fix: Disable rate limit in compare scenario

refs #5129

Change-Id: Iba2703bdc5153024dbdfcb7e4c043f52964736f9

.gitignore

@@ -26,5 +26,4 @@ __pycache__/
 *.py[cod]
 
 # Other
-/unit-tests.conf
-/VERSION
+/VERSION.info

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "websocketpp"]
     path = websocketpp
-    url = https://github.com/zaphoyd/websocketpp.git
+    url = https://github.com/cawka/websocketpp.git

.jenkins

@@ -1,10 +1,32 @@
 #!/usr/bin/env bash
 set -e
+source .jenkins.d/util.sh
 
-DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+export CACHE_DIR=${CACHE_DIR:-/tmp}
+export WAF_JOBS=${WAF_JOBS:-1}
+[[ $JOB_NAME == *"code-coverage" ]] && export DISABLE_ASAN=yes
 
-for file in "$DIR"/.jenkins.d/*; do
+nanos() {
+    # Cannot use date(1) because macOS does not support %N format specifier
+    python3 -c 'import time; print(int(time.time() * 1e9))'
+}
+
+for file in .jenkins.d/*; do
     [[ -f $file && -x $file ]] || continue
-    echo "Run: $file"
+
+    if [[ -n $TRAVIS ]]; then
+        label=$(basename "$file" | sed -E 's/[[:digit:]]+-(.*)\..*/\1/')
+        echo -ne "travis_fold:start:${label}\r"
+        echo -ne "travis_time:start:${label}\r"
+        start=$(nanos)
+    fi
+
+    echo "\$ $file"
     "$file"
+
+    if [[ -n $TRAVIS ]]; then
+        finish=$(nanos)
+        echo -ne "travis_time:end:${label}:start=${start},finish=${finish},duration=$((finish-start)),event=${label}\r"
+        echo -ne "travis_fold:end:${label}\r"
+    fi
 done

.jenkins.d/00-deps.sh

@@ -1,49 +1,41 @@
 #!/usr/bin/env bash
-set -e
-
-JDIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
-source "$JDIR"/util.sh
-
-set -x
+set -ex
 
 if has OSX $NODE_LABELS; then
     FORMULAE=(boost openssl pkg-config)
-    brew update
-    if [[ -n $TRAVIS ]]; then
-        # travis images come with a large number of brew packages
-        # pre-installed, don't waste time upgrading all of them
-        for FORMULA in "${FORMULAE[@]}"; do
-            brew outdated $FORMULA || brew upgrade $FORMULA
-        done
-    else
-        brew upgrade
+    if has OSX-10.13 $NODE_LABELS || has OSX-10.14 $NODE_LABELS; then
+        FORMULAE+=(python)
     fi
-    brew install "${FORMULAE[@]}"
-    brew cleanup
-fi
 
-if has Ubuntu $NODE_LABELS; then
+    if [[ -n $TRAVIS ]]; then
+        # Travis images come with a large number of pre-installed
+        # brew packages, don't waste time upgrading all of them
+        brew list --versions "${FORMULAE[@]}" || brew update
+        for FORMULA in "${FORMULAE[@]}"; do
+            brew list --versions "$FORMULA" || brew install "$FORMULA"
+        done
+        # Ensure /usr/local/opt/openssl exists
+        brew reinstall openssl
+    else
+        brew update
+        brew upgrade
+        brew install "${FORMULAE[@]}"
+        brew cleanup
+    fi
+
+elif has Ubuntu $NODE_LABELS; then
     sudo apt-get -qq update
-    sudo apt-get -qy install build-essential pkg-config libboost-all-dev \
-                             libsqlite3-dev libssl-dev libpcap-dev
+    sudo apt-get -qy install build-essential pkg-config python3-minimal \
+                             libboost-all-dev libssl-dev libsqlite3-dev \
+                             libpcap-dev libsystemd-dev
 
     if [[ $JOB_NAME == *"code-coverage" ]]; then
-        sudo apt-get -qy install lcov libgd-perl python-setuptools
-        sudo easy_install --upgrade gcovr
+        sudo apt-get -qy install gcovr lcov
     fi
-fi
 
-if has CentOS $NODE_LABELS; then
-    sudo yum -y install yum-utils pkgconfig libpcap-devel \
-                        openssl-devel libtranslit-icu \
-                        python-devel sqlite-devel \
-                        devtoolset-7-libasan-devel \
-                        devtoolset-7-liblsan-devel
-    sudo yum -y groupinstall 'Development Tools'
-
-    svn checkout https://github.com/cmscaltech/sandie-ndn/trunk/packaging/RPMS/x86_64
-    sudo rpm -U --force x86_64/boost-license*
-    sudo rpm -U --force x86_64/boost-doc-html*
-    sudo rpm -U --force x86_64/libboost*
-    sudo rpm -U --force x86_64/boost-devel*
+elif has CentOS-8 $NODE_LABELS; then
+    sudo dnf config-manager --enable PowerTools
+    sudo dnf -y install gcc-c++ libasan pkgconf-pkg-config python3 \
+                        boost-devel openssl-devel sqlite-devel \
+                        libpcap-devel systemd-devel
 fi

.jenkins.d/01-ndn-cxx.sh

@@ -1,12 +1,7 @@
 #!/usr/bin/env bash
-set -e
+set -ex
 
-JDIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
-source "$JDIR"/util.sh
-
-set -x
-
-pushd "${CACHE_DIR:-/tmp}" >/dev/null
+pushd "$CACHE_DIR" >/dev/null
 
 INSTALLED_VERSION=
 if has OSX $NODE_LABELS; then
@@ -22,17 +17,15 @@ if [[ -z $INSTALLED_VERSION ]]; then
     INSTALLED_VERSION=$(git -C ndn-cxx rev-parse HEAD 2>/dev/null || echo NONE)
 fi
 
-sudo rm -Rf ndn-cxx-latest
-
-git clone --depth 1 git://github.com/named-data/ndn-cxx ndn-cxx-latest
-
+sudo rm -rf ndn-cxx-latest
+git clone --depth 1 https://github.com/named-data/ndn-cxx.git ndn-cxx-latest
 LATEST_VERSION=$(git -C ndn-cxx-latest rev-parse HEAD 2>/dev/null || echo UNKNOWN)
 
 if [[ $INSTALLED_VERSION != $LATEST_VERSION ]]; then
-    sudo rm -Rf ndn-cxx
+    sudo rm -rf ndn-cxx
     mv ndn-cxx-latest ndn-cxx
 else
-    sudo rm -Rf ndn-cxx-latest
+    sudo rm -rf ndn-cxx-latest
 fi
 
 sudo rm -f /usr/local/bin/ndnsec*
@@ -42,15 +35,21 @@ sudo rm -f /usr/local/lib{,64}/pkgconfig/libndn-cxx.pc
 
 pushd ndn-cxx >/dev/null
 
-./waf configure --color=yes --enable-shared --disable-static --without-osx-keychain
-./waf build --color=yes -j${WAF_JOBS:-1}
-sudo_preserve_env PATH -- ./waf install --color=yes
+if has CentOS-8 $NODE_LABELS; then
+    # https://bugzilla.redhat.com/show_bug.cgi?id=1721553
+    PCH="--without-pch"
+fi
+
+./waf --color=yes configure --disable-static --enable-shared --without-osx-keychain $PCH
+./waf --color=yes build -j$WAF_JOBS
+sudo_preserve_env PATH -- ./waf --color=yes install
 
 popd >/dev/null
 popd >/dev/null
 
+if has CentOS-8 $NODE_LABELS; then
+    sudo tee /etc/ld.so.conf.d/ndn.conf >/dev/null <<< /usr/local/lib64
+fi
 if has Linux $NODE_LABELS; then
     sudo ldconfig
-elif has FreeBSD10 $NODE_LABELS; then
-    sudo ldconfig -m
 fi

.jenkins.d/10-build.sh

@@ -1,45 +1,41 @@
 #!/usr/bin/env bash
-set -e
+set -ex
 
-JDIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
-source "$JDIR"/util.sh
-
-set -x
-
-git submodule init
 git submodule sync
-git submodule update
+git submodule update --init
 
-if [[ $JOB_NAME == *"code-coverage" ]]; then
-    COVERAGE="--with-coverage"
-elif [[ -z $DISABLE_ASAN ]]; then
+if [[ -z $DISABLE_ASAN ]]; then
     ASAN="--with-sanitizer=address"
 fi
-
-# Cleanup
-sudo_preserve_env PATH -- ./waf --color=yes distclean
-
-if [[ $JOB_NAME != *"code-coverage" && $JOB_NAME != *"limited-build" ]]; then
-  # Configure/build in optimized mode with tests
-  ./waf --color=yes configure --with-tests
-  ./waf --color=yes build -j${WAF_JOBS:-1}
-
-  # Cleanup
-  sudo_preserve_env PATH -- ./waf --color=yes distclean
-
-  # Configure/build in optimized mode without tests, but with "other tests"
-  ./waf --color=yes configure --with-other-tests
-  ./waf --color=yes build -j${WAF_JOBS:-1}
-
-  # Cleanup
-  sudo_preserve_env PATH -- ./waf --color=yes distclean
+if [[ $JOB_NAME == *"code-coverage" ]]; then
+    COVERAGE="--with-coverage"
+fi
+if has CentOS-8 $NODE_LABELS; then
+    # https://bugzilla.redhat.com/show_bug.cgi?id=1721553
+    PCH="--without-pch"
 fi
 
-# Configure/build in debug mode with tests and without precompiled headers
-./waf --color=yes configure --debug --with-tests --without-pch $ASAN $COVERAGE
-./waf --color=yes build -j${WAF_JOBS:-1}
+if [[ $JOB_NAME != *"code-coverage" && $JOB_NAME != *"limited-build" ]]; then
+    # Build in release mode with tests and without precompiled headers
+    ./waf --color=yes configure --with-tests --without-pch
+    ./waf --color=yes build -j$WAF_JOBS
 
-# (tests will be run against debug version)
+    # Cleanup
+    ./waf --color=yes distclean
+
+    # Build in release mode without tests, but with "other tests"
+    ./waf --color=yes configure --with-other-tests $PCH
+    ./waf --color=yes build -j$WAF_JOBS
+
+    # Cleanup
+    ./waf --color=yes distclean
+fi
+
+# Build in debug mode with tests
+./waf --color=yes configure --debug --with-tests $ASAN $COVERAGE $PCH
+./waf --color=yes build -j$WAF_JOBS
+
+# (tests will be run against the debug version)
 
 # Install
 sudo_preserve_env PATH -- ./waf --color=yes install

.jenkins.d/20-tests.sh

@@ -1,13 +1,8 @@
 #!/usr/bin/env bash
-set -e
-
-JDIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
-source "$JDIR"/util.sh
-
-set -x
+set -ex
 
 # Prepare environment
-rm -Rf ~/.ndn
+rm -rf ~/.ndn
 
 if has OSX $NODE_LABELS; then
     security unlock-keychain -p named-data
@@ -15,34 +10,25 @@ fi
 
 ndnsec-keygen "/tmp/jenkins/$NODE_NAME" | ndnsec-install-cert -
 
-BOOST_VERSION=$(python -c "import sys; sys.path.append('build/c4che'); import _cache; print(_cache.BOOST_VERSION_NUMBER);")
-
-ut_log_args() {
-    if (( BOOST_VERSION >= 106200 )); then
-        echo --logger=HRF,test_suite,stdout:XML,all,build/xunit-${1:-report}.xml
-    else
-        if [[ -n $XUNIT ]]; then
-            echo --log_level=all $( (( BOOST_VERSION >= 106000 )) && echo -- ) \
-                 --log_format2=XML --log_sink2=build/xunit-${1:-report}.xml
-        else
-            echo --log_level=test_suite
-        fi
-    fi
-}
-
+# https://github.com/google/sanitizers/wiki/AddressSanitizerFlags
 ASAN_OPTIONS="color=always"
-ASAN_OPTIONS+=":detect_leaks=false"
-ASAN_OPTIONS+=":detect_stack_use_after_return=true"
-ASAN_OPTIONS+=":check_initialization_order=true"
-ASAN_OPTIONS+=":strict_init_order=true"
-ASAN_OPTIONS+=":detect_invalid_pointer_pairs=1"
-ASAN_OPTIONS+=":detect_container_overflow=false"
-ASAN_OPTIONS+=":strict_string_checks=true"
+ASAN_OPTIONS+=":check_initialization_order=1"
+ASAN_OPTIONS+=":detect_stack_use_after_return=1"
+ASAN_OPTIONS+=":strict_init_order=1"
+ASAN_OPTIONS+=":strict_string_checks=1"
+ASAN_OPTIONS+=":detect_invalid_pointer_pairs=2"
+ASAN_OPTIONS+=":detect_container_overflow=0"
+ASAN_OPTIONS+=":detect_leaks=0"
 ASAN_OPTIONS+=":strip_path_prefix=${PWD}/"
 export ASAN_OPTIONS
 
 export BOOST_TEST_BUILD_INFO=1
 export BOOST_TEST_COLOR_OUTPUT=1
+export BOOST_TEST_DETECT_MEMORY_LEAK=0
+
+ut_log_args() {
+    echo --logger=HRF,test_suite,stdout:XML,all,build/xunit-log${1:+-$1}.xml
+}
 
 # First run all tests as unprivileged user
 ./build/unit-tests-core $(ut_log_args core)
@@ -52,7 +38,7 @@ export BOOST_TEST_COLOR_OUTPUT=1
 
 # Then use sudo to run those tests that need superuser powers
 sudo_preserve_env ASAN_OPTIONS BOOST_TEST_COLOR_OUTPUT -- \
-    ./build/unit-tests-core -t TestPrivilegeHelper $(ut_log_args core-privilege)
+    ./build/unit-tests-daemon -t TestPrivilegeHelper $(ut_log_args daemon-privilege-helper)
 sudo_preserve_env ASAN_OPTIONS BOOST_TEST_COLOR_OUTPUT -- \
     ./build/unit-tests-daemon -t Face/*Ethernet* $(ut_log_args daemon-ethernet)
 sudo_preserve_env ASAN_OPTIONS BOOST_TEST_COLOR_OUTPUT -- \

.jenkins.d/30-coverage.sh

@@ -1,10 +1,5 @@
 #!/usr/bin/env bash
-set -e
-
-JDIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
-source "$JDIR"/util.sh
-
-set -x
+set -ex
 
 if [[ $JOB_NAME == *"code-coverage" ]]; then
     gcovr --object-directory=build \
@@ -33,7 +28,6 @@ if [[ $JOB_NAME == *"code-coverage" ]]; then
 
     genhtml --branch-coverage \
             --demangle-cpp \
-            --frames \
             --legend \
             --output-directory build/coverage \
             --title "NFD unit tests" \

.jenkins.d/README.md

@@ -1,36 +1,28 @@
-CONTINUOUS INTEGRATION SCRIPTS
-==============================
+# CONTINUOUS INTEGRATION SCRIPTS
 
-Environment Variables Used in Build Scripts
--------------------------------------------
+## Environment Variables Used in Build Scripts
 
-- `NODE_LABELS`: the variable defines a list of OS properties.  The set values are used by the
-  build scripts to select proper behavior for different OS.
+- `NODE_LABELS`: space-separated list of platform properties. The included values are used by
+  the build scripts to select the proper behavior for different operating systems and versions.
 
-  The list should include at least `[OS_TYPE]`, `[DISTRO_TYPE]`, and `[DISTRO_VERSION]`.
+  The list should normally contain `[OS_TYPE]`, `[DISTRO_TYPE]`, and `[DISTRO_VERSION]`.
 
-  Possible values for Linux:
+  Example values:
 
-  * `[OS_TYPE]`: `Linux`
-  * `[DISTRO_TYPE]`: `Ubuntu`
-  * `[DISTRO_VERSION]`: `Ubuntu-16.04`, `Ubuntu-18.04`
+  - `[OS_TYPE]`: `Linux`, `OSX`
+  - `[DISTRO_TYPE]`: `Ubuntu`, `CentOS`
+  - `[DISTRO_VERSION]`: `Ubuntu-16.04`, `Ubuntu-18.04`, `CentOS-8`, `OSX-10.14`, `OSX-10.15`
 
-  Possible values for OS X / macOS:
-
-  * `[OS_TYPE]`: `OSX`
-  * `[DISTRO_TYPE]`: `OSX` (can be absent)
-  * `[DISTRO_VERSION]`: `OSX-10.11`, `OSX-10.12`, `OSX-10.13`
-
-- `JOB_NAME`: optional variable to define type of the job.  Depending on the defined job type,
+- `JOB_NAME`: optional variable that defines the type of build job. Depending on the job type,
   the build scripts can perform different tasks.
 
   Possible values:
 
-  * empty: default build process
-  * `code-coverage` (Linux OS is assumed): debug build with tests and code coverage analysis
-  * `limited-build`: only a single debug build with tests
+  - empty: default build task
+  - `code-coverage`: debug build with tests and code coverage analysis (Ubuntu Linux is assumed)
+  - `limited-build`: only a single debug build with tests
 
-- `CACHE_DIR`: the variable defines a path to folder containing cached files from previous builds,
-  e.g., a compiled version of ndn-cxx library.  If not set, `/tmp` is used.
+- `CACHE_DIR`: directory containing cached files from previous builds, e.g., a compiled version
+  of ndn-cxx. If not set, `/tmp` is used.
 
-- `WAF_JOBS`: number of parallel build jobs used by waf, defaults to 1.
+- `WAF_JOBS`: number of parallel build threads used by waf, defaults to 1.

.jenkins.d/util.sh

@@ -16,6 +16,7 @@ has() {
     set ${saved_xtrace}
     return ${ret}
 }
+export -f has
 
 sudo_preserve_env() {
     local saved_xtrace
@@ -35,3 +36,4 @@ sudo_preserve_env() {
     set ${saved_xtrace}
     sudo env "${vars[@]}" "$@"
 }
+export -f sudo_preserve_env

.mailmap

@@ -0,0 +1,14 @@
+<aa@cs.fiu.edu> <alexander.afanasyev@ucla.edu>
+<davidepesa@gmail.com> <davide.pesavento@lip6.fr>
+<enewberry@email.arizona.edu> <enewberry@cs.arizona.edu>
+Vince Lehman <vslehman@memphis.edu> <vlehman1@gmail.com>
+<lybmath2009@gmail.com> <lybmath@ucla.edu>
+Hila Ben Abraham <hilata@gmail.com>
+<tuyukai1994@gmail.com> <tyk@bupt.edu.cn>
+Haowei Yuan <hyuan@wustl.edu>
+Minsheng Zhang <jimmyzms5@gmail.com>
+Spyridon Mastorakis <spiros.mastorakis@gmail.com>
+Md Ashiqur Rahman <marahman@email.arizona.edu>
+Yumin Xia <me@yumin-xia.com>
+<chghasemi@cs.arizona.edu> <chavoosh.ghasemi@gmail.com>
+Tai-Lin Chu <tailinchu@gmail.com>

.travis.yml

@@ -1,97 +1,115 @@
+version: ~> 1.0
 language: cpp
-dist: xenial
-sudo: required
+os: linux
+dist: bionic
+
+arch:
+  - amd64
+  #- arm64   # Too slow, exceeds time limit
+  #- ppc64le # Fails transport tests
+  #- s390x   # Fails transport tests
+
 env:
-  global:
-    - JOB_NAME=limited-build
-    - WAF_JOBS=2
+  - COMPILER=g++-7
+  - COMPILER=g++-9
+  - COMPILER=clang++-6.0
+  - COMPILER=clang++-9
 
-matrix:
+jobs:
   include:
-    # Linux/gcc
-    # https://launchpad.net/~ubuntu-toolchain-r/+archive/ubuntu/test/+packages
-    - os: linux
-      env: COMPILER=g++-5
-    - os: linux
-      env: COMPILER=g++-6
-    - os: linux
-      env: COMPILER=g++-7
-    - os: linux
-      env: COMPILER=g++-8
+    # Linux
+    - env: COMPILER=g++-5
+    - env: COMPILER=g++-6
+    - env: COMPILER=g++-8
+    - env: COMPILER=clang++-4.0
+    - env: COMPILER=clang++-5.0
+    - env: COMPILER=clang++-7
+    - env: COMPILER=clang++-8
+    - env: COMPILER=clang++-10
+    - env: COMPILER=clang++-11
+    - env: COMPILER=clang++-12
 
-    # Linux/clang
-    # https://apt.llvm.org/
-    - os: linux
-      env: COMPILER=clang++-3.6
-    - os: linux
-      env: COMPILER=clang++-3.7 DISABLE_ASAN=yes
-    - os: linux
-      env: COMPILER=clang++-3.8
-    - os: linux
-      env: COMPILER=clang++-3.9
-    - os: linux
-      env: COMPILER=clang++-4.0
-    - os: linux
-      env: COMPILER=clang++-5.0
-    - os: linux
-      env: COMPILER=clang++-6.0
-    - os: linux
-      env: COMPILER=clang++-7
-    - os: linux
-      env: COMPILER=clang++-8
-
-    # macOS/clang
-    # https://docs.travis-ci.com/user/reference/osx/#OS-X-Version
-    - os: osx
-      osx_image: xcode7.3
-      env: OSX_VERSION=10.11
-    - os: osx
-      osx_image: xcode8
-      env: OSX_VERSION=10.11
-    - os: osx
-      osx_image: xcode8.3
-      env: OSX_VERSION=10.12
-    - os: osx
-      osx_image: xcode9.2
-      env: OSX_VERSION=10.12
+    # macOS
     - os: osx
       osx_image: xcode9.4
-      env: OSX_VERSION=10.13
+      env: # default compiler
     - os: osx
-      osx_image: xcode10
-      env: OSX_VERSION=10.13
+      osx_image: xcode10.1
+      env: # default compiler
+    - os: osx
+      osx_image: xcode10.3
+      env: # default compiler
+    - os: osx
+      osx_image: xcode11.3
+      env: # default compiler
+    - os: osx
+      osx_image: xcode11.6
+      env: # default compiler
+    - os: osx
+      osx_image: xcode12
+      env: # default compiler
 
   allow_failures:
-    - env: COMPILER=clang++-3.6
-    - env: COMPILER=clang++-3.7 DISABLE_ASAN=yes
-    - env: COMPILER=clang++-8
+    - env: COMPILER=g++-5
+    - env: COMPILER=g++-6
+    - env: COMPILER=clang++-4.0
+    - env: COMPILER=clang++-12
 
   fast_finish: true
 
-install: |
+before_install:
+  - |
+    : Adding apt repositories
     case ${COMPILER} in
-      g++-[6789])
+      g++-9)
+        # https://launchpad.net/~ubuntu-toolchain-r/+archive/ubuntu/test/+packages
         travis_retry sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
         travis_retry sudo apt-get -qq update
-        travis_retry sudo apt-get -qy install "${COMPILER}"
         ;;
-      clang++-*)
-        CLANG_VERSION=${COMPILER/clang++}
-        if [[ ${CLANG_VERSION} != "-3."* ]]; then
-          travis_retry wget -nv -O - "https://apt.llvm.org/llvm-snapshot.gpg.key" | sudo apt-key add -
-          travis_retry sudo add-apt-repository -y "deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial${CLANG_VERSION/-8} main"
-        fi
+      clang++-1?)
+        # https://apt.llvm.org/
+        LLVM_REPO=${COMPILER/clang++/llvm-toolchain-${TRAVIS_DIST}}
+        travis_retry wget -nv -O - "https://apt.llvm.org/llvm-snapshot.gpg.key" | sudo apt-key add -
+        travis_retry sudo add-apt-repository -y "deb http://apt.llvm.org/${TRAVIS_DIST}/ ${LLVM_REPO%-12} main"
         travis_retry sudo apt-get -qq update
-        travis_retry sudo apt-get -qy install "clang${CLANG_VERSION}"
         ;;
     esac
 
+install:
+  - |
+    : Installing C++ compiler
+    if [[ -n ${COMPILER} ]]; then
+      travis_retry sudo apt-get -qy install ${COMPILER/clang++/clang}
+    fi
+
 before_script:
-  - if [[ ${TRAVIS_OS_NAME} == linux ]]; then export NODE_LABELS="Linux Ubuntu Ubuntu-16.04"; fi
-  - if [[ ${TRAVIS_OS_NAME} == osx ]]; then export NODE_LABELS="OSX OSX-${OSX_VERSION}"; fi
-  - if [[ -n ${COMPILER} ]]; then export CXX=${COMPILER}; fi
+  - |
+    : Setting environment variables
+    if [[ -n ${COMPILER} ]]; then
+      export CXX=${COMPILER}
+    fi
+    case ${TRAVIS_OS_NAME} in
+      linux)  export NODE_LABELS="Linux Ubuntu Ubuntu-18.04" ;;
+      osx)    export NODE_LABELS="OSX OSX-$(sw_vers -productVersion | cut -d . -f -2)" ;;
+    esac
+    export JOB_NAME=limited-build
+    export WAF_JOBS=2
+  - |
+    : Enabling workarounds
+    case "${TRAVIS_CPU_ARCH},${COMPILER}" in
+      ppc64le,g++-7)
+        # AddressSanitizer does not seem to be working
+        export DISABLE_ASAN=yes
+        ;;
+      *,clang++-8)
+        # https://bugs.llvm.org/show_bug.cgi?id=40808
+        export DISABLE_ASAN=yes
+        ;;
+    esac
+    if [[ ${TRAVIS_OS_NAME} == linux ]]; then
+      sudo sysctl -e -w net.ipv6.conf.all.disable_ipv6=0
+    fi
   - ${CXX:-c++} --version
-  - python --version
 
 script:
   - ./.jenkins

.waf-tools/boost.py

@@ -56,6 +56,7 @@ from waflib.TaskGen import feature, after_method
 
 BOOST_LIBS = ['/usr/lib', '/usr/local/lib', '/opt/local/lib', '/sw/lib', '/lib']
 BOOST_INCLUDES = ['/usr/include', '/usr/local/include', '/opt/local/include', '/sw/include']
+
 BOOST_VERSION_FILE = 'boost/version.hpp'
 BOOST_VERSION_CODE = '''
 #include <iostream>
@@ -90,13 +91,18 @@ int main() { boost::thread t; }
 
 BOOST_LOG_CODE = '''
 #include <boost/log/trivial.hpp>
+int main() { BOOST_LOG_TRIVIAL(info) << "boost_log is working"; }
+'''
+
+BOOST_LOG_SETUP_CODE = '''
+#include <boost/log/trivial.hpp>
 #include <boost/log/utility/setup/console.hpp>
 #include <boost/log/utility/setup/common_attributes.hpp>
 int main() {
 	using namespace boost::log;
 	add_common_attributes();
 	add_console_log(std::clog, keywords::format = "%Message%");
-	BOOST_LOG_TRIVIAL(debug) << "log is working" << std::endl;
+	BOOST_LOG_TRIVIAL(info) << "boost_log_setup is working";
 }
 '''
 
@@ -145,7 +151,7 @@ def options(opt):
 	opt.add_option('--boost-abi', type='string', default='', dest='boost_abi',
 				   help='''select libraries with tags (gd for debug, static is automatically added),
 				   see doc Boost, Getting Started, chapter 6.1''')
-	opt.add_option('--boost-linkage_autodetect', action="store_true", dest='boost_linkage_autodetect',
+	opt.add_option('--boost-linkage_autodetect', action='store_true', dest='boost_linkage_autodetect',
 				   help="auto-detect boost linkage options (don't get used to it / might break other stuff)")
 	opt.add_option('--boost-toolset', type='string',
 				   default='', dest='boost_toolset',
@@ -175,7 +181,7 @@ def boost_get_version(self, d):
 		try:
 			txt = node.read()
 		except EnvironmentError:
-			Logs.error("Could not read the file %r" % node.abspath())
+			Logs.error('Could not read the file %r' % node.abspath())
 		else:
 			re_but1 = re.compile('^#define\\s+BOOST_LIB_VERSION\\s+"(.+)"', re.M)
 			m1 = re_but1.search(txt)
@@ -183,7 +189,7 @@ def boost_get_version(self, d):
 			m2 = re_but2.search(txt)
 			if m1 and m2:
 				return (m1.group(1), m2.group(1))
-	return self.check_cxx(fragment=BOOST_VERSION_CODE, includes=[d], execute=True, define_ret=True).split(":")
+	return self.check_cxx(fragment=BOOST_VERSION_CODE, includes=[d], execute=True, define_ret=True).split(':')
 
 @conf
 def boost_get_includes(self, *k, **kw):
@@ -194,10 +200,10 @@ def boost_get_includes(self, *k, **kw):
 		if self.__boost_get_version_file(d):
 			return d
 	if includes:
-		self.end_msg('headers not found in %s' % includes)
+		self.end_msg('headers not found in %s' % includes, 'YELLOW')
 		self.fatal('The configuration failed')
 	else:
-		self.end_msg('headers not found, please provide a --boost-includes argument (see help)')
+		self.end_msg('headers not found, please provide a --boost-includes argument (see help)', 'YELLOW')
 		self.fatal('The configuration failed')
 
 
@@ -240,10 +246,10 @@ def __boost_get_libs_path(self, *k, **kw):
 					break
 	if not path:
 		if libs:
-			self.end_msg('libs not found in %s' % libs)
+			self.end_msg('libs not found in %s' % libs, 'YELLOW')
 			self.fatal('The configuration failed')
 		else:
-			self.end_msg('libs not found, please provide a --boost-libs argument (see help)')
+			self.end_msg('libs not found, please provide a --boost-libs argument (see help)', 'YELLOW')
 			self.fatal('The configuration failed')
 
 	self.to_log('Found the boost path in %r with the libraries:' % path)
@@ -313,7 +319,7 @@ def boost_get_libs(self, *k, **kw):
 					libs.append(format_lib_name(file.name))
 					break
 			else:
-				self.end_msg('lib %s not found in %s' % (lib, path.abspath()))
+				self.end_msg('lib %s not found in %s' % (lib, path.abspath()), 'YELLOW')
 				self.fatal('The configuration failed')
 		return libs
 
@@ -354,7 +360,7 @@ def _check_pthread_flag(self, *k, **kw):
 	#      ... -mt is also the pthreads flag for HP/aCC
 	# -lpthread: GNU Linux, etc.
 	# --thread-safe: KAI C++
-	if Utils.unversioned_sys_platform() == "sunos":
+	if Utils.unversioned_sys_platform() == 'sunos':
 		# On Solaris (at least, for some versions), libc contains stubbed
 		# (non-functional) versions of the pthreads routines, so link-based
 		# tests will erroneously succeed.  (We need to link with -pthreads/-mt/
@@ -362,23 +368,22 @@ def _check_pthread_flag(self, *k, **kw):
 		# a function called by this macro, so we could check for that, but
 		# who knows whether they'll stub that too in a future libc.)  So,
 		# we'll just look for -pthreads and -lpthread first:
-		boost_pthread_flags = ["-pthreads", "-lpthread", "-mt", "-pthread"]
+		boost_pthread_flags = ['-pthreads', '-lpthread', '-mt', '-pthread']
 	else:
-		boost_pthread_flags = ["", "-lpthreads", "-Kthread", "-kthread", "-llthread", "-pthread",
-							   "-pthreads", "-mthreads", "-lpthread", "--thread-safe", "-mt"]
+		boost_pthread_flags = ['', '-lpthreads', '-Kthread', '-kthread', '-llthread', '-pthread',
+							   '-pthreads', '-mthreads', '-lpthread', '--thread-safe', '-mt']
 
 	for boost_pthread_flag in boost_pthread_flags:
 		try:
 			self.env.stash()
 			self.env['CXXFLAGS_%s' % var] += [boost_pthread_flag]
 			self.env['LINKFLAGS_%s' % var] += [boost_pthread_flag]
-			self.check_cxx(code=PTHREAD_CODE, msg=None, use=var, execute=False)
-
+			self.check_cxx(code=PTHREAD_CODE, msg=None, use=var, execute=False, quiet=True)
 			self.end_msg(boost_pthread_flag)
 			return
 		except self.errors.ConfigurationError:
 			self.env.revert()
-	self.end_msg('None')
+	self.end_msg('none')
 
 @conf
 def check_boost(self, *k, **kw):
@@ -403,21 +408,24 @@ def check_boost(self, *k, **kw):
 
 	var = kw.get('uselib_store', 'BOOST')
 
-	self.find_program('dpkg-architecture', var='DPKG_ARCHITECTURE', mandatory=False)
-	if self.env.DPKG_ARCHITECTURE:
-		deb_host_multiarch = self.cmd_and_log([self.env.DPKG_ARCHITECTURE[0], '-qDEB_HOST_MULTIARCH'])
-		BOOST_LIBS.insert(0, '/usr/lib/%s' % deb_host_multiarch.strip())
+	if not self.env.DONE_FIND_BOOST_COMMON:
+		self.find_program('dpkg-architecture', var='DPKG_ARCHITECTURE', mandatory=False)
+		if self.env.DPKG_ARCHITECTURE:
+			deb_host_multiarch = self.cmd_and_log([self.env.DPKG_ARCHITECTURE[0], '-qDEB_HOST_MULTIARCH'])
+			BOOST_LIBS.insert(0, '/usr/lib/%s' % deb_host_multiarch.strip())
 
-	self.start_msg('Checking boost includes')
-	self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
-	versions = self.boost_get_version(inc)
-	self.env.BOOST_VERSION = versions[0]
-	self.env.BOOST_VERSION_NUMBER = int(versions[1])
-	self.end_msg("%d.%d.%d" % (int(versions[1]) / 100000,
-							   int(versions[1]) / 100 % 1000,
-							   int(versions[1]) % 100))
-	if Logs.verbose:
-		Logs.pprint('CYAN', '	path : %s' % self.env['INCLUDES_%s' % var])
+		self.start_msg('Checking boost includes')
+		self.env['INCLUDES_%s' % var] = inc = self.boost_get_includes(**params)
+		versions = self.boost_get_version(inc)
+		self.env.BOOST_VERSION = versions[0]
+		self.env.BOOST_VERSION_NUMBER = int(versions[1])
+		self.end_msg('%d.%d.%d' % (int(versions[1]) / 100000,
+								   int(versions[1]) / 100 % 1000,
+								   int(versions[1]) % 100))
+		if Logs.verbose:
+			Logs.pprint('CYAN', '	path : %s' % self.env['INCLUDES_%s' % var])
+
+		self.env.DONE_FIND_BOOST_COMMON = True
 
 	if not params['lib'] and not params['stlib']:
 		return
@@ -429,7 +437,7 @@ def check_boost(self, *k, **kw):
 	self.env['STLIBPATH_%s' % var] = [path]
 	self.env['LIB_%s' % var] = libs
 	self.env['STLIB_%s' % var] = stlibs
-	self.end_msg('ok')
+	self.end_msg(' '.join(libs + stlibs))
 	if Logs.verbose:
 		Logs.pprint('CYAN', '	path : %s' % path)
 		Logs.pprint('CYAN', '	shared libs : %s' % libs)
@@ -450,15 +458,18 @@ def check_boost(self, *k, **kw):
 			self.check_cxx(fragment=BOOST_ERROR_CODE, use=var, execute=False)
 		if has_lib('thread'):
 			self.check_cxx(fragment=BOOST_THREAD_CODE, use=var, execute=False)
-		if has_lib('log'):
+		if has_lib('log') or has_lib('log_setup'):
 			if not has_lib('thread'):
 				self.env['DEFINES_%s' % var] += ['BOOST_LOG_NO_THREADS']
-			if has_shlib('log'):
+			if has_shlib('log') or has_shlib('log_setup'):
 				self.env['DEFINES_%s' % var] += ['BOOST_LOG_DYN_LINK']
-			self.check_cxx(fragment=BOOST_LOG_CODE, use=var, execute=False)
+			if has_lib('log_setup'):
+				self.check_cxx(fragment=BOOST_LOG_SETUP_CODE, use=var, execute=False)
+			else:
+				self.check_cxx(fragment=BOOST_LOG_CODE, use=var, execute=False)
 
 	if params.get('linkage_autodetect', False):
-		self.start_msg("Attempting to detect boost linkage flags")
+		self.start_msg('Attempting to detect boost linkage flags')
 		toolset = self.boost_get_toolset(kw.get('toolset', ''))
 		if toolset in ('vc',):
 			# disable auto-linking feature, causing error LNK1181
@@ -480,10 +491,10 @@ def check_boost(self, *k, **kw):
 			# we attempt to play with some known-to-work CXXFLAGS combinations
 			for cxxflags in (['/MD', '/EHsc'], []):
 				self.env.stash()
-				self.env["CXXFLAGS_%s" % var] += cxxflags
+				self.env['CXXFLAGS_%s' % var] += cxxflags
 				try:
 					try_link()
-					self.end_msg("ok: winning cxxflags combination: %s" % (self.env["CXXFLAGS_%s" % var]))
+					self.end_msg('ok: winning cxxflags combination: %s' % (self.env['CXXFLAGS_%s' % var]))
 					exc = None
 					break
 				except Errors.ConfigurationError as e:
@@ -491,17 +502,17 @@ def check_boost(self, *k, **kw):
 					exc = e
 
 			if exc is not None:
-				self.end_msg("Could not auto-detect boost linking flags combination, you may report it to boost.py author", ex=exc)
+				self.end_msg('Could not auto-detect boost linking flags combination, you may report it to boost.py author', ex=exc)
 				self.fatal('The configuration failed')
 		else:
-			self.end_msg("Boost linkage flags auto-detection not implemented (needed ?) for this toolchain")
+			self.end_msg('Boost linkage flags auto-detection not implemented (needed ?) for this toolchain')
 			self.fatal('The configuration failed')
 	else:
 		self.start_msg('Checking for boost linkage')
 		try:
 			try_link()
 		except Errors.ConfigurationError as e:
-			self.end_msg("Could not link against boost libraries using supplied options")
+			self.end_msg('Could not link against boost libraries using supplied options', 'YELLOW')
 			self.fatal('The configuration failed')
 		self.end_msg('ok')
 

.waf-tools/compiler-features.py

@@ -1,30 +0,0 @@
-# -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
-
-"""
-Copyright (c) 2014-2016,  Regents of the University of California,
-                          Arizona Board of Regents,
-                          Colorado State University,
-                          University Pierre & Marie Curie, Sorbonne University,
-                          Washington University in St. Louis,
-                          Beijing Institute of Technology,
-                          The University of Memphis.
-
-This file is part of NFD (Named Data Networking Forwarding Daemon).
-See AUTHORS.md for complete list of NFD authors and contributors.
-
-NFD is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version.
-
-NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE.  See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with
-NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
-"""
-
-from waflib.Configure import conf
-
-def configure(conf):
-    pass

.waf-tools/default-compiler-flags.py

@@ -1,10 +1,11 @@
 # -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
 
+import platform
 from waflib import Configure, Logs, Utils
 
 def options(opt):
     opt.add_option('--debug', '--with-debug', action='store_true', default=False,
-                   help='Compile in debugging mode with minimal optimizations (-O0 or -Og)')
+                   help='Compile in debugging mode with minimal optimizations (-Og)')
 
 def configure(conf):
     conf.start_msg('Checking C++ compiler version')
@@ -17,15 +18,21 @@ def configure(conf):
     if cxx == 'gcc':
         if ccver < (5, 3, 0):
             errmsg = ('The version of gcc you are using is too old.\n'
-                      'The minimum supported gcc version is 5.3.0.')
+                      'The minimum supported gcc version is 7.4.0.')
+        elif ccver < (7, 4, 0):
+            warnmsg = ('Using a version of gcc older than 7.4.0 is not '
+                       'officially supported and may result in build failures.')
         conf.flags = GccFlags()
     elif cxx == 'clang':
-        if ccver < (3, 6, 0):
+        if Utils.unversioned_sys_platform() == 'darwin' and ccver < (9, 0, 0):
+            errmsg = ('The version of Xcode you are using is too old.\n'
+                      'The minimum supported Xcode version is 9.0.')
+        elif ccver < (4, 0, 0):
             errmsg = ('The version of clang you are using is too old.\n'
-                      'The minimum supported clang version is 3.6.0.')
+                      'The minimum supported clang version is 4.0.')
         conf.flags = ClangFlags()
     else:
-        warnmsg = 'Note: %s compiler is unsupported' % cxx
+        warnmsg = '%s compiler is unsupported' % cxx
         conf.flags = CompilerFlags()
 
     if errmsg:
@@ -33,7 +40,7 @@ def configure(conf):
         conf.fatal(errmsg)
     elif warnmsg:
         conf.end_msg(ccverstr, color='YELLOW')
-        Logs.warn(warnmsg)
+        Logs.warn('WARNING: ' + warnmsg)
     else:
         conf.end_msg(ccverstr)
 
@@ -129,23 +136,28 @@ class GccBasicFlags(CompilerFlags):
     def getGeneralFlags(self, conf):
         flags = super(GccBasicFlags, self).getGeneralFlags(conf)
         flags['CXXFLAGS'] += ['-std=c++14']
+        if Utils.unversioned_sys_platform() == 'linux':
+            flags['LINKFLAGS'] += ['-fuse-ld=gold']
+        elif Utils.unversioned_sys_platform() == 'freebsd':
+            flags['LINKFLAGS'] += ['-fuse-ld=lld']
         return flags
 
     def getDebugFlags(self, conf):
         flags = super(GccBasicFlags, self).getDebugFlags(conf)
-        flags['CXXFLAGS'] += ['-O0',
-                              '-Og', # gcc >= 4.8, clang >= 4.0
+        flags['CXXFLAGS'] += ['-Og',
                               '-g3',
                               '-pedantic',
                               '-Wall',
                               '-Wextra',
                               '-Werror',
+                              '-Wcatch-value=2',
+                              '-Wextra-semi',
                               '-Wnon-virtual-dtor',
                               '-Wno-error=deprecated-declarations', # Bug #3795
                               '-Wno-error=maybe-uninitialized', # Bug #1615
                               '-Wno-unused-parameter',
                               ]
-        flags['LINKFLAGS'] += ['-fuse-ld=gold', '-Wl,-O1']
+        flags['LINKFLAGS'] += ['-Wl,-O1']
         return flags
 
     def getOptimizedFlags(self, conf):
@@ -155,56 +167,61 @@ class GccBasicFlags(CompilerFlags):
                               '-pedantic',
                               '-Wall',
                               '-Wextra',
+                              '-Wcatch-value=2',
+                              '-Wextra-semi',
                               '-Wnon-virtual-dtor',
                               '-Wno-unused-parameter',
                               ]
-        flags['LINKFLAGS'] += ['-fuse-ld=gold', '-Wl,-O1']
+        flags['LINKFLAGS'] += ['-Wl,-O1']
         return flags
 
 class GccFlags(GccBasicFlags):
     def getDebugFlags(self, conf):
         flags = super(GccFlags, self).getDebugFlags(conf)
-        flags['CXXFLAGS'] += ['-fdiagnostics-color']
+        flags['CXXFLAGS'] += ['-fdiagnostics-color',
+                              '-Wredundant-tags',
+                              ]
+        if platform.machine() == 'armv7l' and self.getCompilerVersion(conf) >= (7, 1, 0):
+            flags['CXXFLAGS'] += ['-Wno-psabi'] # Bug #5106
         return flags
 
     def getOptimizedFlags(self, conf):
         flags = super(GccFlags, self).getOptimizedFlags(conf)
-        flags['CXXFLAGS'] += ['-fdiagnostics-color']
+        flags['CXXFLAGS'] += ['-fdiagnostics-color',
+                              '-Wredundant-tags',
+                              ]
+        if platform.machine() == 'armv7l' and self.getCompilerVersion(conf) >= (7, 1, 0):
+            flags['CXXFLAGS'] += ['-Wno-psabi'] # Bug #5106
         return flags
 
 class ClangFlags(GccBasicFlags):
     def getGeneralFlags(self, conf):
         flags = super(ClangFlags, self).getGeneralFlags(conf)
-        if Utils.unversioned_sys_platform() == 'darwin' and self.getCompilerVersion(conf) >= (9, 0, 0):
+        if Utils.unversioned_sys_platform() == 'darwin':
             # Bug #4296
             flags['CXXFLAGS'] += [['-isystem', '/usr/local/include'], # for Homebrew
                                   ['-isystem', '/opt/local/include']] # for MacPorts
+        elif Utils.unversioned_sys_platform() == 'freebsd':
+            # Bug #4790
+            flags['CXXFLAGS'] += [['-isystem', '/usr/local/include']]
         return flags
 
     def getDebugFlags(self, conf):
         flags = super(ClangFlags, self).getDebugFlags(conf)
         flags['CXXFLAGS'] += ['-fcolor-diagnostics',
-                              '-Wextra-semi',
                               '-Wundefined-func-template',
                               '-Wno-unused-local-typedef', # Bugs #2657 and #3209
                               ]
-        version = self.getCompilerVersion(conf)
-        if version < (3, 9, 0) or (Utils.unversioned_sys_platform() == 'darwin' and version < (8, 1, 0)):
-            flags['CXXFLAGS'] += ['-Wno-unknown-pragmas']
-        if version < (6, 0, 0):
+        if self.getCompilerVersion(conf) < (6, 0, 0):
             flags['CXXFLAGS'] += ['-Wno-missing-braces'] # Bug #4721
         return flags
 
     def getOptimizedFlags(self, conf):
         flags = super(ClangFlags, self).getOptimizedFlags(conf)
         flags['CXXFLAGS'] += ['-fcolor-diagnostics',
-                              '-Wextra-semi',
                               '-Wundefined-func-template',
                               '-Wno-unused-local-typedef', # Bugs #2657 and #3209
                               ]
-        version = self.getCompilerVersion(conf)
-        if version < (3, 9, 0) or (Utils.unversioned_sys_platform() == 'darwin' and version < (8, 1, 0)):
-            flags['CXXFLAGS'] += ['-Wno-unknown-pragmas']
-        if version < (6, 0, 0):
+        if self.getCompilerVersion(conf) < (6, 0, 0):
             flags['CXXFLAGS'] += ['-Wno-missing-braces'] # Bug #4721
         return flags

.waf-tools/sphinx_build.py

@@ -44,28 +44,28 @@ def apply_sphinx(self):
     task.inputs.append(conf)
 
     confdir = conf.parent.abspath()
-    buildername = getattr(self, "builder", "html")
-    srcdir = getattr(self, "srcdir", confdir)
-    outdir = self.path.find_or_declare(getattr(self, "outdir", buildername)).get_bld()
-    doctreedir = getattr(self, "doctreedir", os.path.join(outdir.abspath(), ".doctrees"))
+    buildername = getattr(self, 'builder', 'html')
+    srcdir = getattr(self, 'srcdir', confdir)
+    outdir = self.path.find_or_declare(getattr(self, 'outdir', buildername)).get_bld()
+    doctreedir = getattr(self, 'doctreedir', os.path.join(outdir.abspath(), '.doctrees'))
 
     task.env['BUILDERNAME'] = buildername
     task.env['SRCDIR'] = srcdir
     task.env['DOCTREEDIR'] = doctreedir
     task.env['OUTDIR'] = outdir.abspath()
-    task.env['VERSION'] = "version=%s" % self.VERSION
-    task.env['RELEASE'] = "release=%s" % self.VERSION
+    task.env['VERSION'] = 'version=%s' % self.version
+    task.env['RELEASE'] = 'release=%s' % getattr(self, 'release', self.version)
 
     import imp
     confData = imp.load_source('sphinx_conf', conf.abspath())
 
-    if buildername == "man":
+    if buildername == 'man':
         for i in confData.man_pages:
             target = outdir.find_or_declare('%s.%d' % (i[1], i[4]))
             task.outputs.append(target)
 
             if self.install_path:
-                self.bld.install_files("%s/man%d/" % (self.install_path, i[4]), target)
+                self.bld.install_files('%s/man%d/' % (self.install_path, i[4]), target)
     else:
         task.outputs.append(outdir)
 

.waf-tools/unix-socket.py

@@ -1,13 +1,13 @@
 # -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
 #
-# Copyright (c) 2014-2018, Regents of the University of California
+# Copyright (c) 2014-2019, Regents of the University of California
 #
 # GPL 3.0 license, see the COPYING.md file for more information
 
 from waflib import Options
 
 BOOST_ASIO_HAS_LOCAL_SOCKETS_CHECK = '''
-#include <boost/asio.hpp>
+#include <boost/asio/local/basic_endpoint.hpp>
 #ifndef BOOST_ASIO_HAS_LOCAL_SOCKETS
 #error "Unix sockets are not available on this platform"
 #endif
@@ -25,6 +25,5 @@ def configure(conf):
                               fragment=BOOST_ASIO_HAS_LOCAL_SOCKETS_CHECK,
                               features='cxx', use='BOOST', mandatory=False)
 
-    if conf.options.force_unix_socket or boost_asio_has_local_sockets():
-        conf.define('HAVE_UNIX_SOCKETS', 1)
-        conf.env.HAVE_UNIX_SOCKETS = True
+    conf.env.HAVE_UNIX_SOCKETS = conf.options.force_unix_socket or boost_asio_has_local_sockets()
+    conf.define_cond('HAVE_UNIX_SOCKETS', conf.env.HAVE_UNIX_SOCKETS)

.waf-tools/websocket.py

@@ -61,13 +61,13 @@ def checkWebsocket(self, **kw):
     except Errors.WafError as error:
         if isMandatory:
             self.end_msg(str(error), color='RED')
-            Logs.warn('If you are using git NFD repository, checkout websocketpp submodule: ')
+            Logs.warn('If you are using NFD from the git repository, checkout the websocketpp submodule: ')
             Logs.warn('    git submodule update --init')
-            Logs.warn('Otherwise, manually download and extract websocketpp library:')
-            Logs.warn('    mkdir websocketpp')
-            Logs.warn('    curl -L https://github.com/zaphoyd/websocketpp/archive/0.7.0.tar.gz > websocket.tar.gz')
-            Logs.warn('    tar xf websocket.tar.gz -C websocketpp/ --strip 1')
+            Logs.warn('Otherwise, manually download and extract the websocketpp library:')
+            Logs.warn('    mkdir -p websocketpp')
+            Logs.warn('    curl -L https://github.com/cawka/websocketpp/archive/0.8.1-hotfix.tar.gz > websocketpp.tar.gz')
+            Logs.warn('    tar xf websocketpp.tar.gz -C websocketpp/ --strip 1')
             Logs.warn('Alternatively, WebSocket support can be disabled with --without-websocket')
-            self.fatal('The configuration failed')
+            self.fatal('WebSocket++ not found')
         else:
             self.end_msg(str(error))

AUTHORS.md

@@ -1,82 +1,62 @@
-NFD Authors
-===========
+# NFD Authors
 
-NFD is an open source project started in late 2013, includes contributions
-from many people around the world, and open for new contributions from new
-volunteers.
+The following lists maintainers, primary developers, and all much-appreciated contributors to NFD in alphabetic order.
+The specific contributions of individual authors can be obtained from the git history of the [official NFD repository](https://github.com/named-data/NFD).
+If you would like to become a contributor to the official repository, please follow the recommendations in https://github.com/named-data/.github/blob/master/CONTRIBUTING.md.
 
+* Jerald Paul Abraham <https://cs.arizona.edu/~jeraldabraham>
+* ***(Maintainer)*** Alexander Afanasyev <https://users.cs.fiu.edu/~afanasyev>
+* Syed Obai Amin <http://obaidamin.weebly.com>
+* Hila Ben Abraham <https://sites.wustl.edu/hbabraham>
+* Muktadir R Chowdhury <https://github.com/alvyC>
+* Tai-Lin Chu <https://www.linkedin.com/pub/tai-lin-chu/55/5b2/669>
+* Stephanie DiBenedetto
+* Saurab Dulal <https://dulalsaurab.github.io>
+* Chengyu Fan <https://github.com/chengyu>
+* Ashlesh Gawande <https://www.linkedin.com/in/agawande>
+* Chavoosh Ghasemi <https://chavoosh.github.io>
+* Mathias Gibbens <https://calenhad.com>
+* Nick Gordon <https://github.com/gorgonical>
+* Giulio Grassi <https://www.lip6.fr/actualite/personnes-fiche.php?ident=D1461>
+* Yi Huang <https://www.linkedin.com/in/yihuang1991>
+* Jongseok Lee <https://github.com/imwhiz>
+* Spencer Lee <https://www.linkedin.com/in/spenlee>
+* Vince Lehman <http://vslehman.com>
+* Yanbiao Li <https://www.linkedin.com/pub/yanbiao-li/24/7a1/4ba>
+* Teng Liang <https://cs.arizona.edu/~philoliang>
+* Weiwei Liu <https://www.linkedin.com/in/weiweiliu10>
+* Spyridon Mastorakis <https://sites.google.com/site/spyridonmastorakis>
+* Ernest McCracken <https://github.com/emccrckn>
+* Ilya Moiseenko <https://www.linkedin.com/in/ilya-moiseenko-52884317>
+* Eric Newberry <https://ericnewberry.com>
+* Ju Pan <https://cs-jupan.com>
+* João Pereira <http://website.jpereira.co.uk>
+* Davide Pesavento <https://github.com/Pesa>
+* Felix Rabe <https://twitter.com/felixrabe>
+* Md Ashiqur Rahman <https://ashiqrahman.com>
+* Matteo Sammarco <https://www.linkedin.com/in/matteo-sammarco-9b544530>
+* Niv Sardi <http://core.evilgiggle.com>
+* Klaus Schneider <https://cs.arizona.edu/~klaus>
+* Wentao Shang <https://irl.cs.ucla.edu/~wentao>
+* Susmit Shannigrahi <https://susm.it>
+* ***(Former Maintainer)*** Junxiao Shi <https://cs.arizona.edu/~shijunxiao>
+* Yukai Tu <https://irl.cs.ucla.edu/~yukai>
+* Sebastian Wölke <https://inet.haw-hamburg.de/members/alumni-1/sebastian-woelke>
+* Yumin Xia <https://github.com/Stumble>
+* Yingdi Yu <https://irl.cs.ucla.edu/~yingdi>
+* Haowei Yuan <http://www.cse.wustl.edu/~yuanh>
+* Hang Zhang <http://netlab.bit.edu.cn/z_hang>
+* Minsheng Zhang <https://github.com/mzhang4>
+* Zhiyi Zhang <https://zhiyi-zhang.com>
+* Qi Zhao <https://web.cs.ucla.edu/~qi.zhao>
+* Wenkai Zheng <https://github.com/wenkaizheng>
 
-## Project technical leads:
+## Technical Advisors
 
-* Alexander Afanasyev <http://lasr.cs.ucla.edu/afanasyev/index.html>
-* Junxiao Shi         <http://www.cs.arizona.edu/people/shijunxiao/>
-
-
-## Technical advisors:
-
-* Beichuan Zhang      <http://www.cs.arizona.edu/~bzhang/>
-* Lixia Zhang         <http://www.cs.ucla.edu/~lixia/>
-
-
-## Main project authors and their affiliations:
-
-* University of California, Los Angeles
-
-    * Alexander Afanasyev <http://lasr.cs.ucla.edu/afanasyev/index.html>
-    * Ilya Moiseenko      <http://ilyamoiseenko.com/>
-    * Yingdi Yu           <http://irl.cs.ucla.edu/~yingdi/web/index.html>
-    * Wentao Shang        <http://irl.cs.ucla.edu/~wentao/>
-    * Lixia Zhang         <http://www.cs.ucla.edu/~lixia/>
-
-* The University of Arizona
-
-    * Junxiao Shi         <http://www.cs.arizona.edu/people/shijunxiao/>
-    * Yi Huang            <ethanhuang1991@gmail.com>
-    * Jerald Paul Abraham <http://www.cs.arizona.edu/people/jeraldabraham/>
-    * Beichuan Zhang      <http://www.cs.arizona.edu/~bzhang/>
-
-* Colorado State University
-
-    * Steve DiBenedetto     <http://www.cs.colostate.edu/~dibenede/>
-    * Chengyu Fan           <chengyu@cs.colostate.edu>
-    * Christos Papadopoulos <http://www.cs.colostate.edu/~christos/>
-
-* University Pierre & Marie Curie, Sorbonne University
-
-    * Davide Pesavento    <https://www.linkedin.com/in/davidepesavento>
-    * Giulio Grassi       <http://www.lip6.fr/actualite/personnes-fiche.php?ident=D1461>
-    * Giovanni Pau        <http://www.cs.ucla.edu/~gpau/Giovanni_Paus_Home_Page/Home.html>
-
-* Beijing Institute of Technology
-
-    * Hang Zhang          <http://netlab.bit.edu.cn/z_hang>
-    * Tian Song           <http://cs.bit.edu.cn/songtian>
-
-* Washington University in St. Louis
-
-    * Haowei Yuan         <http://www.cse.wustl.edu/~yuanh/>
-    * Hila Ben Abraham    <http://research.engineering.wustl.edu/~abrahamh/>
-    * Patrick Crowley     <http://www.arl.wustl.edu/~pcrowley/>
-
-* The University of Memphis
-
-    * Syed Obaid Amin     <http://obaidamin.weebly.com/>
-    * Vince Lehman        <vslehman@memphis.edu>
-    * Minsheng Zhang      <mzhang4@memphis.edu>
-    * Lan Wang            <http://www.cs.memphis.edu/~lanwang/>
-
-## Project contributors
-
-The following is an inevitably incomplete list of MUCH-APPRECIATED CONTRIBUTORS,
-people who have reported bugs, submitted patches, and implemented new features
-in the library:
-
-* Tai-Lin Chu             <https://www.linkedin.com/pub/tai-lin-chu/55/5b2/669>
-* Spyridon Mastorakis     <http://cs.ucla.edu/~mastorakis/>
-* Eric Newberry           <http://cs.arizona.edu/~enewberry/>
-* Yukai Tu                <tuyukai1994@gmail.com>
-* João Pereira            <http://website.jpereira.co.uk>
-* Mathias Gibbens         <gibmat@cs.arizona.edu>
-* Yanbiao Li              <https://www.linkedin.com/pub/yanbiao-li/24/7a1/4ba>
-* Weiwei Liu              <https://www.linkedin.com/in/weiweiliu10>
-* Spencer Lee             <https://www.linkedin.com/in/spenlee>
+* Patrick Crowley <https://www.arl.wustl.edu/~pcrowley>
+* Christos Papadopoulos <https://www.cs.colostate.edu/~christos>
+* Giovanni Pau <http://www.cs.ucla.edu/~gpau/Giovanni_Paus_Home_Page/Home.html>
+* Tian Song <http://www.bit-netlab.org/songtian>
+* Lan Wang <http://www.cs.memphis.edu/~lanwang>
+* Beichuan Zhang <https://cs.arizona.edu/~bzhang>
+* Lixia Zhang <https://cs.ucla.edu/~lixia>

INSTALL.md

@@ -1,5 +0,0 @@
-NFD Installation Instructions
-=============================
-
-See [`docs/INSTALL.rst`](https://github.com/named-data/NFD/blob/master/docs/INSTALL.rst)
-for detailed NFD installation instructions.

README-dev.md

@@ -1,21 +1,23 @@
-Notes for NFD developers
-========================
+# Notes for NFD developers
 
 If you are new to the NDN software community, please read the
-[Contributor's Guide](https://github.com/named-data/NFD/blob/master/CONTRIBUTING.md)
+[Contributor's Guide](https://github.com/named-data/.github/blob/master/CONTRIBUTING.md).
 
-Requirements
-------------
+## Code style
 
-Contributions to NFD must be licensed under GPL 3.0 or compatible license.  If you are
-choosing GPL 3.0, please use the following license boilerplate in all `.hpp` and `.cpp`
-files:
+NFD code is subject to [NFD code style](https://redmine.named-data.net/projects/nfd/wiki/CodeStyle).
+
+## Licensing
+
+Contributions to NFD must be licensed under the GPL 3.0 or compatible license.  If you
+are choosing GPL 3.0, please use the following license boilerplate in all `.hpp` and
+`.cpp` files:
 
 Include the following license boilerplate into all `.hpp` and `.cpp` files:
 
     /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
     /*
-     * Copyright (c) [Year(s)],  [Copyright Holder(s)].
+     * Copyright (c) [Year(s)], [Copyright Holder(s)].
      *
      * This file is part of NFD (Named Data Networking Forwarding Daemon).
      * See AUTHORS.md for complete list of NFD authors and contributors.
@@ -35,37 +37,36 @@ Include the following license boilerplate into all `.hpp` and `.cpp` files:
 If you are affiliated to an NSF-supported NDN project institution, please use the [NDN Team License
 Boilerplate](https://redmine.named-data.net/projects/nfd/wiki/NDN_Team_License_Boilerplate_(NFD)).
 
-Recommendations
----------------
+## Logging
 
-NFD code is subject to NFD [code style](https://redmine.named-data.net/projects/nfd/wiki/CodeStyle).
+Fine-grained per-module logging can be configured via the `NDN_LOG` environment variable.
+This is especially useful when running unit tests or tools such as `nfdc` that do not
+have a configuration file.  See `ndn-log(7)` manual page for syntax and examples.
 
-
-Running unit-tests
-------------------
+## Unit tests
 
 To run unit tests, NFD needs to be configured and build with unit test support:
 
-    ./waf configure --with-tests
+    ./waf configure --with-tests # --debug is also strongly recommended while developing
     ./waf
 
-The simplest way to run tests, is just to run the compiled binary without any parameters:
+The simplest way to run the tests is to launch the compiled binary without any parameters:
 
     # Run core tests
     ./build/unit-tests-core
 
-    # Run  NFD daemon tests
+    # Run NFD daemon tests
     ./build/unit-tests-daemon
 
     # Run NFD RIB management tests
     ./build/unit-tests-rib
 
-However, [Boost.Test framework](https://www.boost.org/doc/libs/1_58_0/libs/test/doc/html/index.html)
+The [Boost.Test framework](https://www.boost.org/doc/libs/1_65_1/libs/test/doc/html/index.html)
 is very flexible and allows a number of run-time customization of what tests should be run.
 For example, it is possible to choose to run only a specific test suite, only a specific
 test case within a suite, or specific test cases within specific test suites:
 
-    # Run only TCP Face test suite of NFD daemon tests (see tests/daemon/face/tcp.cpp)
+    # Run only the TCP Face test suite of NFD daemon tests
     ./build/unit-tests-daemon -t FaceTcp
 
     # Run only test case EndToEnd4 from the same test suite
@@ -76,8 +77,8 @@ test case within a suite, or specific test cases within specific test suites:
 
 By default, Boost.Test framework will produce verbose output only when a test case fails.
 If it is desired to see verbose output (result of each test assertion), add `-l all`
-option to `./build/unit-tests` command.  To see test progress, you can use `-l test_suite`
-or `-p` to show progress bar:
+option to `./build/unit-tests` command.  To see test progress, you can use `-l test_suite`,
+or `-p` to show a progress bar:
 
     # Show report all log messages including the passed test notification
     ./build/unit-tests-daemon -l all
@@ -91,7 +92,6 @@ or `-p` to show progress bar:
     # Show progress bar
     ./build/unit-tests-core -p
 
-There are many more command line options available, information about
-which can be obtained either from the command line using `--help`
-switch, or online on [Boost.Test library](https://www.boost.org/doc/libs/1_58_0/libs/test/doc/html/index.html)
-website.
+There are many more command line options available, information about which can be obtained
+either from the command line using the `--help` switch, or online on the
+[Boost.Test website](https://www.boost.org/doc/libs/1_65_1/libs/test/doc/html/index.html).

README.md

@@ -1,38 +1,15 @@
-NFD - Named Data Networking Forwarding Daemon
-=============================================
+# NFD - Named Data Networking Forwarding Daemon
 
+![Language](https://img.shields.io/badge/C%2B%2B-14-blue.svg)
 [![Build Status](https://travis-ci.org/named-data/NFD.svg?branch=master)](https://travis-ci.org/named-data/NFD)
-
-For complete documentation, including step-by-step installation instructions and
-tutorials, please visit the [NFD homepage](https://named-data.net/doc/NFD/).
-
-If you are new to the NDN software community, please read README-dev.md and the
-[Contributor's Guide](https://github.com/named-data/NFD/blob/master/CONTRIBUTING.md).
+![Latest Version](https://img.shields.io/github/tag/named-data/NFD.svg?color=darkkhaki&label=latest%20version)
 
 ## Overview
 
 NFD is a network forwarder that implements and evolves together with the Named Data
-Networking (NDN) [protocol](https://named-data.net/doc/ndn-tlv/).  After the initial
-release, NFD will become a core component of the
-[NDN Platform](https://named-data.net/codebase/platform/) and will follow the same release
-cycle.
-
-NFD is an open and free software package licensed under GPL 3.0 license and is the
-centerpiece of our committement to making NDN's core technology open and free to all
-Internet users and developers.  For more information about the licensing details and
-limitation, refer to
-[`COPYING.md`](https://github.com/named-data/NFD/blob/master/COPYING.md).
-
-NFD is developed by a community effort.  Although the first release was mostly done by the
-members of [NSF-sponsored NDN project team](https://named-data.net/project/participants/),
-it already contains significant contributions from people outside the project team (for
-more details, refer to
-[`AUTHORS.md`](https://github.com/named-data/NFD/blob/master/AUTHORS.md)).  We strongly
-encourage participation from all interested parties, since broader community support is
-key for NDN to succeed as a new Internet architecture.  Bug reports and feedback are
-highly appreciated and can be made through
-[Redmine site](https://redmine.named-data.net/projects/nfd) and the
-[ndn-interest mailing list](http://www.lists.cs.ucla.edu/mailman/listinfo/ndn-interest).
+Networking (NDN) [protocol](https://named-data.net/doc/NDN-packet-spec/current/).
+Since the initial public release in 2014, NFD has been a core component of the
+[NDN Platform](https://named-data.net/codebase/platform/).
 
 The main design goal of NFD is to support diverse experimentation of NDN technology.  The
 design emphasizes *modularity* and *extensibility* to allow easy experiments with new
@@ -45,3 +22,34 @@ NFD will keep evolving in three aspects: improvement of the modularity framework
 up with the NDN protocol spec, and addition of other new features. We hope to keep the
 modular framework stable and lean, allowing researchers to implement and experiment with
 various features, some of which may eventually work into the protocol spec.
+
+## Documentation
+
+See [`docs/INSTALL.rst`](docs/INSTALL.rst) for compilation and installation instructions.
+
+Extensive documentation is available on NFD's [homepage](https://named-data.net/doc/NFD/).
+
+## Reporting bugs
+
+Bug reports and feedback are highly appreciated and can be submitted through the
+[NFD issue tracker](https://redmine.named-data.net/projects/nfd/issues) or the
+[ndn-interest mailing list](http://www.lists.cs.ucla.edu/mailman/listinfo/ndn-interest).
+
+## Contributing
+
+NFD is developed by a community effort.  Although the first release was mostly done by the
+members of [NSF-sponsored NDN project team](https://named-data.net/project/participants/),
+it already contains significant contributions from people outside the project team (see
+[`AUTHORS.md`](AUTHORS.md)).  We strongly encourage participation from all interested parties,
+since broader community support is key for NDN to succeed as a new Internet architecture.
+
+If you are new to the NDN software community, please read [`README-dev.md`](README-dev.md)
+and the [Contributor's Guide](https://github.com/named-data/.github/blob/master/CONTRIBUTING.md)
+to get started.
+
+## License
+
+NFD is a free and open-source software package licensed under the GPL version 3 and
+is the centerpiece of our committement to making NDN's core technology free and open
+to all Internet users and developers. For more information about licensing, refer to
+[`COPYING.md`](COPYING.md).

contrib/systemd/README.md

@@ -1,130 +0,0 @@
-Starting NFD on Linux with systemd
-==================================
-
-Newer versions of Ubuntu (starting with 15.04) and some other Linux distributions, including Debian
-use systemd to start system daemons, monitor their health, and restart them when they die.
-
-Initial setup
--------------
-
-* Edit `nfd.service`, correcting the paths to the `nfd` executable, configuration, and
-  ``HOME`` directories.
-
-* Copy the systemd config file for NFD to the proper directory
-
-        sudo cp nfd.service /etc/systemd/system
-
-* Reload the systemd manager configuration
-
-        sudo systemctl daemon-reload
-
-### Assumptions in the default scripts
-
-* `nfd` is installed into `/usr/local/bin`
-* Configuraton file is `/usr/local/etc/ndn/nfd.conf`
-* `nfd` will be run as root
-* Log files will be written to `/usr/local/var/log/ndn` folder, which is owned by user `ndn`
-
-### Creating users
-
-If the `ndn` user and group do not exist, they need to be manually created.
-
-    # Create group `ndn`
-    sudo addgroup --system ndn
-
-    # Create user `ndn`
-    sudo adduser --system \
-                 --disabled-login \
-                 --ingroup ndn \
-                 --home /nonexistent \
-                 --gecos "NDN User" \
-                 --shell /bin/false \
-                 ndn
-
-
-### Creating folders
-
-Folder `/usr/local/var/log/ndn` should be created and assigned proper user and group:
-
-    sudo mkdir -p /usr/local/var/log/ndn
-    sudo chown -R ndn:ndn /usr/local/var/log/ndn
-
-`HOME` directory for `nfd` should be created prior to starting. This is necessary to manage
-unique security credentials for the daemon.
-
-    # Create HOME and generate self-signed NDN certificate for nfd
-    sudo sh -c ' \
-      mkdir -p /usr/local/var/lib/ndn/nfd/.ndn; \
-      export HOME=/usr/local/var/lib/ndn/nfd; \
-      ndnsec-keygen /localhost/daemons/nfd | ndnsec-install-cert -; \
-    '
-
-### Configuring NFD's security
-
-NFD sample configuration allows anybody to create faces, add nexthops to FIB, and set
-strategy choice for namespaces. While such settings could be a good start, it is
-generally not a good idea to run NFD in this mode.
-
-While thorough discussion about the security configuration of NFD is outside the scope of
-this document, at least the following change should be done in ``nfd.conf`` in the
-authorize section:
-
-    authorizations
-    {
-      authorize
-      {
-        certfile certs/localhost_daemons_nfd.ndncert
-        privileges
-        {
-            faces
-            fib
-            strategy-choice
-        }
-      }
-
-      authorize
-      {
-        certfile any
-        privileges
-        {
-            faces
-            strategy-choice
-        }
-      }
-    }
-
-While this configuration still allows the management of faces and updating strategy choice by
-anyone, only NFD's RIB Manager (i.e., NFD itself) is allowed to manage FIB.
-
-As the final step to make this configuration work, nfd's self-signed certificate needs to
-be exported into the `localhost_daemons_nfd.ndncert` file:
-
-    sudo sh -c '\
-      mkdir -p /usr/local/etc/ndn/certs || true; \
-      export HOME=/usr/local/var/lib/ndn/nfd; \
-      ndnsec-dump-certificate -i /localhost/daemons/nfd > \
-        /usr/local/etc/ndn/certs/localhost_daemons_nfd.ndncert; \
-    '
-
-Enable auto-start
------------------
-
-After copying the provided upstart script, auto-start of the `nfd` daemon can be enabled with:
-
-    sudo systemctl enable nfd
-
-To manually start it, use the following command:
-
-    sudo systemctl start nfd
-
-Disable auto-start
-------------------
-
-To stop the `nfd` daemon, use the following command:
-
-    sudo systemctl stop nfd
-
-To permanently stop the `nfd` daemon and disable it from being automatically started on reboot,
-disable the service:
-
-    sudo systemctl disable nfd

contrib/upstart/README.md

@@ -1,125 +0,0 @@
-Starting NFD on Linux with upstart
-==================================
-
-Some Linux distributions, such as Ubuntu, use [upstart](http://upstart.ubuntu.com/) as a
-standard mechanism to start system daemons, monitor their health, and restart
-when they die.
-
-Initial setup
--------------
-
-* Edit `nfd.conf` correcting paths for `nfd` binary, configuration and log files.
-
-* Copy upstart config file for NFD
-
-        sudo cp nfd.conf /etc/init/
-
-### Assumptions in the default scripts
-
-* `nfd` is installed into `/usr/local/bin`
-* Configuration file is `/usr/local/etc/ndn/nfd.conf`
-* `nfd` will be run as root
-* Log files will be written to `/usr/local/var/log/ndn` folder, which is owned by user `ndn`
-
-### Creating users
-
-If `ndn` user and group does not exists, they need to be manually created.
-
-    # Create group `ndn`
-    addgroup --system ndn
-
-    # Create user `ndn`
-    sudo adduser --system \
-                 --disabled-login \
-                 --ingroup ndn \
-                 --home /nonexistent \
-                 --gecos "NDN User" \
-                 --shell /bin/false \
-                 ndn
-
-
-### Creating folders
-
-Folder `/usr/local/var/log/ndn` should be created and assigned proper user and group:
-
-    sudo mkdir -p /usr/local/var/log/ndn
-    sudo chown -R ndn:ndn /usr/local/var/log/ndn
-
-`HOME` directory for `nfd` should be created prior to starting.  This is necessary to manage
-unique security credentials for the deamon.
-
-    # Create HOME and generate self-signed NDN certificate for nfd
-    sudo -s -- ' \
-      mkdir -p /usr/local/var/lib/ndn/nfd/.ndn; \
-      export HOME=/usr/local/var/lib/ndn/nfd; \
-      ndnsec-keygen /localhost/daemons/nfd | ndnsec-install-cert -; \
-    '
-
-### Configuring NFD's security
-
-NFD sample configuration allows anybody to create faces, add nexthops to FIB, and set
-strategy choice for namespaces.  While such settings could be a good start, it is
-generally not a good idea to run NFD in this mode.
-
-While thorough discussion about security configuration of NFD is outside the scope of this
-document, at least the following change should be done to ``nfd.conf`` in authorize
-section:
-
-    authorizations
-    {
-      authorize
-      {
-        certfile certs/localhost_daemons_nfd.ndncert
-        privileges
-        {
-            faces
-            fib
-            strategy-choice
-        }
-      }
-
-      authorize
-      {
-        certfile any
-        privileges
-        {
-            faces
-            strategy-choice
-        }
-      }
-    }
-
-While this configuration still allows management of faces and updating strategy choice by
-anybody, only NFD's RIB Manager (i.e., NFD itself) is allowed to manage FIB.
-
-As the final step to make this configuration work, nfd's self-signed certificate needs to
-be exported into `localhost_daemons_nfd.ndncert` file:
-
-    sudo -s -- '\
-      mkdir -p /usr/local/etc/ndn/certs || true; \
-      export HOME=/usr/local/var/lib/ndn/nfd; \
-      ndnsec-dump-certificate -i /localhost/daemons/nfd > \
-        /usr/local/etc/ndn/certs/localhost_daemons_nfd.ndncert; \
-      '
-
-
-Enable auto-start
------------------
-
-After copying the provided upstart script, `nfd` daemon will automatically run after the reboot.
-To manually start them, use the following commands:
-
-    sudo start nfd
-
-Disable auto-start
-------------------
-
-To stop `nfd` daemon, use the following commands:
-
-    sudo stop nfd
-
-Note that as long as upstart files are present in `/etc/init/`, the daemon will
-automatically start after the reboot.  To permanently stop `nfd` daemon, delete
-the upstart files:
-
-    sudo rm /etc/init/nfd.conf

contrib/upstart/nfd.conf

@@ -1,26 +0,0 @@
-# nfd.conf
-#
-# NDN Forwarding Daemon
-
-description "NDN forwarding daemon"
-
-start on (local-filesystems and net-device-up IFACE!=lo)
-stop on runlevel [!2345]
-
-respawn
-respawn limit unlimited
-
-env HOME=/usr/local/var/lib/ndn/nfd
-export HOME
-
-exec /usr/local/bin/nfd --config /usr/local/etc/ndn/nfd.conf 2>> /usr/local/var/log/ndn/nfd.log
-
-post-start script
-  if [ -f /usr/local/etc/ndn/nfd-init.sh ]; then
-      sleep 2 # post-start is executed just after nfd process starts, but there is no guarantee
-              # that all initialization has been finished
-      . /usr/local/etc/ndn/nfd-init.sh
-  fi
-end script
-
-post-stop exec sleep 2

core/common.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -33,12 +33,14 @@
 #define PUBLIC_WITH_TESTS_ELSE_PROTECTED public
 #define PUBLIC_WITH_TESTS_ELSE_PRIVATE public
 #define PROTECTED_WITH_TESTS_ELSE_PRIVATE protected
+#define OVERRIDE_WITH_TESTS_ELSE_FINAL override
 #define FINAL_UNLESS_WITH_TESTS
 #else
 #define VIRTUAL_WITH_TESTS
 #define PUBLIC_WITH_TESTS_ELSE_PROTECTED protected
 #define PUBLIC_WITH_TESTS_ELSE_PRIVATE private
 #define PROTECTED_WITH_TESTS_ELSE_PRIVATE private
+#define OVERRIDE_WITH_TESTS_ELSE_FINAL final
 #define FINAL_UNLESS_WITH_TESTS final
 #endif
 
@@ -65,14 +67,16 @@
 #include <ndn-cxx/lp/nack.hpp>
 #include <ndn-cxx/net/face-uri.hpp>
 #include <ndn-cxx/util/backports.hpp>
+#include <ndn-cxx/util/exception.hpp>
+#include <ndn-cxx/util/scheduler.hpp>
 #include <ndn-cxx/util/signal.hpp>
+#include <ndn-cxx/util/time.hpp>
 
 #include <boost/asio.hpp>
 #include <boost/assert.hpp>
+#include <boost/core/noncopyable.hpp>
 #include <boost/lexical_cast.hpp>
-#include <boost/noncopyable.hpp>
 #include <boost/property_tree/ptree.hpp>
-#include <boost/throw_exception.hpp>
 
 namespace nfd {
 
@@ -106,6 +110,7 @@ using ndn::FaceUri;
 using ndn::Interest;
 using ndn::Name;
 using ndn::PartialName;
+using ndn::Scheduler;
 
 // Not using a namespace alias (namespace tlv = ndn::tlv), because
 // it doesn't allow NFD to add other members to the namespace
@@ -115,9 +120,11 @@ using namespace ndn::tlv;
 
 namespace lp = ndn::lp;
 namespace name = ndn::name;
+namespace scheduler = ndn::scheduler;
 namespace signal = ndn::util::signal;
 namespace time = ndn::time;
 using namespace ndn::time_literals;
+using ndn::operator""_block;
 
 } // namespace nfd
 

core/random.cpp

@@ -1,42 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2016,  Regents of the University of California,
- *                           Arizona Board of Regents,
- *                           Colorado State University,
- *                           University Pierre & Marie Curie, Sorbonne University,
- *                           Washington University in St. Louis,
- *                           Beijing Institute of Technology,
- *                           The University of Memphis.
- *
- * This file is part of NFD (Named Data Networking Forwarding Daemon).
- * See AUTHORS.md for complete list of NFD authors and contributors.
- *
- * NFD is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- *
- * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "random.hpp"
-#include <boost/thread/tss.hpp>
-
-namespace nfd {
-
-std::mt19937&
-getGlobalRng()
-{
-  static boost::thread_specific_ptr<std::mt19937> rng;
-  if (rng.get() == nullptr) {
-    std::random_device rd;
-    rng.reset(new std::mt19937(rd()));
-  }
-  return *rng;
-}
-
-} // namespace nfd

core/random.hpp

@@ -1,52 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/*
- * Copyright (c) 2014-2017,  Regents of the University of California,
- *                           Arizona Board of Regents,
- *                           Colorado State University,
- *                           University Pierre & Marie Curie, Sorbonne University,
- *                           Washington University in St. Louis,
- *                           Beijing Institute of Technology,
- *                           The University of Memphis.
- *
- * This file is part of NFD (Named Data Networking Forwarding Daemon).
- * See AUTHORS.md for complete list of NFD authors and contributors.
- *
- * NFD is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- *
- * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * \file
- * \brief Declares the global pseudorandom number generator (PRNG) for NFD
- *
- * All random numbers generated by NFD should use this global generator,
- * so that it can be properly seeded when necessary.
- *
- * \warning This PRNG is not suitable for security purposes; security-critical
- *          code must use a cryptographically secure PRNG, such as that provided
- *          by OpenSSL.
- */
-
-#ifndef NFD_CORE_RANDOM_HPP
-#define NFD_CORE_RANDOM_HPP
-
-#include <random>
-
-namespace nfd {
-
-/** \return the global random number generator instance
- */
-std::mt19937&
-getGlobalRng();
-
-} // namespace nfd
-
-#endif // NFD_CORE_RANDOM_HPP

core/rtt-estimator.cpp

@@ -1,80 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2017,  Regents of the University of California,
- *                           Arizona Board of Regents,
- *                           Colorado State University,
- *                           University Pierre & Marie Curie, Sorbonne University,
- *                           Washington University in St. Louis,
- *                           Beijing Institute of Technology,
- *                           The University of Memphis
- *
- * This file is part of NFD (Named Data Networking Forwarding Daemon).
- * See AUTHORS.md for complete list of NFD authors and contributors.
- *
- * NFD is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- *
- * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
- **/
-
-#include "rtt-estimator.hpp"
-
-namespace nfd {
-
-RttEstimator::RttEstimator(uint16_t maxMultiplier, Duration minRto, double gain)
-  : m_maxMultiplier(maxMultiplier)
-  , m_minRto(minRto.count())
-  , m_rtt(RttEstimator::getInitialRtt().count())
-  , m_gain(gain)
-  , m_variance(0)
-  , m_multiplier(1)
-  , m_nSamples(0)
-{
-}
-
-void
-RttEstimator::addMeasurement(Duration measure)
-{
-  double m = static_cast<double>(measure.count());
-  if (m_nSamples > 0) {
-    double err = m - m_rtt;
-    double gErr = err * m_gain;
-    m_rtt += gErr;
-    double difference = std::abs(err) - m_variance;
-    m_variance += difference * m_gain;
-  }
-  else {
-    m_rtt = m;
-    m_variance = m;
-  }
-  ++m_nSamples;
-  m_multiplier = 1;
-}
-
-void
-RttEstimator::incrementMultiplier()
-{
-  m_multiplier = std::min(static_cast<uint16_t>(m_multiplier + 1), m_maxMultiplier);
-}
-
-void
-RttEstimator::doubleMultiplier()
-{
-  m_multiplier = std::min(static_cast<uint16_t>(m_multiplier * 2), m_maxMultiplier);
-}
-
-RttEstimator::Duration
-RttEstimator::computeRto() const
-{
-  double rto = std::max(m_minRto, m_rtt + 4 * m_variance);
-  rto *= m_multiplier;
-  return Duration(static_cast<Duration::rep>(rto));
-}
-
-} // namespace nfd

core/scheduler.cpp

@@ -1,107 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2017,  Regents of the University of California,
- *                           Arizona Board of Regents,
- *                           Colorado State University,
- *                           University Pierre & Marie Curie, Sorbonne University,
- *                           Washington University in St. Louis,
- *                           Beijing Institute of Technology,
- *                           The University of Memphis.
- *
- * This file is part of NFD (Named Data Networking Forwarding Daemon).
- * See AUTHORS.md for complete list of NFD authors and contributors.
- *
- * NFD is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- *
- * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "scheduler.hpp"
-#include "global-io.hpp"
-
-#include <boost/thread/tss.hpp>
-
-namespace nfd {
-namespace scheduler {
-
-static boost::thread_specific_ptr<Scheduler> g_scheduler;
-
-Scheduler&
-getGlobalScheduler()
-{
-  if (g_scheduler.get() == nullptr) {
-    g_scheduler.reset(new Scheduler(getGlobalIoService()));
-  }
-
-  return *g_scheduler;
-}
-
-EventId
-schedule(time::nanoseconds after, const EventCallback& event)
-{
-  return getGlobalScheduler().scheduleEvent(after, event);
-}
-
-void
-cancel(const EventId& eventId)
-{
-  getGlobalScheduler().cancelEvent(eventId);
-}
-
-void
-resetGlobalScheduler()
-{
-  g_scheduler.reset();
-}
-
-ScopedEventId::ScopedEventId()
-{
-}
-
-ScopedEventId::ScopedEventId(const EventId& event)
-  : m_event(event)
-{
-}
-
-ScopedEventId::ScopedEventId(ScopedEventId&& other)
-  : m_event(other.m_event)
-{
-  other.release();
-}
-
-ScopedEventId&
-ScopedEventId::operator=(const EventId& event)
-{
-  if (m_event != event) {
-    scheduler::cancel(m_event);
-    m_event = event;
-  }
-  return *this;
-}
-
-ScopedEventId::~ScopedEventId()
-{
-  scheduler::cancel(m_event);
-}
-
-void
-ScopedEventId::cancel()
-{
-  scheduler::cancel(m_event);
-}
-
-void
-ScopedEventId::release()
-{
-  m_event.reset();
-}
-
-} // namespace scheduler
-} // namespace nfd

core/scheduler.hpp

@@ -1,100 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/*
- * Copyright (c) 2014-2018,  Regents of the University of California,
- *                           Arizona Board of Regents,
- *                           Colorado State University,
- *                           University Pierre & Marie Curie, Sorbonne University,
- *                           Washington University in St. Louis,
- *                           Beijing Institute of Technology,
- *                           The University of Memphis.
- *
- * This file is part of NFD (Named Data Networking Forwarding Daemon).
- * See AUTHORS.md for complete list of NFD authors and contributors.
- *
- * NFD is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- *
- * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.  See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef NFD_CORE_SCHEDULER_HPP
-#define NFD_CORE_SCHEDULER_HPP
-
-#include "common.hpp"
-
-#include <ndn-cxx/util/scheduler.hpp>
-
-namespace nfd {
-namespace scheduler {
-
-using ndn::Scheduler;
-
-/** \class nfd::scheduler::EventId
- *  \brief Opaque handle for a scheduled event.
- */
-using ndn::EventId;
-
-using ndn::util::scheduler::EventCallback;
-
-/** \brief Schedule an event.
- */
-EventId
-schedule(time::nanoseconds after, const EventCallback& event);
-
-/** \brief Cancel a scheduled event.
- */
-void
-cancel(const EventId& eventId);
-
-/** \brief Cancels an event automatically upon destruction.
- */
-class ScopedEventId : noncopyable
-{
-public:
-  ScopedEventId();
-
-  /** \brief Implicit constructor from EventId.
-   *  \param event the event to be cancelled upon destruction
-   */
-  ScopedEventId(const EventId& event);
-
-  /** \brief Move constructor.
-   */
-  ScopedEventId(ScopedEventId&& other);
-
-  /** \brief Assigns an event.
-   *
-   *  If a different event has been assigned to this instance previously,
-   *  that event will be cancelled immediately.
-   */
-  ScopedEventId&
-  operator=(const EventId& event);
-
-  /** \brief Cancels the event.
-   */
-  ~ScopedEventId();
-
-  /** \brief Cancels the event manually.
-   */
-  void
-  cancel();
-
-  /** \brief Releases the event so that it won't be cancelled when this ScopedEventId is destructed.
-   */
-  void
-  release();
-
-private:
-  EventId m_event;
-};
-
-} // namespace scheduler
-} // namespace nfd
-
-#endif // NFD_CORE_SCHEDULER_HPP

core/version.cpp.in

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2017,  Regents of the University of California,
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,17 +23,7 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "readvertised-route.hpp"
-#include "core/random.hpp"
+#include "core/version.hpp"
 
-namespace nfd {
-namespace rib {
-
-ReadvertisedRoute::ReadvertisedRoute(const Name& prefix)
-  : prefix(prefix)
-  , nRibRoutes(0)
-{
-}
-
-} // namespace rib
-} // namespace nfd
+const char NFD_VERSION_STRING[] = "@VERSION_STRING@";
+const char NFD_VERSION_BUILD_STRING[] = "@VERSION_BUILD@";

core/version.hpp.in

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2016,  Regents of the University of California,
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,49 +26,48 @@
 #ifndef NFD_CORE_VERSION_HPP
 #define NFD_CORE_VERSION_HPP
 
-namespace nfd {
-
-/** NFD version follows Semantic Versioning 2.0.0 specification
- *  http://semver.org/
- */
-
+// NFD version follows Semantic Versioning 2.0.0
+// https://semver.org/spec/v2.0.0.html
+//
 // To change version number, modify VERSION variable in top-level wscript.
 
-/** \brief NFD version represented as an integer
+/** \brief NFD version represented as an integer.
  *
- *  MAJOR*1000000 + MINOR*1000 + PATCH
+ *  Equivalent to: `#NFD_VERSION_MAJOR*1000000 + #NFD_VERSION_MINOR*1000 + #NFD_VERSION_PATCH`
  */
 #define NFD_VERSION @VERSION@
 
-/** \brief NFD version represented as a string
- *
- *  MAJOR.MINOR.PATCH
- */
-#define NFD_VERSION_STRING "@VERSION_STRING@"
-
-/** \brief NFD version string, including git commit information, if NFD is build from
- *         specific git commit
- *
- * NFD_VERSION_BUILD_STRING is obtained using the following command (`NFD-` prefix is
- * afterwards removed):
- *
- *    `git describe --match 'NFD-*'`
- *
- * When NFD is built not from git, NFD_VERSION_BUILD_STRING equals NFD_VERSION_STRING
- *
- * MAJOR.MINOR.PATCH(-release-candidate-tag)(-(number-of-commits-since-tag)-COMMIT-HASH)
- *
- * Example, 0.1.0-rc1-1-g5c86570
- */
-#define NFD_VERSION_BUILD_STRING "@VERSION_BUILD@"
-
-/// MAJOR version
+/// The major version of NFD
 #define NFD_VERSION_MAJOR @VERSION_MAJOR@
-/// MINOR version
+/// The minor version of NFD
 #define NFD_VERSION_MINOR @VERSION_MINOR@
-/// PATCH version
+/// The patch version of NFD
 #define NFD_VERSION_PATCH @VERSION_PATCH@
 
-} // namespace nfd
+/** \brief NFD version represented as a string.
+ *
+ * Format:
+ * @code
+ * MAJOR.MINOR.PATCH
+ * @endcode
+ */
+extern const char NFD_VERSION_STRING[];
+
+/** \brief NFD version string, including git commit information, if NFD is build from
+ *         specific git commit.
+ *
+ * #NFD_VERSION_BUILD_STRING is obtained using the following command (`NFD-` prefix is
+ * afterwards removed): `git describe --match 'NFD-*'`
+ *
+ * When NFD is not built from git, #NFD_VERSION_BUILD_STRING equals #NFD_VERSION_STRING.
+ *
+ * Format:
+ * @code
+ * MAJOR.MINOR.PATCH(-release-candidate-tag)(-(number-of-commits-since-tag)-COMMIT-HASH)
+ * @endcode
+ *
+ * Example: 0.1.0-rc1-1-g5c86570
+ */
+extern const char NFD_VERSION_BUILD_STRING[];
 
 #endif // NFD_CORE_VERSION_HPP

daemon/common/config-file.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,9 +23,10 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "config-file.hpp"
+#include "common/config-file.hpp"
 
 #include <boost/property_tree/info_parser.hpp>
+
 #include <fstream>
 #include <sstream>
 
@@ -42,8 +43,8 @@ ConfigFile::throwErrorOnUnknownSection(const std::string& filename,
                                        const ConfigSection& section,
                                        bool isDryRun)
 {
-  BOOST_THROW_EXCEPTION(Error("Error processing configuration file " + filename +
-                              ": no module subscribed for section \"" + sectionName + "\""));
+  NDN_THROW(Error("Error processing configuration file " + filename +
+                  ": no module subscribed for section '" + sectionName + "'"));
 }
 
 void
@@ -68,8 +69,8 @@ ConfigFile::parseYesNo(const ConfigSection& node, const std::string& key,
     return false;
   }
 
-  BOOST_THROW_EXCEPTION(Error("Invalid value \"" + value + "\" for option \"" +
-                              key + "\" in \"" + sectionName + "\" section"));
+  NDN_THROW(Error("Invalid value '" + value + "' for option '" +
+                  key + "' in section '" + sectionName + "'"));
 }
 
 void
@@ -84,7 +85,7 @@ ConfigFile::parse(const std::string& filename, bool isDryRun)
 {
   std::ifstream inputFile(filename);
   if (!inputFile.good() || !inputFile.is_open()) {
-    BOOST_THROW_EXCEPTION(Error("Failed to read configuration file " + filename));
+    NDN_THROW(Error("Failed to read configuration file " + filename));
   }
   parse(inputFile, isDryRun, filename);
   inputFile.close();
@@ -104,8 +105,8 @@ ConfigFile::parse(std::istream& input, bool isDryRun, const std::string& filenam
     boost::property_tree::read_info(input, m_global);
   }
   catch (const boost::property_tree::info_parser_error& error) {
-    BOOST_THROW_EXCEPTION(Error("Failed to parse configuration file " + filename +
-                                ": " + error.message() + " on line " + to_string(error.line())));
+    NDN_THROW(Error("Failed to parse configuration file " + filename +
+                    ": " + error.message() + " on line " + to_string(error.line())));
   }
 
   process(isDryRun, filename);

daemon/common/config-file.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,10 +23,10 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_CORE_CONFIG_FILE_HPP
-#define NFD_CORE_CONFIG_FILE_HPP
+#ifndef NFD_DAEMON_COMMON_CONFIG_FILE_HPP
+#define NFD_DAEMON_COMMON_CONFIG_FILE_HPP
 
-#include "common.hpp"
+#include "core/common.hpp"
 
 #include <boost/property_tree/ptree.hpp>
 
@@ -60,11 +60,7 @@ public:
   class Error : public std::runtime_error
   {
   public:
-    explicit
-    Error(const std::string& what)
-      : std::runtime_error(what)
-    {
-    }
+    using std::runtime_error::runtime_error;
   };
 
   explicit
@@ -112,11 +108,13 @@ public: // parse helpers
     static_assert(std::is_arithmetic<T>::value, "T must be an arithmetic type");
 
     boost::optional<T> value = node.get_value_optional<T>();
-    if (value) {
+    // Unsigned logic is workaround for https://redmine.named-data.net/issues/4489
+    if (value &&
+        (std::is_signed<T>() || node.get_value<std::string>().find("-") == std::string::npos)) {
       return *value;
     }
-    BOOST_THROW_EXCEPTION(Error("Invalid value \"" + node.get_value<std::string>() +
-                                "\" for option \"" + key + "\" in \"" + sectionName + "\" section"));
+    NDN_THROW(Error("Invalid value '" + node.get_value<std::string>() +
+                    "' for option '" + key + "' in section '" + sectionName + "'"));
   }
 
   template <typename T>
@@ -181,4 +179,4 @@ private:
 
 } // namespace nfd
 
-#endif // NFD_CORE_CONFIG_FILE_HPP
+#endif // NFD_DAEMON_COMMON_CONFIG_FILE_HPP

daemon/common/counter.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2017,  Regents of the University of California,
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,10 +23,10 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_CORE_COUNTER_HPP
-#define NFD_CORE_COUNTER_HPP
+#ifndef NFD_DAEMON_COMMON_COUNTER_HPP
+#define NFD_DAEMON_COMMON_COUNTER_HPP
 
-#include "common.hpp"
+#include "core/common.hpp"
 
 namespace nfd {
 
@@ -35,25 +35,14 @@ namespace nfd {
  *  SimpleCounter is noncopyable, because increment should be called on the counter,
  *  not a copy of it; it's implicitly convertible to an integral type to be observed
  */
-class SimpleCounter
+class SimpleCounter : noncopyable
 {
 public:
   typedef uint64_t rep;
 
-  constexpr
-  SimpleCounter()
-    : m_value(0)
-  {
-  }
-
-  SimpleCounter(const SimpleCounter&) = delete;
-
-  SimpleCounter&
-  operator=(const SimpleCounter&) = delete;
-
   /** \brief observe the counter
    */
-  operator rep() const
+  operator rep() const noexcept
   {
     return m_value;
   }
@@ -61,13 +50,13 @@ public:
   /** \brief replace the counter value
    */
   void
-  set(rep value)
+  set(rep value) noexcept
   {
     m_value = value;
   }
 
 protected:
-  rep m_value;
+  rep m_value = 0;
 };
 
 /** \brief represents a counter of number of packets
@@ -80,7 +69,7 @@ public:
   /** \brief increment the counter by one
    */
   PacketCounter&
-  operator++()
+  operator++() noexcept
   {
     ++m_value;
     return *this;
@@ -98,7 +87,7 @@ public:
   /** \brief increase the counter
    */
   ByteCounter&
-  operator+=(rep n)
+  operator+=(rep n) noexcept
   {
     m_value += n;
     return *this;
@@ -111,24 +100,19 @@ public:
  *  if table not specified in constructor, it can be added later by invoking observe()
  */
 template<typename T>
-class SizeCounter
+class SizeCounter : noncopyable
 {
 public:
   typedef size_t Rep;
 
   explicit constexpr
-  SizeCounter(const T* table = nullptr)
+  SizeCounter(const T* table = nullptr) noexcept
     : m_table(table)
   {
   }
 
-  SizeCounter(const SizeCounter&) = delete;
-
-  SizeCounter&
-  operator=(const SizeCounter&) = delete;
-
   void
-  observe(const T* table)
+  observe(const T* table) noexcept
   {
     m_table = table;
   }
@@ -147,4 +131,4 @@ private:
 
 } // namespace nfd
 
-#endif // NFD_CORE_COUNTER_HPP
+#endif // NFD_DAEMON_COMMON_COUNTER_HPP

daemon/common/global.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,48 +23,41 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "global-io.hpp"
-#include <boost/thread/tss.hpp>
+#include "common/global.hpp"
 
 namespace nfd {
 
-namespace scheduler {
-// defined in scheduler.cpp
-void
-resetGlobalScheduler();
-} // namespace scheduler
-
-static boost::thread_specific_ptr<boost::asio::io_service> g_ioService;
+static thread_local unique_ptr<boost::asio::io_service> g_ioService;
+static thread_local unique_ptr<Scheduler> g_scheduler;
 static boost::asio::io_service* g_mainIoService = nullptr;
 static boost::asio::io_service* g_ribIoService = nullptr;
 
 boost::asio::io_service&
 getGlobalIoService()
 {
-  if (g_ioService.get() == nullptr) {
-    g_ioService.reset(new boost::asio::io_service());
+  if (g_ioService == nullptr) {
+    g_ioService = make_unique<boost::asio::io_service>();
   }
   return *g_ioService;
 }
 
+Scheduler&
+getScheduler()
+{
+  if (g_scheduler == nullptr) {
+    g_scheduler = make_unique<Scheduler>(getGlobalIoService());
+  }
+  return *g_scheduler;
+}
+
+#ifdef WITH_TESTS
 void
 resetGlobalIoService()
 {
-  scheduler::resetGlobalScheduler();
+  g_scheduler.reset();
   g_ioService.reset();
 }
-
-void
-setMainIoService(boost::asio::io_service* mainIo)
-{
-  g_mainIoService = mainIo;
-}
-
-void
-setRibIoService(boost::asio::io_service* ribIo)
-{
-  g_ribIoService = ribIo;
-}
+#endif
 
 boost::asio::io_service&
 getMainIoService()
@@ -80,6 +73,18 @@ getRibIoService()
   return *g_ribIoService;
 }
 
+void
+setMainIoService(boost::asio::io_service* mainIo)
+{
+  g_mainIoService = mainIo;
+}
+
+void
+setRibIoService(boost::asio::io_service* ribIo)
+{
+  g_ribIoService = ribIo;
+}
+
 void
 runOnMainIoService(const std::function<void()>& f)
 {

daemon/common/global.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018  Regents of the University of California,
+ * Copyright (c) 2014-2019  Regents of the University of California,
  *                          Arizona Board of Regents,
  *                          Colorado State University,
  *                          University Pierre & Marie Curie, Sorbonne University,
@@ -22,33 +22,22 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  **/
 
-#ifndef NFD_CORE_GLOBAL_IO_HPP
-#define NFD_CORE_GLOBAL_IO_HPP
+#ifndef NFD_DAEMON_COMMON_GLOBAL_HPP
+#define NFD_DAEMON_COMMON_GLOBAL_HPP
 
-#include "common.hpp"
+#include "core/common.hpp"
 
 namespace nfd {
 
-/** \return the global io_service instance
+/** \brief Returns the global io_service instance for the calling thread.
  */
 boost::asio::io_service&
 getGlobalIoService();
 
-void
-setMainIoService(boost::asio::io_service* mainIo);
-
-void
-setRibIoService(boost::asio::io_service* ribIo);
-
-/** \brief run a function on the main io_service instance
+/** \brief Returns the global Scheduler instance for the calling thread.
  */
-void
-runOnMainIoService(const std::function<void()>& f);
-
-/** \brief run a function on the RIB io_service instance
- */
-void
-runOnRibIoService(const std::function<void()>& f);
+Scheduler&
+getScheduler();
 
 boost::asio::io_service&
 getMainIoService();
@@ -56,10 +45,26 @@ getMainIoService();
 boost::asio::io_service&
 getRibIoService();
 
+void
+setMainIoService(boost::asio::io_service* mainIo);
+
+void
+setRibIoService(boost::asio::io_service* ribIo);
+
+/** \brief Run a function on the main io_service instance.
+ */
+void
+runOnMainIoService(const std::function<void()>& f);
+
+/** \brief Run a function on the RIB io_service instance.
+ */
+void
+runOnRibIoService(const std::function<void()>& f);
+
 #ifdef WITH_TESTS
-/** \brief delete the global io_service instance
+/** \brief Destroy the global io_service instance.
  *
- *  It will be recreated at the next invocation of getGlobalIoService.
+ *  It will be recreated at the next invocation of getGlobalIoService().
  */
 void
 resetGlobalIoService();
@@ -67,4 +72,4 @@ resetGlobalIoService();
 
 } // namespace nfd
 
-#endif // NFD_CORE_GLOBAL_IO_HPP
+#endif // NFD_DAEMON_COMMON_GLOBAL_HPP

daemon/common/logger.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,8 +23,8 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_CORE_LOGGER_HPP
-#define NFD_CORE_LOGGER_HPP
+#ifndef NFD_DAEMON_COMMON_LOGGER_HPP
+#define NFD_DAEMON_COMMON_LOGGER_HPP
 
 #include <ndn-cxx/util/logger.hpp>
 
@@ -41,4 +41,4 @@
 #define NFD_LOG_ERROR NDN_LOG_ERROR
 #define NFD_LOG_FATAL NDN_LOG_FATAL
 
-#endif // NFD_CORE_LOGGER_HPP
+#endif // NFD_DAEMON_COMMON_LOGGER_HPP

daemon/common/privilege-helper.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,8 +23,8 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "privilege-helper.hpp"
-#include "core/logger.hpp"
+#include "common/privilege-helper.hpp"
+#include "common/logger.hpp"
 
 #include <pwd.h>
 #include <grp.h>
@@ -63,25 +63,23 @@ PrivilegeHelper::initialize(const std::string& userName, const std::string& grou
       groupSize = FALLBACK_GROUP_BUFFER_SIZE;
 
     std::vector<char> groupBuffer(static_cast<size_t>(groupSize));
-    struct group group;
-    struct group* groupResult = nullptr;
+    group gr;
+    group* grResult = nullptr;
 
-    int errorCode = getgrnam_r(groupName.data(), &group,
-                               groupBuffer.data(), groupBuffer.size(), &groupResult);
+    int errorCode = getgrnam_r(groupName.data(), &gr, groupBuffer.data(), groupBuffer.size(), &grResult);
 
     while (errorCode == ERANGE) {
       if (groupBuffer.size() * 2 > MAX_GROUP_BUFFER_SIZE)
         throw Error("Cannot allocate large enough buffer for struct group");
 
       groupBuffer.resize(groupBuffer.size() * 2);
-      errorCode = getgrnam_r(groupName.data(), &group,
-                             groupBuffer.data(), groupBuffer.size(), &groupResult);
+      errorCode = getgrnam_r(groupName.data(), &gr, groupBuffer.data(), groupBuffer.size(), &grResult);
     }
 
-    if (errorCode != 0 || !groupResult)
+    if (errorCode != 0 || !grResult)
       throw Error("Failed to get gid for \"" + groupName + "\"");
 
-    s_normalGid = group.gr_gid;
+    s_normalGid = gr.gr_gid;
   }
 
   if (!userName.empty()) {
@@ -91,25 +89,23 @@ PrivilegeHelper::initialize(const std::string& userName, const std::string& grou
       passwdSize = FALLBACK_PASSWD_BUFFER_SIZE;
 
     std::vector<char> passwdBuffer(static_cast<size_t>(passwdSize));
-    struct passwd passwd;
-    struct passwd* passwdResult = nullptr;
+    passwd pw;
+    passwd* pwResult = nullptr;
 
-    int errorCode = getpwnam_r(userName.data(), &passwd,
-                               passwdBuffer.data(), passwdBuffer.size(), &passwdResult);
+    int errorCode = getpwnam_r(userName.data(), &pw, passwdBuffer.data(), passwdBuffer.size(), &pwResult);
 
     while (errorCode == ERANGE) {
       if (passwdBuffer.size() * 2 > MAX_PASSWD_BUFFER_SIZE)
         throw Error("Cannot allocate large enough buffer for struct passwd");
 
       passwdBuffer.resize(passwdBuffer.size() * 2);
-      errorCode = getpwnam_r(userName.data(), &passwd,
-                             passwdBuffer.data(), passwdBuffer.size(), &passwdResult);
+      errorCode = getpwnam_r(userName.data(), &pw, passwdBuffer.data(), passwdBuffer.size(), &pwResult);
     }
 
-    if (errorCode != 0 || !passwdResult)
+    if (errorCode != 0 || !pwResult)
       throw Error("Failed to get uid for \"" + userName + "\"");
 
-    s_normalUid = passwd.pw_uid;
+    s_normalUid = pw.pw_uid;
   }
 #else
   if (!userName.empty() || !groupName.empty()) {
@@ -121,10 +117,10 @@ PrivilegeHelper::initialize(const std::string& userName, const std::string& grou
 void
 PrivilegeHelper::drop()
 {
+#ifdef HAVE_PRIVILEGE_DROP_AND_ELEVATE
   if (::geteuid() == s_normalUid && ::getegid() == s_normalGid)
     return;
 
-#ifdef HAVE_PRIVILEGE_DROP_AND_ELEVATE
   NFD_LOG_TRACE("dropping to effective gid=" << s_normalGid);
   if (::setegid(s_normalGid) != 0)
     throw Error("Failed to drop to effective gid=" + to_string(s_normalGid));
@@ -142,10 +138,10 @@ PrivilegeHelper::drop()
 void
 PrivilegeHelper::raise()
 {
+#ifdef HAVE_PRIVILEGE_DROP_AND_ELEVATE
   if (::geteuid() == s_privilegedUid && ::getegid() == s_privilegedGid)
     return;
 
-#ifdef HAVE_PRIVILEGE_DROP_AND_ELEVATE
   NFD_LOG_TRACE("elevating to effective uid=" << s_privilegedUid);
   if (::seteuid(s_privilegedUid) != 0)
     throw Error("Failed to elevate to effective uid=" + to_string(s_privilegedUid));

daemon/common/privilege-helper.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,10 +23,10 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_CORE_PRIVILEGE_HELPER_HPP
-#define NFD_CORE_PRIVILEGE_HELPER_HPP
+#ifndef NFD_DAEMON_COMMON_PRIVILEGE_HELPER_HPP
+#define NFD_DAEMON_COMMON_PRIVILEGE_HELPER_HPP
 
-#include "common.hpp"
+#include "core/common.hpp"
 
 #include <unistd.h>
 
@@ -38,7 +38,7 @@ public:
   /** \brief represents a serious seteuid/gid failure
    *
    *  This should only be caught by main as part of a graceful program termination.
-   *  \note This is not an std::exception and BOOST_THROW_EXCEPTION should not be used.
+   *  \note This is not an std::exception and NDN_THROW should not be used.
    */
   class Error
   {
@@ -96,4 +96,4 @@ PUBLIC_WITH_TESTS_ELSE_PRIVATE:
 
 } // namespace nfd
 
-#endif // NFD_CORE_PRIVILEGE_HELPER_HPP
+#endif // NFD_DAEMON_COMMON_PRIVILEGE_HELPER_HPP

daemon/face/TokenBucket.cpp

@@ -0,0 +1,62 @@
+#include "TokenBucket.hpp"
+#include "common/global.hpp"
+#include "common/logger.hpp"
+#include <iostream>
+#include <functional>
+namespace nfd {
+    namespace face {
+        NFD_LOG_INIT(QSCCPTokenBucket);
+        TokenBucket::TokenBucket(uint64_t rateLimit, uint64_t bucketSize, const std::string& name): rateLimit(rateLimit), bucketSize(bucketSize), name(name) {
+            this->eachStep = this->rateLimit / 250.0;
+            this->currentTokenSize = 0;
+            this->isStart = false;
+            // NFD_LOG_DEBUG("Create tokenBucket: " << name << ", eachStep: " << this->eachStep << ", rateLimit: " << this->rateLimit);
+        }
+        void TokenBucket::start() {
+            if (this->isStart) {
+                return;
+            }
+            // 每 4ms 增加一次令牌
+            getScheduler().schedule(time::milliseconds(4), std::bind(&TokenBucket::generateToken, this));
+        }
+        void TokenBucket::generateToken() {
+            // NFD_LOG_DEBUG(this->name << "=> do generateToken => " << this->currentTokenSize);
+            if (this->currentTokenSize + this->eachStep > this->bucketSize) {
+                this->currentTokenSize = this->bucketSize;
+            } else {
+                this->currentTokenSize += this->eachStep;
+            }
+            getScheduler().schedule(time::milliseconds(4), std::bind(&TokenBucket::generateToken, this));
+        }
+
+        void TokenBucket::generateTokenByCurrentTime(long currentTime) {
+            if (this->lastGenerateTokenTime == -1) {
+                this->lastGenerateTokenTime = currentTime;
+                return;
+            }
+            if (currentTime - this->lastGenerateTokenTime < 1) {
+                return;
+            }
+            long currentStep = (currentTime - this->lastGenerateTokenTime) * this->rateLimit / 1000.0;
+            // std::cout << "currentStep: " << currentStep << "currentTime: " << currentTime << "lastGenerateTokenTime: " << this->lastGenerateTokenTime << std::endl;
+            // NFD_LOG_DEBUG(this->name << "=> do generateToken => " << this->currentTokenSize);
+            this->lastGenerateTokenTime = currentTime;
+            if (this->currentTokenSize + currentStep > this->bucketSize) {
+                this->currentTokenSize = this->bucketSize;
+            } else {
+                this->currentTokenSize += currentStep;
+            }
+        }
+
+        bool TokenBucket::use(uint64_t tokenNum) {
+            if(this->currentTokenSize > tokenNum) {
+                this->currentTokenSize -= tokenNum;
+                // NFD_LOG_DEBUG(this->name << "=> use success => " << this->currentTokenSize);
+                return true;
+            } else {
+                // NFD_LOG_DEBUG(this->name << "=> use failed => " << this->currentTokenSize);
+                return false;
+            }
+        }
+    }
+}

daemon/face/TokenBucket.hpp

@@ -0,0 +1,41 @@
+//
+// Created by gdcni21 on 3/25/22.
+//
+#ifndef NS_TOKENBUCKET_H
+#define NS_TOKENBUCKET_H
+#include <memory>
+#include <string>
+namespace nfd {
+    namespace face {
+        class TokenBucket {
+        public:
+            explicit TokenBucket(uint64_t rateLimit, uint64_t bucketSize, const std::string& name);
+            void start();
+            /**
+             * 周期性增加token
+             **/
+            void generateToken();
+
+            /**
+             * 根据当前时间生成token
+            */
+            void generateTokenByCurrentTime(long currentTime);
+
+            /**
+             * 尝试消费n个token
+             * @param tokenNum
+             * @return
+             */
+            bool use(uint64_t tokenNum);
+        public:
+            double eachStep; // 每个周期增加的令牌
+            double currentTokenSize; // 当前令牌数
+            uint64_t rateLimit;     // 令牌生成速率
+            uint64_t bucketSize;    // 令牌桶容量
+            std::string name;
+            bool isStart; // 标识是否启动
+            long lastGenerateTokenTime = -1;
+        };
+    }
+}
+#endif //NS_TOKENBUCKET_H

daemon/face/channel-log.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2017,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,7 +26,7 @@
 #ifndef NFD_DAEMON_FACE_CHANNEL_LOG_HPP
 #define NFD_DAEMON_FACE_CHANNEL_LOG_HPP
 
-#include "core/logger.hpp"
+#include "common/logger.hpp"
 
 /** \defgroup ChannelLogging Channel logging macros
  *

daemon/face/channel.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2017,  Regents of the University of California,
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,6 +24,7 @@
  */
 
 #include "channel.hpp"
+#include "face.hpp"
 
 namespace nfd {
 namespace face {
@@ -37,14 +38,13 @@ Channel::setUri(const FaceUri& uri)
 }
 
 void
-connectFaceClosedSignal(Face& face, const std::function<void()>& f)
+connectFaceClosedSignal(Face& face, std::function<void()> f)
 {
-  face.afterStateChange.connect(
-    [f] (FaceState oldState, FaceState newState) {
-      if (newState == FaceState::CLOSED) {
-        f();
-      }
-    });
+  face.afterStateChange.connect([f = std::move(f)] (auto, FaceState newState) {
+    if (newState == FaceState::CLOSED) {
+      f();
+    }
+  });
 }
 
 } // namespace face

daemon/face/channel.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -27,29 +27,18 @@
 #define NFD_DAEMON_FACE_CHANNEL_HPP
 
 #include "channel-log.hpp"
-#include "face.hpp"
-
-#include <boost/logic/tribool.hpp>
+#include "face-common.hpp"
 
 namespace nfd {
 namespace face {
 
-/** \brief Prototype for the callback that is invoked when a face is created
- *         (in response to an incoming connection or after a connection is established)
- */
-using FaceCreatedCallback = std::function<void(const shared_ptr<Face>& face)>;
-
-/** \brief Prototype for the callback that is invoked when a face fails to be created
- */
-using FaceCreationFailedCallback = std::function<void(uint32_t status, const std::string& reason)>;
-
-/** \brief represent a channel that communicates on a local endpoint
+/** \brief Represents a channel that listens on a local endpoint.
  *  \sa FaceSystem
  *
  *  A channel can listen on a local endpoint and initiate outgoing connection from a local endpoint.
  *  A channel creates Face objects and retains shared ownership of them.
  */
-class Channel : noncopyable
+class Channel : public std::enable_shared_from_this<Channel>, noncopyable
 {
 public:
   virtual
@@ -79,31 +68,24 @@ private:
   FaceUri m_uri;
 };
 
-/** \brief Parameters used to set Transport properties or LinkService options on a newly created face
- *
- *  Parameters are passed as a struct rather than individually, so that a future change in the list
- *  of parameters does not require an update to the method signature in all subclasses.
+/** \brief Prototype for the callback that is invoked when a face is created
+ *         (in response to an incoming connection or after a connection is established).
  */
-struct FaceParams
-{
-  ndn::nfd::FacePersistency persistency = ndn::nfd::FACE_PERSISTENCY_PERSISTENT;
-  optional<time::nanoseconds> baseCongestionMarkingInterval;
-  optional<uint64_t> defaultCongestionThreshold;
-  optional<ssize_t> mtu;
-  bool wantLocalFields = false;
-  bool wantLpReliability = false;
-  boost::logic::tribool wantCongestionMarking = boost::logic::indeterminate;
-};
+using FaceCreatedCallback = std::function<void(const shared_ptr<Face>&)>;
 
-/** \brief invokes a callback when the face is closed
+/** \brief Prototype for the callback that is invoked when a face fails to be created.
+ */
+using FaceCreationFailedCallback = std::function<void(uint32_t status, const std::string& reason)>;
+
+/** \brief Invokes a callback when a face is closed.
  *  \param face the face
  *  \param f the callback to be invoked when the face enters CLOSED state
  *
- *  This function connects a callback to the afterStateChange signal on the \p face,
+ *  This function connects a callback to the afterStateChange signal of \p face,
  *  and invokes \p f when the state becomes CLOSED.
  */
 void
-connectFaceClosedSignal(Face& face, const std::function<void()>& f);
+connectFaceClosedSignal(Face& face, std::function<void()> f);
 
 } // namespace face
 } // namespace nfd

daemon/face/datagram-transport.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -28,7 +28,7 @@
 
 #include "transport.hpp"
 #include "socket-utils.hpp"
-#include "core/global-io.hpp"
+#include "common/global.hpp"
 
 #include <array>
 
@@ -69,7 +69,7 @@ protected:
   doClose() override;
 
   void
-  doSend(Transport::Packet&& packet) override;
+  doSend(const Block& packet) override;
 
   void
   handleSend(const boost::system::error_code& error, size_t nBytesSent);
@@ -157,13 +157,13 @@ DatagramTransport<T, U>::doClose()
 
 template<class T, class U>
 void
-DatagramTransport<T, U>::doSend(Transport::Packet&& packet)
+DatagramTransport<T, U>::doSend(const Block& packet)
 {
   NFD_LOG_FACE_TRACE(__func__);
 
-  m_socket.async_send(boost::asio::buffer(packet.packet),
-                      // packet.packet is copied into the lambda to retain the underlying Buffer
-                      [this, p = packet.packet] (auto&&... args) {
+  m_socket.async_send(boost::asio::buffer(packet),
+                      // 'packet' is copied into the lambda to retain the underlying Buffer
+                      [this, packet] (auto&&... args) {
                         this->handleSend(std::forward<decltype(args)>(args)...);
                       });
 }
@@ -193,9 +193,7 @@ DatagramTransport<T, U>::receiveDatagram(const uint8_t* buffer, size_t nBytesRec
   }
   m_hasRecentlyReceived = true;
 
-  Transport::Packet tp(std::move(element));
-  tp.remoteEndpoint = makeEndpointId(m_sender);
-  this->receive(std::move(tp));
+  this->receive(element, makeEndpointId(m_sender));
 }
 
 template<class T, class U>
@@ -260,7 +258,7 @@ DatagramTransport<T, U>::resetRecentlyReceived()
 }
 
 template<class T, class U>
-Transport::EndpointId
+EndpointId
 DatagramTransport<T, U>::makeEndpointId(const typename protocol::endpoint&)
 {
   return 0;

daemon/face/ethernet-channel.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -25,9 +25,10 @@
 
 #include "ethernet-channel.hpp"
 #include "ethernet-protocol.hpp"
+#include "face.hpp"
 #include "generic-link-service.hpp"
 #include "unicast-ethernet-transport.hpp"
-#include "core/global-io.hpp"
+#include "common/global.hpp"
 
 #include <boost/range/adaptor/map.hpp>
 #include <pcap/pcap.h>
@@ -89,7 +90,7 @@ EthernetChannel::listen(const FaceCreatedCallback& onFaceCreated,
     m_socket.assign(m_pcap.getFd());
   }
   catch (const PcapHelper::Error& e) {
-    BOOST_THROW_EXCEPTION(Error(e.what()));
+    NDN_THROW_NESTED(Error(e.what()));
   }
   updateFilter();
 
@@ -200,12 +201,18 @@ EthernetChannel::createFace(const ethernet::Address& remoteEndpoint,
   options.allowFragmentation = true;
   options.allowReassembly = true;
   options.reliabilityOptions.isEnabled = params.wantLpReliability;
+  if (params.mtu) {
+    options.overrideMtu = *params.mtu;
+  }
+  if (params.bandwidth) {
+    options.C = *params.bandwidth;
+  }
 
   auto linkService = make_unique<GenericLinkService>(options);
   auto transport = make_unique<UnicastEthernetTransport>(*m_localEndpoint, remoteEndpoint,
-                                                         params.persistency, m_idleFaceTimeout,
-                                                         params.mtu);
+                                                         params.persistency, m_idleFaceTimeout);
   auto face = make_shared<Face>(std::move(linkService), std::move(transport));
+  face->setChannel(shared_from_this()); // use weak_from_this() in C++17
 
   m_channelFaces[remoteEndpoint] = face;
   connectFaceClosedSignal(*face, [this, remoteEndpoint] {

daemon/face/ethernet-factory.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -37,7 +37,7 @@ NFD_LOG_INIT(EthernetFactory);
 NFD_REGISTER_PROTOCOL_FACTORY(EthernetFactory);
 
 const std::string&
-EthernetFactory::getId()
+EthernetFactory::getId() noexcept
 {
   static std::string id("ether");
   return id;
@@ -53,8 +53,8 @@ EthernetFactory::EthernetFactory(const CtorParams& params)
 }
 
 void
-EthernetFactory::processConfig(OptionalConfigSection configSection,
-                               FaceSystem::ConfigContext& context)
+EthernetFactory::doProcessConfig(OptionalConfigSection configSection,
+                                 FaceSystem::ConfigContext& context)
 {
   // ether
   // {
@@ -96,12 +96,12 @@ EthernetFactory::processConfig(OptionalConfigSection configSection,
         const std::string& valueStr = value.get_value<std::string>();
         mcastConfig.group = ethernet::Address::fromString(valueStr);
         if (mcastConfig.group.isNull()) {
-          BOOST_THROW_EXCEPTION(ConfigFile::Error("face_system.ether.mcast_group: '" +
-                                valueStr + "' cannot be parsed as an Ethernet address"));
+          NDN_THROW(ConfigFile::Error("face_system.ether.mcast_group: '" +
+                                      valueStr + "' cannot be parsed as an Ethernet address"));
         }
         else if (!mcastConfig.group.isMulticast()) {
-          BOOST_THROW_EXCEPTION(ConfigFile::Error("face_system.ether.mcast_group: '" +
-                                valueStr + "' is not a multicast address"));
+          NDN_THROW(ConfigFile::Error("face_system.ether.mcast_group: '" +
+                                      valueStr + "' is not a multicast address"));
         }
       }
       else if (key == "mcast_ad_hoc") {
@@ -115,7 +115,7 @@ EthernetFactory::processConfig(OptionalConfigSection configSection,
         mcastConfig.netifPredicate.parseBlacklist(value);
       }
       else {
-        BOOST_THROW_EXCEPTION(ConfigFile::Error("Unrecognized option face_system.ether." + key));
+        NDN_THROW(ConfigFile::Error("Unrecognized option face_system.ether." + key));
       }
     }
   }
@@ -165,18 +165,15 @@ EthernetFactory::processConfig(OptionalConfigSection configSection,
 }
 
 void
-EthernetFactory::createFace(const CreateFaceRequest& req,
-                            const FaceCreatedCallback& onCreated,
-                            const FaceCreationFailedCallback& onFailure)
+EthernetFactory::doCreateFace(const CreateFaceRequest& req,
+                              const FaceCreatedCallback& onCreated,
+                              const FaceCreationFailedCallback& onFailure)
 {
-  BOOST_ASSERT(req.remoteUri.isCanonical());
-
   if (!req.localUri || req.localUri->getScheme() != "dev") {
     NFD_LOG_TRACE("Cannot create unicast Ethernet face without dev:// LocalUri");
     onFailure(406, "Creation of unicast Ethernet faces requires a LocalUri with dev:// scheme");
     return;
   }
-  BOOST_ASSERT(req.localUri->isCanonical());
 
   if (req.params.persistency == ndn::nfd::FACE_PERSISTENCY_ON_DEMAND) {
     NFD_LOG_TRACE("createFace does not support FACE_PERSISTENCY_ON_DEMAND");
@@ -200,10 +197,10 @@ EthernetFactory::createFace(const CreateFaceRequest& req,
     return;
   }
 
-  if (req.params.mtu && *req.params.mtu < Transport::MIN_MTU) {
+  if (req.params.mtu && *req.params.mtu < MIN_MTU) {
     // The specified MTU must be greater than the minimum possible
-    NFD_LOG_TRACE("createFace cannot create a face with an MTU less than " << Transport::MIN_MTU);
-    onFailure(406, "MTU cannot be less than " + to_string(Transport::MIN_MTU));
+    NFD_LOG_TRACE("createFace: override MTU cannot be less than " << MIN_MTU);
+    onFailure(406, "Override MTU cannot be less than " + to_string(MIN_MTU));
     return;
   }
 
@@ -228,12 +225,11 @@ EthernetFactory::createChannel(const shared_ptr<const ndn::net::NetworkInterface
 
   auto channel = std::make_shared<EthernetChannel>(localEndpoint, idleTimeout);
   m_channels[localEndpoint->getName()] = channel;
-
   return channel;
 }
 
 std::vector<shared_ptr<const Channel>>
-EthernetFactory::getChannels() const
+EthernetFactory::doGetChannels() const
 {
   return getChannelsFromMap(m_channels);
 }
@@ -261,6 +257,9 @@ EthernetFactory::createMulticastFace(const ndn::net::NetworkInterface& netif,
   m_mcastFaces[key] = face;
   connectFaceClosedSignal(*face, [this, key] { m_mcastFaces.erase(key); });
 
+  auto channelIt = m_channels.find(netif.getName());
+  face->setChannel(channelIt != m_channels.end() ? channelIt->second : nullptr);
+
   return face;
 }
 
@@ -348,7 +347,7 @@ EthernetFactory::applyMcastConfigToNetif(const ndn::net::NetworkInterface& netif
 }
 
 void
-EthernetFactory::applyConfig(const FaceSystem::ConfigContext& context)
+EthernetFactory::applyConfig(const FaceSystem::ConfigContext&)
 {
   if (m_unicastConfig.isEnabled) {
     providedSchemes.insert("ether");

daemon/face/ethernet-factory.hpp

@@ -32,28 +32,17 @@
 namespace nfd {
 namespace face {
 
-/** \brief protocol factory for Ethernet
+/** \brief Protocol factory for Ethernet
  */
 class EthernetFactory : public ProtocolFactory
 {
 public:
   static const std::string&
-  getId();
+  getId() noexcept;
 
   explicit
   EthernetFactory(const CtorParams& params);
 
-  /** \brief process face_system.ether config section
-   */
-  void
-  processConfig(OptionalConfigSection configSection,
-                FaceSystem::ConfigContext& context) override;
-
-  void
-  createFace(const CreateFaceRequest& req,
-             const FaceCreatedCallback& onCreated,
-             const FaceCreationFailedCallback& onFailure) override;
-
   /**
    * \brief Create Ethernet-based channel on the specified network interface
    *
@@ -68,9 +57,6 @@ public:
   createChannel(const shared_ptr<const ndn::net::NetworkInterface>& localEndpoint,
                 time::nanoseconds idleTimeout);
 
-  std::vector<shared_ptr<const Channel>>
-  getChannels() const override;
-
   /**
    * \brief Create a face to communicate on the given Ethernet multicast group
    *
@@ -87,6 +73,20 @@ public:
                       const ethernet::Address& group);
 
 private:
+  /** \brief process face_system.ether config section
+   */
+  void
+  doProcessConfig(OptionalConfigSection configSection,
+                  FaceSystem::ConfigContext& context) override;
+
+  void
+  doCreateFace(const CreateFaceRequest& req,
+               const FaceCreatedCallback& onCreated,
+               const FaceCreationFailedCallback& onFailure) override;
+
+  std::vector<shared_ptr<const Channel>>
+  doGetChannels() const override;
+
   /** \brief Create EthernetChannel on \p netif if requested by \p m_unicastConfig.
    *  \return new or existing channel, or nullptr if no channel should be created
    */

daemon/face/ethernet-transport.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -25,7 +25,7 @@
 
 #include "ethernet-transport.hpp"
 #include "ethernet-protocol.hpp"
-#include "core/global-io.hpp"
+#include "common/global.hpp"
 
 #include <pcap/pcap.h>
 
@@ -55,9 +55,22 @@ EthernetTransport::EthernetTransport(const ndn::net::NetworkInterface& localEndp
     m_socket.assign(m_pcap.getFd());
   }
   catch (const PcapHelper::Error& e) {
-    BOOST_THROW_EXCEPTION(Error(e.what()));
+    NDN_THROW_NESTED(Error(e.what()));
   }
 
+  // Set initial transport state based upon the state of the underlying NetworkInterface
+  handleNetifStateChange(localEndpoint.getState());
+
+  m_netifStateChangedConn = localEndpoint.onStateChanged.connect(
+    [this] (ndn::net::InterfaceState, ndn::net::InterfaceState newState) {
+      handleNetifStateChange(newState);
+    });
+
+  m_netifMtuChangedConn = localEndpoint.onMtuChanged.connect(
+    [this] (uint32_t, uint32_t mtu) {
+      setMtu(mtu);
+    });
+
   asyncRead();
 }
 
@@ -83,11 +96,25 @@ EthernetTransport::doClose()
 }
 
 void
-EthernetTransport::doSend(Transport::Packet&& packet)
+EthernetTransport::handleNetifStateChange(ndn::net::InterfaceState netifState)
+{
+  NFD_LOG_FACE_TRACE("netif is " << netifState);
+  if (netifState == ndn::net::InterfaceState::RUNNING) {
+    if (getState() == TransportState::DOWN) {
+      this->setState(TransportState::UP);
+    }
+  }
+  else if (getState() == TransportState::UP) {
+    this->setState(TransportState::DOWN);
+  }
+}
+
+void
+EthernetTransport::doSend(const Block& packet)
 {
   NFD_LOG_FACE_TRACE(__func__);
 
-  sendPacket(packet.packet);
+  sendPacket(packet);
 }
 
 void
@@ -190,13 +217,13 @@ EthernetTransport::receivePayload(const uint8_t* payload, size_t length,
   }
   m_hasRecentlyReceived = true;
 
-  Transport::Packet tp(std::move(element));
-  static_assert(sizeof(tp.remoteEndpoint) >= ethernet::ADDR_LEN,
-                "Transport::Packet::remoteEndpoint is too small");
+  static_assert(sizeof(EndpointId) >= ethernet::ADDR_LEN, "EndpointId is too small");
+  EndpointId endpoint = 0;
   if (m_destAddress.isMulticast()) {
-    std::memcpy(&tp.remoteEndpoint, sender.data(), sender.size());
+    std::memcpy(&endpoint, sender.data(), sender.size());
   }
-  this->receive(std::move(tp));
+
+  this->receive(element, endpoint);
 }
 
 void

daemon/face/ethernet-transport.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2017,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -29,6 +29,7 @@
 #include "ethernet-protocol.hpp"
 #include "pcap-helper.hpp"
 #include "transport.hpp"
+
 #include <ndn-cxx/net/network-interface.hpp>
 
 namespace nfd {
@@ -43,11 +44,7 @@ public:
   class Error : public std::runtime_error
   {
   public:
-    explicit
-    Error(const std::string& what)
-      : std::runtime_error(what)
-    {
-    }
+    using std::runtime_error::runtime_error;
   };
 
   /**
@@ -81,7 +78,10 @@ protected:
 
 private:
   void
-  doSend(Transport::Packet&& packet) final;
+  handleNetifStateChange(ndn::net::InterfaceState netifState);
+
+  void
+  doSend(const Block& packet) final;
 
   /**
    * @brief Sends the specified TLV block on the network wrapped in an Ethernet frame
@@ -106,6 +106,8 @@ protected:
   std::string m_interfaceName;
 
 private:
+  signal::ScopedConnection m_netifStateChangedConn;
+  signal::ScopedConnection m_netifMtuChangedConn;
   bool m_hasRecentlyReceived;
 #ifdef _DEBUG
   /// number of frames dropped by the kernel, as reported by libpcap

daemon/face/face-common.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2017,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,28 +23,84 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_DAEMON_FACE_FACE_LOG_HPP
-#define NFD_DAEMON_FACE_FACE_LOG_HPP
+#ifndef NFD_DAEMON_FACE_FACE_COMMON_HPP
+#define NFD_DAEMON_FACE_FACE_COMMON_HPP
 
-#include "core/logger.hpp"
+#include "core/common.hpp"
+#include "common/logger.hpp"
+
+#include <ndn-cxx/encoding/nfd-constants.hpp>
+
+#include <boost/logic/tribool.hpp>
 
 namespace nfd {
 namespace face {
 
-/** \brief for internal use by FaceLogging macros
+class Face;
+class LinkService;
+
+/** \brief Identifies a face.
+ */
+using FaceId = uint64_t;
+
+/// indicates an invalid FaceId
+const FaceId INVALID_FACEID = ndn::nfd::INVALID_FACE_ID;
+/// identifies the InternalFace used in management
+const FaceId FACEID_INTERNAL_FACE = 1;
+/// identifies a packet comes from the ContentStore
+const FaceId FACEID_CONTENT_STORE = 254;
+/// identifies the NullFace that drops every packet
+const FaceId FACEID_NULL = 255;
+/// upper bound of reserved FaceIds
+const FaceId FACEID_RESERVED_MAX = 255;
+
+/** \brief Minimum MTU that may be set
  *
- *  FaceLogHelper wraps a Face, LinkService, or Transport object.
+ *  This is done to ensure the NDNLPv2 fragmentation feature functions properly.
+ */
+const ssize_t MIN_MTU = 64;
+
+/** \brief Identifies a remote endpoint on the link.
  *
- *  std::ostream& operator<<(std::ostream& os, const FaceLogHelper<T>& flh)
+ *  This ID is only meaningful in the context of the same Transport.
+ *  Incoming packets from the same remote endpoint have the same EndpointId,
+ *  and incoming packets from different remote endpoints have different EndpointIds.
+ *
+ *  Typically, a point-to-point Transport has only one meaningful EndpointId (usually 0).
+ */
+using EndpointId = uint64_t;
+
+/** \brief Parameters used to set Transport properties or LinkService options on a newly created face.
+ *
+ *  Parameters are passed as a struct rather than individually, so that a future change in the list
+ *  of parameters does not require an update to the method signature in all subclasses.
+ */
+struct FaceParams
+{
+  ndn::nfd::FacePersistency persistency = ndn::nfd::FACE_PERSISTENCY_PERSISTENT;
+  optional<time::nanoseconds> baseCongestionMarkingInterval;
+  optional<uint64_t> defaultCongestionThreshold;
+  optional<ssize_t> mtu;
+  optional<uint64_t> bandwidth;
+  bool wantLocalFields = false;
+  bool wantLpReliability = false;
+  boost::logic::tribool wantCongestionMarking = boost::logic::indeterminate;
+};
+
+/** \brief For internal use by FaceLogging macros.
+ *
+ *  FaceLogHelper wraps a reference to Face, LinkService, or Transport object.
+ *
+ *  `std::ostream& operator<<(std::ostream& os, const FaceLogHelper<T>& flh)`
  *  should be specialized to print "[id=888,local=scheme://local/uri,remote=scheme://remote/uri] "
- *  which appears as part of the log message.
+ *  which will appear as part of the log message.
  */
 template<typename T>
 class FaceLogHelper
 {
 public:
   explicit
-  FaceLogHelper(const T& obj1)
+  FaceLogHelper(const T& obj1) noexcept
     : obj(obj1)
   {
   }
@@ -54,6 +110,10 @@ public:
 };
 
 } // namespace face
+
+using face::EndpointId;
+using face::FaceId;
+
 } // namespace nfd
 
 /** \defgroup FaceLogging Face logging macros
@@ -66,6 +126,7 @@ public:
  */
 
 /** \cond */
+// implementation detail
 #define NFD_LOG_FACE(level, msg) NFD_LOG_##level( \
   ::nfd::face::FaceLogHelper< \
     typename std::remove_cv< \
@@ -92,4 +153,4 @@ public:
 
 /** @} */
 
-#endif // NFD_DAEMON_FACE_FACE_LOG_HPP
+#endif // NFD_DAEMON_FACE_FACE_COMMON_HPP

daemon/face/face-counters.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2017,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -32,7 +32,7 @@ FaceCounters::FaceCounters(const LinkService::Counters& linkServiceCounters,
                            const Transport::Counters& transportCounters)
   : nInInterests(linkServiceCounters.nInInterests)
   , nOutInterests(linkServiceCounters.nOutInterests)
-  , nDroppedInterests(linkServiceCounters.nDroppedInterests)
+  , nInterestsExceededRetx(linkServiceCounters.nInterestsExceededRetx)
   , nInData(linkServiceCounters.nInData)
   , nOutData(linkServiceCounters.nOutData)
   , nInNacks(linkServiceCounters.nInNacks)

daemon/face/face-counters.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2017,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -70,7 +70,7 @@ public:
 public:
   const PacketCounter& nInInterests;
   const PacketCounter& nOutInterests;
-  const PacketCounter& nDroppedInterests;
+  const PacketCounter& nInterestsExceededRetx;
   const PacketCounter& nInData;
   const PacketCounter& nOutData;
   const PacketCounter& nInNacks;
@@ -81,6 +81,14 @@ public:
   const ByteCounter& nInBytes;
   const ByteCounter& nOutBytes;
 
+  /** \brief count of incoming Interests dropped due to HopLimit == 0
+   */
+  PacketCounter nInHopLimitZero;
+
+  /** \brief count of outgoing Interests dropped due to HopLimit == 0 on non-local faces
+   */
+  PacketCounter nOutHopLimitZero;
+
 private:
   const LinkService::Counters& m_linkServiceCounters;
   const Transport::Counters& m_transportCounters;

daemon/face/face-endpoint.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2016,  Regents of the University of California,
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,28 +23,36 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_DAEMON_FW_CLIENT_CONTROL_STRATEGY_HPP
-#define NFD_DAEMON_FW_CLIENT_CONTROL_STRATEGY_HPP
+#ifndef NFD_DAEMON_FACE_FACE_ENDPOINT_HPP
+#define NFD_DAEMON_FACE_FACE_ENDPOINT_HPP
 
-#include "best-route-strategy.hpp"
+#include "face.hpp"
 
 namespace nfd {
-namespace fw {
 
-/** \brief identical to BestRouteStrategy v1, for backwards compatibility
- *  \deprecated NextHopFaceId field is honored universally and it's unnecessary to set this strategy
+/** \brief Represents a face-endpoint pair in the forwarder.
+ *  \sa face::Face, face::EndpointId
  */
-class ClientControlStrategy : public BestRouteStrategyBase
+class FaceEndpoint
 {
 public:
-  explicit
-  ClientControlStrategy(Forwarder& forwarder, const Name& name = getStrategyName());
+  FaceEndpoint(const Face& face, EndpointId endpoint)
+    : face(const_cast<Face&>(face))
+    , endpoint(endpoint)
+  {
+  }
 
-  static const Name&
-  getStrategyName();
+public:
+  Face& face;
+  const EndpointId endpoint;
 };
 
-} // namespace fw
+inline std::ostream&
+operator<<(std::ostream& os, const FaceEndpoint& fe)
+{
+  return os << '(' << fe.face.getId() << ',' << fe.endpoint << ')';
+}
+
 } // namespace nfd
 
-#endif // NFD_DAEMON_FW_CLIENT_CONTROL_STRATEGY_HPP
+#endif // NFD_DAEMON_FACE_FACE_ENDPOINT_HPP

daemon/face/face-system.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -25,7 +25,8 @@
 
 #include "face-system.hpp"
 #include "protocol-factory.hpp"
-#include "core/global-io.hpp"
+#include "netdev-bound.hpp"
+#include "common/global.hpp"
 #include "fw/face-table.hpp"
 
 namespace nfd {
@@ -33,21 +34,28 @@ namespace face {
 
 NFD_LOG_INIT(FaceSystem);
 
+const std::string CFGSEC_FACESYSTEM = "face_system";
+const std::string CFGSEC_GENERAL = "general";
+const std::string CFGSEC_GENERAL_FQ = CFGSEC_FACESYSTEM + ".general";
+const std::string CFGSEC_NETDEVBOUND = "netdev_bound";
+
 FaceSystem::FaceSystem(FaceTable& faceTable, shared_ptr<ndn::net::NetworkMonitor> netmon)
   : m_faceTable(faceTable)
   , m_netmon(std::move(netmon))
 {
   auto pfCtorParams = this->makePFCtorParams();
-  for (const std::string& id : ProtocolFactory::listRegistered()) {
+  for (const auto& id : ProtocolFactory::listRegistered()) {
     NFD_LOG_TRACE("creating factory " << id);
     m_factories[id] = ProtocolFactory::create(id, pfCtorParams);
   }
+
+  m_netdevBound = make_unique<NetdevBound>(pfCtorParams, *this);
 }
 
 ProtocolFactoryCtorParams
 FaceSystem::makePFCtorParams()
 {
-  auto addFace = [&ft = m_faceTable] (auto face) { ft.add(std::move(face)); };
+  auto addFace = [this] (auto face) { m_faceTable.add(std::move(face)); };
   return {addFace, m_netmon};
 }
 
@@ -77,33 +85,39 @@ FaceSystem::getFactoryByScheme(const std::string& scheme)
   return found == m_factoryByScheme.end() ? nullptr : found->second;
 }
 
-void
-FaceSystem::setConfigFile(ConfigFile& configFile)
+bool
+FaceSystem::hasFactoryForScheme(const std::string& scheme) const
 {
-  configFile.addSectionHandler("face_system", bind(&FaceSystem::processConfig, this, _1, _2, _3));
+  return m_factoryByScheme.count(scheme) > 0;
 }
 
 void
-FaceSystem::processConfig(const ConfigSection& configSection, bool isDryRun, const std::string& filename)
+FaceSystem::setConfigFile(ConfigFile& configFile)
+{
+  configFile.addSectionHandler(CFGSEC_FACESYSTEM, bind(&FaceSystem::processConfig, this, _1, _2, _3));
+}
+
+void
+FaceSystem::processConfig(const ConfigSection& configSection, bool isDryRun, const std::string&)
 {
   ConfigContext context;
   context.isDryRun = isDryRun;
 
   // process general protocol factory config section
-  auto generalSection = configSection.get_child_optional("general");
+  auto generalSection = configSection.get_child_optional(CFGSEC_GENERAL);
   if (generalSection) {
     for (const auto& pair : *generalSection) {
       const std::string& key = pair.first;
       if (key == "enable_congestion_marking") {
-        context.generalConfig.wantCongestionMarking = ConfigFile::parseYesNo(pair, "face_system.general");
+        context.generalConfig.wantCongestionMarking = ConfigFile::parseYesNo(pair, CFGSEC_GENERAL_FQ);
       }
       else {
-        BOOST_THROW_EXCEPTION(ConfigFile::Error("Unrecognized option face_system.general." + key));
+        NDN_THROW(ConfigFile::Error("Unrecognized option " + CFGSEC_GENERAL_FQ + "." + key));
       }
     }
   }
 
-  // process sections in protocol factories
+  // process in protocol factories
   for (const auto& pair : m_factories) {
     const std::string& sectionName = pair.first;
     ProtocolFactory* factory = pair.second.get();
@@ -127,6 +141,10 @@ FaceSystem::processConfig(const ConfigSection& configSection, bool isDryRun, con
     }
   }
 
+  // process netdev_bound section, after factories start providing *+dev schemes
+  auto netdevBoundSection = configSection.get_child_optional(CFGSEC_NETDEVBOUND);
+  m_netdevBound->processConfig(netdevBoundSection, context);
+
   // process other sections
   std::set<std::string> seenSections;
   for (const auto& pair : configSection) {
@@ -134,16 +152,15 @@ FaceSystem::processConfig(const ConfigSection& configSection, bool isDryRun, con
     // const ConfigSection& subSection = pair.second;
 
     if (!seenSections.insert(sectionName).second) {
-      BOOST_THROW_EXCEPTION(ConfigFile::Error("Duplicate section face_system." + sectionName));
+      NDN_THROW(ConfigFile::Error("Duplicate section " + CFGSEC_FACESYSTEM + "." + sectionName));
     }
 
-    if (sectionName == "general" || m_factories.count(sectionName) > 0) {
+    if (sectionName == CFGSEC_GENERAL || sectionName == CFGSEC_NETDEVBOUND ||
+        m_factories.count(sectionName) > 0) {
       continue;
     }
 
-    ///\todo #3521 nicfaces
-
-    BOOST_THROW_EXCEPTION(ConfigFile::Error("Unrecognized option face_system." + sectionName));
+    NDN_THROW(ConfigFile::Error("Unrecognized option " + CFGSEC_FACESYSTEM + "." + sectionName));
   }
 }
 

daemon/face/face-system.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,9 +26,9 @@
 #ifndef NFD_DAEMON_FACE_FACE_SYSTEM_HPP
 #define NFD_DAEMON_FACE_FACE_SYSTEM_HPP
 
-#include "channel.hpp"
-#include "core/config-file.hpp"
-#include "core/network-predicate.hpp"
+#include "network-predicate.hpp"
+#include "common/config-file.hpp"
+
 #include <ndn-cxx/net/network-address.hpp>
 #include <ndn-cxx/net/network-interface.hpp>
 #include <ndn-cxx/net/network-monitor.hpp>
@@ -39,6 +39,7 @@ class FaceTable;
 
 namespace face {
 
+class NetdevBound;
 class ProtocolFactory;
 struct ProtocolFactoryCtorParams;
 
@@ -69,6 +70,9 @@ public:
   ProtocolFactory*
   getFactoryByScheme(const std::string& scheme);
 
+  bool
+  hasFactoryForScheme(const std::string& scheme) const;
+
   FaceTable&
   getFaceTable()
   {
@@ -109,6 +113,7 @@ PUBLIC_WITH_TESTS_ELSE_PRIVATE:
   /** \brief config section name => protocol factory
    */
   std::map<std::string, unique_ptr<ProtocolFactory>> m_factories;
+  unique_ptr<NetdevBound> m_netdevBound;
 
 private:
   /** \brief scheme => protocol factory
@@ -118,7 +123,6 @@ private:
   std::map<std::string, ProtocolFactory*> m_factoryByScheme;
 
   FaceTable& m_faceTable;
-
   shared_ptr<ndn::net::NetworkMonitor> m_netmon;
 };
 

daemon/face/face.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,28 +26,15 @@
 #ifndef NFD_DAEMON_FACE_FACE_HPP
 #define NFD_DAEMON_FACE_FACE_HPP
 
+#include "face-common.hpp"
 #include "face-counters.hpp"
-#include "face-log.hpp"
 #include "link-service.hpp"
 #include "transport.hpp"
 
 namespace nfd {
 namespace face {
 
-/** \brief identifies a face
- */
-typedef uint64_t FaceId;
-
-/// indicates an invalid FaceId
-const FaceId INVALID_FACEID = 0;
-/// identifies the InternalFace used in management
-const FaceId FACEID_INTERNAL_FACE = 1;
-/// identifies a packet comes from the ContentStore
-const FaceId FACEID_CONTENT_STORE = 254;
-/// identifies the NullFace that drops every packet
-const FaceId FACEID_NULL = 255;
-/// upper bound of reserved FaceIds
-const FaceId FACEID_RESERVED_MAX = 255;
+class Channel;
 
 /** \brief indicates the state of a face
  */
@@ -64,11 +51,7 @@ typedef TransportState FaceState;
  *  LinkService is the upper part, which translates between network-layer packets
  *  and TLV blocks, and may provide additional services such as fragmentation and reassembly.
  */
-class Face
-#ifndef WITH_TESTS
-final
-#endif
-  : public std::enable_shared_from_this<Face>, noncopyable
+class Face FINAL_UNLESS_WITH_TESTS : public std::enable_shared_from_this<Face>, noncopyable
 {
 public:
   Face(unique_ptr<LinkService> service, unique_ptr<Transport> transport);
@@ -79,39 +62,51 @@ public:
   Transport*
   getTransport() const;
 
+  /** \brief Request that the face be closed
+   *
+   *  This operation is effective only if face is in the UP or DOWN state; otherwise, it has no effect.
+   *  The face will change state to CLOSING, and then perform a cleanup procedure.
+   *  When the cleanup is complete, the state will be changed to CLOSED, which may happen
+   *  synchronously or asynchronously.
+   *
+   *  \warning The face must not be deallocated until its state changes to CLOSED.
+   */
+  void
+  close();
+
 public: // upper interface connected to forwarding
-  /** \brief sends Interest on Face
+  /** \brief send Interest
    */
   void
   sendInterest(const Interest& interest);
 
-  /** \brief sends Data on Face
+  /** \brief send Data
    */
   void
   sendData(const Data& data);
 
-  /** \brief sends Nack on Face
+  /** \brief send Nack
    */
   void
   sendNack(const lp::Nack& nack);
 
   /** \brief signals on Interest received
    */
-  signal::Signal<LinkService, Interest>& afterReceiveInterest;
+  signal::Signal<LinkService, Interest, EndpointId>& afterReceiveInterest;
 
   /** \brief signals on Data received
    */
-  signal::Signal<LinkService, Data>& afterReceiveData;
+  signal::Signal<LinkService, Data, EndpointId>& afterReceiveData;
 
   /** \brief signals on Nack received
    */
-  signal::Signal<LinkService, lp::Nack>& afterReceiveNack;
+  signal::Signal<LinkService, lp::Nack, EndpointId>& afterReceiveNack;
 
   /** \brief signals on Interest dropped by reliability system for exceeding allowed number of retx
    */
   signal::Signal<LinkService, Interest>& onDroppedInterest;
 
-public: // static properties
+public: // properties
   /** \return face ID
    */
   FaceId
@@ -153,7 +148,13 @@ public: // static properties
   ndn::nfd::LinkType
   getLinkType() const;
 
-public: // dynamic properties
+  /** \brief Returns face effective MTU
+   *
+   *  This function is a wrapper. The effective MTU of a face is determined by the link service.
+   */
+  ssize_t
+  getMtu() const;
+
   /** \return face state
    */
   FaceState
@@ -169,27 +170,33 @@ public: // dynamic properties
   time::steady_clock::TimePoint
   getExpirationTime() const;
 
-  /** \brief request the face to be closed
-   *
-   *  This operation is effective only if face is in UP or DOWN state,
-   *  otherwise it has no effect.
-   *  The face changes state to CLOSING, and performs cleanup procedure.
-   *  The state will be changed to CLOSED when cleanup is complete, which may
-   *  happen synchronously or asynchronously.
-   *
-   *  \warning the face must not be deallocated until its state changes to CLOSED
-   */
-  void
-  close();
-
   const FaceCounters&
   getCounters() const;
 
+  /**
+   * \brief Get channel on which face was created (unicast) or the associated channel (multicast)
+   */
+  weak_ptr<Channel>
+  getChannel() const
+  {
+    return m_channel;
+  }
+
+  /**
+   * \brief Set channel on which face was created (unicast) or the associated channel (multicast)
+   */
+  void
+  setChannel(weak_ptr<Channel> channel)
+  {
+    m_channel = std::move(channel);
+  }
+
 private:
   FaceId m_id;
   unique_ptr<LinkService> m_service;
   unique_ptr<Transport> m_transport;
   FaceCounters m_counters;
+  weak_ptr<Channel> m_channel;
 };
 
 inline LinkService*
@@ -204,6 +211,12 @@ Face::getTransport() const
   return m_transport.get();
 }
 
+inline void
+Face::close()
+{
+  m_transport->close();
+}
+
 inline void
 Face::sendInterest(const Interest& interest)
 {
@@ -270,6 +283,12 @@ Face::getLinkType() const
   return m_transport->getLinkType();
 }
 
+inline ssize_t
+Face::getMtu() const
+{
+  return m_service->getEffectiveMtu();
+}
+
 inline FaceState
 Face::getState() const
 {
@@ -282,12 +301,6 @@ Face::getExpirationTime() const
   return m_transport->getExpirationTime();
 }
 
-inline void
-Face::close()
-{
-  m_transport->close();
-}
-
 inline const FaceCounters&
 Face::getCounters() const
 {
@@ -299,7 +312,6 @@ operator<<(std::ostream& os, const FaceLogHelper<Face>& flh);
 
 } // namespace face
 
-using face::FaceId;
 using face::Face;
 
 } // namespace nfd

daemon/face/generic-link-service.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,7 +24,8 @@
  */
 
 #include "generic-link-service.hpp"
-
+#include <iostream>
+#include <ndn-cxx/lp/pit-token.hpp>
 #include <ndn-cxx/lp/tags.hpp>
 
 #include <cmath>
@@ -34,7 +35,9 @@ namespace face {
 
 NFD_LOG_INIT(GenericLinkService);
 
-constexpr uint32_t DEFAULT_CONGESTION_THRESHOLD_DIVISOR = 2;
+constexpr size_t CONGESTION_MARK_SIZE = tlv::sizeOfVarNumber(lp::tlv::CongestionMark) + // type
+                                        tlv::sizeOfVarNumber(sizeof(uint64_t)) +        // length
+                                        tlv::sizeOfNonNegativeInteger(UINT64_MAX);      // value
 
 GenericLinkService::GenericLinkService(const GenericLinkService::Options& options)
   : m_options(options)
@@ -43,12 +46,45 @@ GenericLinkService::GenericLinkService(const GenericLinkService::Options& option
   , m_reliability(m_options.reliabilityOptions, this)
   , m_lastSeqNo(-2)
   , m_nextMarkTime(time::steady_clock::TimePoint::max())
-  , m_lastMarkTime(time::steady_clock::TimePoint::min())
   , m_nMarkedSinceInMarkingState(0)
+  , globalSp(options.C * 0.99, options.vqSize)
 {
+  std::cout << "C: " << options.C << std::endl;
   m_reassembler.beforeTimeout.connect([this] (auto...) { ++this->nReassemblyTimeouts; });
   m_reliability.onDroppedInterest.connect([this] (const auto& i) { this->notifyDroppedInterest(i); });
   nReassembling.observe(&m_reassembler);
+  this->sendPacketCallback = [this](std::shared_ptr<VirtualQueueItem> taskPtr) {
+        this->globalSp.triggerCalObjectRate();
+        if (taskPtr != nullptr) {
+            const Block &block = taskPtr->item->wireEncode();
+            // std::cout << "interest wireEncode size: " << block.size() << std::endl;
+            lp::Packet lpPacket(block);
+            // std::cout << "Interest lppacket size before encode lp fields: " << lpPacket.wireEncode().size() << std::endl;
+            encodeLpFields(*(taskPtr->item), lpPacket);
+            // std::cout << "Interest lppacket size after encode lp fields: " << lpPacket.wireEncode().size() << std::endl;
+            this->sendNetPacket(std::move(lpPacket), true);
+            // lp::Packet lpPacket(taskPtr->item->wireEncode());
+            // encodeLpFields(*(taskPtr->item), lpPacket);
+            // this->sendNetPacket(std::move(lpPacket), taskPtr->endpointId, true);
+        }
+        // 得到下一个需要调度的包
+        auto newTaskPtr = this->globalSp.scheduleNext();
+        if (newTaskPtr == nullptr) {
+            //NFD_LOG_ERROR("FUCK");
+            // std::cout << "FUCK" << std::endl;
+            // 如果没有可调度的包,则 1 ms 之后再调度
+            this->canScheduler = true;
+//            getScheduler().schedule(time::milliseconds(1), std::bind(this->sendPacketCallback, nullptr));
+        } else {
+            // 等待足够的 token 再发送
+            this->canScheduler = false;
+            // std::cout << "Route waitTime: " << newTaskPtr->waitNsTime << std::endl;
+            // NFD_LOG_DEBUG("Route waitTime: " << newTaskPtr->waitNsTime);
+            getScheduler().schedule(time::nanoseconds((uint32_t)(0)),
+                                    std::bind(this->sendPacketCallback, newTaskPtr));
+        }
+    };
+    // getScheduler().schedule(time::nanoseconds(0), std::bind(this->sendPacketCallback, nullptr));
 }
 
 void
@@ -60,18 +96,38 @@ GenericLinkService::setOptions(const GenericLinkService::Options& options)
   m_reliability.setOptions(m_options.reliabilityOptions);
 }
 
+ssize_t
+GenericLinkService::getEffectiveMtu() const
+{
+  // Since MTU_UNLIMITED is negative, it will implicitly override any finite override MTU
+  return std::min(m_options.overrideMtu, getTransport()->getMtu());
+}
+
+bool
+GenericLinkService::canOverrideMtuTo(ssize_t mtu) const
+{
+  // Not allowed to override unlimited transport MTU
+  if (getTransport()->getMtu() == MTU_UNLIMITED) {
+    return false;
+  }
+
+  // Override MTU must be at least MIN_MTU (also implicitly forbids MTU_UNLIMITED and MTU_INVALID)
+  return mtu >= MIN_MTU;
+}
+
 void
 GenericLinkService::requestIdlePacket()
 {
   // No need to request Acks to attach to this packet from LpReliability, as they are already
   // attached in sendLpPacket
+  NFD_LOG_FACE_TRACE("IDLE packet requested");
   this->sendLpPacket({});
 }
 
 void
 GenericLinkService::sendLpPacket(lp::Packet&& pkt)
 {
-  const ssize_t mtu = this->getTransport()->getMtu();
+  const ssize_t mtu = getEffectiveMtu();
 
   if (m_options.reliabilityOptions.isEnabled) {
     m_reliability.piggyback(pkt, mtu);
@@ -81,23 +137,46 @@ GenericLinkService::sendLpPacket(lp::Packet&& pkt)
     checkCongestionLevel(pkt);
   }
 
-  Transport::Packet tp(pkt.wireEncode());
-  if (mtu != MTU_UNLIMITED && tp.packet.size() > static_cast<size_t>(mtu)) {
+  auto block = pkt.wireEncode();
+  if (mtu != MTU_UNLIMITED && block.size() > static_cast<size_t>(mtu)) {
     ++this->nOutOverMtu;
     NFD_LOG_FACE_WARN("attempted to send packet over MTU limit");
     return;
   }
-  this->sendPacket(std::move(tp));
+  this->sendPacket(block);
 }
 
 void
 GenericLinkService::doSendInterest(const Interest& interest)
 {
-  lp::Packet lpPacket(interest.wireEncode());
+  if (interest.getName().getPrefix(1).toUri() == "/localhost") {
+        const Block &block = interest.wireEncode();
+        // // std::cout << "interest wireEncode size: " << block.size() << std::endl;
+        lp::Packet lpPacket(block);
+        // // std::cout << "lppacket size before encode lp fields: " << lpPacket.wireEncode().size() << std::endl;
+        encodeLpFields(interest, lpPacket);
+        // // std::cout << "lppacket size after encode lp fields: " << lpPacket.wireEncode().size() << std::endl;
+        this->sendNetPacket(std::move(lpPacket), true);
+    } else {
+        this->globalSp.appendInterest(interest);
+        if (this->canScheduler) {
+            this->sendPacketCallback(nullptr);
+        }
+        //if (!success) {
+        //    // send Nack
+        //    lp::Nack nack(interest);
+        //    nack.setReason(lp::NackReason::CONGESTION);
+        //    if (this->nwfq.canMark(nack)) {
+        //        // 拥塞标记
+        //        nack.getInterest().setTag(make_shared<lp::CongestionMarkTag>(1));
+        //    }
+        //    this->receiveNack(nack, endpointId);
+        //}
+    }
 
-  encodeLpFields(interest, lpPacket);
+  // encodeLpFields(interest, lpPacket);
 
-  this->sendNetPacket(std::move(lpPacket), true);
+  // this->sendNetPacket(std::move(lpPacket), true);
 }
 
 void
@@ -121,39 +200,52 @@ GenericLinkService::doSendNack(const lp::Nack& nack)
   this->sendNetPacket(std::move(lpPacket), false);
 }
 
+void
+GenericLinkService::assignSequences(std::vector<lp::Packet>& pkts)
+{
+  std::for_each(pkts.begin(), pkts.end(), [this] (lp::Packet& pkt) {
+    pkt.set<lp::SequenceField>(++m_lastSeqNo);
+  });
+}
+
 void
 GenericLinkService::encodeLpFields(const ndn::PacketBase& netPkt, lp::Packet& lpPacket)
 {
   if (m_options.allowLocalFields) {
-    shared_ptr<lp::IncomingFaceIdTag> incomingFaceIdTag = netPkt.getTag<lp::IncomingFaceIdTag>();
+    auto incomingFaceIdTag = netPkt.getTag<lp::IncomingFaceIdTag>();
     if (incomingFaceIdTag != nullptr) {
       lpPacket.add<lp::IncomingFaceIdField>(*incomingFaceIdTag);
     }
   }
 
-  shared_ptr<lp::CongestionMarkTag> congestionMarkTag = netPkt.getTag<lp::CongestionMarkTag>();
+  auto congestionMarkTag = netPkt.getTag<lp::CongestionMarkTag>();
   if (congestionMarkTag != nullptr) {
     lpPacket.add<lp::CongestionMarkField>(*congestionMarkTag);
   }
 
   if (m_options.allowSelfLearning) {
-    shared_ptr<lp::NonDiscoveryTag> nonDiscoveryTag = netPkt.getTag<lp::NonDiscoveryTag>();
+    auto nonDiscoveryTag = netPkt.getTag<lp::NonDiscoveryTag>();
     if (nonDiscoveryTag != nullptr) {
       lpPacket.add<lp::NonDiscoveryField>(*nonDiscoveryTag);
     }
 
-    shared_ptr<lp::PrefixAnnouncementTag> prefixAnnouncementTag = netPkt.getTag<lp::PrefixAnnouncementTag>();
+    auto prefixAnnouncementTag = netPkt.getTag<lp::PrefixAnnouncementTag>();
     if (prefixAnnouncementTag != nullptr) {
       lpPacket.add<lp::PrefixAnnouncementField>(*prefixAnnouncementTag);
     }
   }
+
+  auto pitToken = netPkt.getTag<lp::PitToken>();
+  if (pitToken != nullptr) {
+    lpPacket.add<lp::PitTokenField>(*pitToken);
+  }
 }
 
 void
 GenericLinkService::sendNetPacket(lp::Packet&& pkt, bool isInterest)
 {
   std::vector<lp::Packet> frags;
-  ssize_t mtu = this->getTransport()->getMtu();
+  ssize_t mtu = getEffectiveMtu();
 
   // Make space for feature fields in fragments
   if (m_options.reliabilityOptions.isEnabled && mtu != MTU_UNLIMITED) {
@@ -164,7 +256,8 @@ GenericLinkService::sendNetPacket(lp::Packet&& pkt, bool isInterest)
     mtu -= CONGESTION_MARK_SIZE;
   }
 
-  BOOST_ASSERT(mtu == MTU_UNLIMITED || mtu > 0);
+  // An MTU of 0 is allowed but will cause all packets to be dropped before transmission
+  BOOST_ASSERT(mtu == MTU_UNLIMITED || mtu >= 0);
 
   if (m_options.allowFragmentation && mtu != MTU_UNLIMITED) {
     bool isOk = false;
@@ -191,8 +284,8 @@ GenericLinkService::sendNetPacket(lp::Packet&& pkt, bool isInterest)
     BOOST_ASSERT(!frags.front().has<lp::FragCountField>());
   }
 
-  // Only assign sequences to fragments if packet contains more than 1 fragment
-  if (frags.size() > 1) {
+  // Only assign sequences to fragments if reliability enabled or if packet contains >1 fragment
+  if (m_options.reliabilityOptions.isEnabled || frags.size() > 1) {
     // Assign sequences to all fragments
     this->assignSequences(frags);
   }
@@ -206,50 +299,30 @@ GenericLinkService::sendNetPacket(lp::Packet&& pkt, bool isInterest)
   }
 }
 
-void
-GenericLinkService::assignSequence(lp::Packet& pkt)
-{
-  pkt.set<lp::SequenceField>(++m_lastSeqNo);
-}
-
-void
-GenericLinkService::assignSequences(std::vector<lp::Packet>& pkts)
-{
-  std::for_each(pkts.begin(), pkts.end(), [this] (auto& pkt) { this->assignSequence(pkt); });
-}
-
 void
 GenericLinkService::checkCongestionLevel(lp::Packet& pkt)
 {
   ssize_t sendQueueLength = getTransport()->getSendQueueLength();
-  // This operation requires that the transport supports retrieving current send queue length
+  // The transport must support retrieving the current send queue length
   if (sendQueueLength < 0) {
     return;
   }
 
-  // To avoid overflowing the queue, set the congestion threshold to at least half of the send
-  // queue capacity.
-  size_t congestionThreshold = m_options.defaultCongestionThreshold;
-  if (getTransport()->getSendQueueCapacity() >= 0) {
-    congestionThreshold = std::min(congestionThreshold,
-                                   static_cast<size_t>(getTransport()->getSendQueueCapacity()) /
-                                                       DEFAULT_CONGESTION_THRESHOLD_DIVISOR);
-  }
-
   if (sendQueueLength > 0) {
-    NFD_LOG_FACE_TRACE("txqlen=" << sendQueueLength << " threshold=" << congestionThreshold <<
-                       " capacity=" << getTransport()->getSendQueueCapacity());
+    NFD_LOG_FACE_TRACE("txqlen=" << sendQueueLength << " threshold=" <<
+                       m_options.defaultCongestionThreshold << " capacity=" <<
+                       getTransport()->getSendQueueCapacity());
   }
 
-  if (static_cast<size_t>(sendQueueLength) > congestionThreshold) { // Send queue is congested
+  // sendQueue is above target
+  if (static_cast<size_t>(sendQueueLength) > m_options.defaultCongestionThreshold) {
     const auto now = time::steady_clock::now();
-    if (now >= m_nextMarkTime || now >= m_lastMarkTime + m_options.baseCongestionMarkingInterval) {
-      // Mark at most one initial packet per baseCongestionMarkingInterval
-      if (m_nMarkedSinceInMarkingState == 0) {
-        m_nextMarkTime = now;
-      }
 
-      // Time to mark packet
+    if (m_nextMarkTime == time::steady_clock::TimePoint::max()) {
+      m_nextMarkTime = now + m_options.baseCongestionMarkingInterval;
+    }
+    // Mark packet if sendQueue stays above target for one interval
+    else if (now >= m_nextMarkTime) {
       pkt.set<lp::CongestionMarkField>(1);
       ++nCongestionMarked;
       NFD_LOG_FACE_DEBUG("LpPacket was marked as congested");
@@ -257,10 +330,10 @@ GenericLinkService::checkCongestionLevel(lp::Packet& pkt)
       ++m_nMarkedSinceInMarkingState;
       // Decrease the marking interval by the inverse of the square root of the number of packets
       // marked in this incident of congestion
-      m_nextMarkTime += time::nanoseconds(static_cast<time::nanoseconds::rep>(
-                                            m_options.baseCongestionMarkingInterval.count() /
-                                            std::sqrt(m_nMarkedSinceInMarkingState)));
-      m_lastMarkTime = now;
+      time::nanoseconds interval(static_cast<time::nanoseconds::rep>(
+                                   m_options.baseCongestionMarkingInterval.count() /
+                                   std::sqrt(m_nMarkedSinceInMarkingState + 1)));
+      m_nextMarkTime += interval;
     }
   }
   else if (m_nextMarkTime != time::steady_clock::TimePoint::max()) {
@@ -272,13 +345,17 @@ GenericLinkService::checkCongestionLevel(lp::Packet& pkt)
 }
 
 void
-GenericLinkService::doReceivePacket(Transport::Packet&& packet)
+GenericLinkService::doReceivePacket(const Block& packet, const EndpointId& endpoint)
 {
   try {
-    lp::Packet pkt(packet.packet);
+    lp::Packet pkt(packet);
 
     if (m_options.reliabilityOptions.isEnabled) {
-      m_reliability.processIncomingPacket(pkt);
+      if (!m_reliability.processIncomingPacket(pkt)) {
+        NFD_LOG_FACE_TRACE("received duplicate fragment: DROP");
+        ++this->nDuplicateSequence;
+        return;
+      }
     }
 
     if (!pkt.has<lp::FragmentField>()) {
@@ -295,10 +372,9 @@ GenericLinkService::doReceivePacket(Transport::Packet&& packet)
     bool isReassembled = false;
     Block netPkt;
     lp::Packet firstPkt;
-    std::tie(isReassembled, netPkt, firstPkt) = m_reassembler.receiveFragment(packet.remoteEndpoint,
-                                                                              pkt);
+    std::tie(isReassembled, netPkt, firstPkt) = m_reassembler.receiveFragment(endpoint, pkt);
     if (isReassembled) {
-      this->decodeNetPacket(netPkt, firstPkt);
+      this->decodeNetPacket(netPkt, firstPkt, endpoint);
     }
   }
   catch (const tlv::Error& e) {
@@ -308,20 +384,21 @@ GenericLinkService::doReceivePacket(Transport::Packet&& packet)
 }
 
 void
-GenericLinkService::decodeNetPacket(const Block& netPkt, const lp::Packet& firstPkt)
+GenericLinkService::decodeNetPacket(const Block& netPkt, const lp::Packet& firstPkt,
+                                    const EndpointId& endpointId)
 {
   try {
     switch (netPkt.type()) {
       case tlv::Interest:
         if (firstPkt.has<lp::NackField>()) {
-          this->decodeNack(netPkt, firstPkt);
+          this->decodeNack(netPkt, firstPkt, endpointId);
         }
         else {
-          this->decodeInterest(netPkt, firstPkt);
+          this->decodeInterest(netPkt, firstPkt, endpointId);
         }
         break;
       case tlv::Data:
-        this->decodeData(netPkt, firstPkt);
+        this->decodeData(netPkt, firstPkt, endpointId);
         break;
       default:
         ++this->nInNetInvalid;
@@ -331,12 +408,13 @@ GenericLinkService::decodeNetPacket(const Block& netPkt, const lp::Packet& first
   }
   catch (const tlv::Error& e) {
     ++this->nInNetInvalid;
-    NFD_LOG_FACE_WARN("packet parse error (" << e.what() << "): DROP");
+    NFD_LOG_FACE_WARN("packet parse error (" << e.what() << "): DROP" << netPkt.type());
   }
 }
 
 void
-GenericLinkService::decodeInterest(const Block& netPkt, const lp::Packet& firstPkt)
+GenericLinkService::decodeInterest(const Block& netPkt, const lp::Packet& firstPkt,
+                                   const EndpointId& endpointId)
 {
   BOOST_ASSERT(netPkt.type() == tlv::Interest);
   BOOST_ASSERT(!firstPkt.has<lp::NackField>());
@@ -383,11 +461,18 @@ GenericLinkService::decodeInterest(const Block& netPkt, const lp::Packet& firstP
     return;
   }
 
-  this->receiveInterest(*interest);
+  if (firstPkt.has<lp::PitTokenField>()) {
+    interest->setTag(make_shared<lp::PitToken>(firstPkt.get<lp::PitTokenField>()));
+  }
+
+  this->globalSp.receiveInterest(*interest);
+  this->globalSp.triggerCalObjectRate();
+  this->receiveInterest(*interest, endpointId);
 }
 
 void
-GenericLinkService::decodeData(const Block& netPkt, const lp::Packet& firstPkt)
+GenericLinkService::decodeData(const Block& netPkt, const lp::Packet& firstPkt,
+                               const EndpointId& endpointId)
 {
   BOOST_ASSERT(netPkt.type() == tlv::Data);
 
@@ -436,11 +521,19 @@ GenericLinkService::decodeData(const Block& netPkt, const lp::Packet& firstPkt)
     }
   }
 
-  this->receiveData(*data);
+  // 不处理本地命令通信
+  if (data->getName().getPrefix(1).toUri() != "/localhost") {
+      // TR = min(TR, OR)
+      this->globalSp.assignObjectRate(*data);
+  }
+
+  this->globalSp.triggerCalObjectRate();
+  this->receiveData(*data, endpointId);
 }
 
 void
-GenericLinkService::decodeNack(const Block& netPkt, const lp::Packet& firstPkt)
+GenericLinkService::decodeNack(const Block& netPkt, const lp::Packet& firstPkt,
+                               const EndpointId& endpointId)
 {
   BOOST_ASSERT(netPkt.type() == tlv::Interest);
   BOOST_ASSERT(firstPkt.has<lp::NackField>());
@@ -480,7 +573,7 @@ GenericLinkService::decodeNack(const Block& netPkt, const lp::Packet& firstPkt)
     return;
   }
 
-  this->receiveNack(nack);
+  this->receiveNack(nack, endpointId);
 }
 
 } // namespace face

daemon/face/generic-link-service.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -30,6 +30,7 @@
 #include "lp-fragmenter.hpp"
 #include "lp-reassembler.hpp"
 #include "lp-reliability.hpp"
+#include "queues.hpp"
 
 namespace nfd {
 namespace face {
@@ -81,6 +82,10 @@ public:
    */
   PacketCounter nRetxExhausted;
 
+  /** \brief count of LpPackets dropped due to duplicate Sequence numbers
+   */
+  PacketCounter nDuplicateSequence;
+
   /** \brief count of outgoing LpPackets that were marked with congestion marks
    */
   PacketCounter nCongestionMarked;
@@ -89,8 +94,8 @@ public:
 /** \brief GenericLinkService is a LinkService that implements the NDNLPv2 protocol
  *  \sa https://redmine.named-data.net/projects/nfd/wiki/NDNLPv2
  */
-class GenericLinkService : public LinkService
-                         , protected virtual GenericLinkServiceCounters
+class GenericLinkService FINAL_UNLESS_WITH_TESTS : public LinkService
+                                                 , protected virtual GenericLinkServiceCounters
 {
 public:
   /** \brief Options that control the behavior of GenericLinkService
@@ -98,7 +103,6 @@ public:
   class Options
   {
   public:
-    constexpr
     Options() noexcept
     {
     }
@@ -133,12 +137,16 @@ public:
     bool allowCongestionMarking = false;
 
     /** \brief starting value for congestion marking interval
+     *
+     *  Packets are marked if the queue size stays above THRESHOLD for at least one INTERVAL.
      *
      *  The default value (100 ms) is taken from RFC 8289 (CoDel).
      */
     time::nanoseconds baseCongestionMarkingInterval = 100_ms;
 
     /** \brief default congestion threshold in bytes
+     *
+     *  Packets are marked if the queue size stays above THRESHOLD for at least one INTERVAL.
      *
      *  The default value (64 KiB) works well for a queue capacity of 200 KiB.
      */
@@ -146,7 +154,20 @@ public:
 
     /** \brief enables self-learning forwarding support
      */
-    bool allowSelfLearning = false;
+    bool allowSelfLearning = true;
+
+    /** \brief overrides MTU provided by Transport
+     *
+     *  This MTU value will be used instead of the MTU provided by the transport if it is less than
+     *  the transport MTU. However, it will not be utilized when the transport MTU is unlimited.
+     *
+     *  Acceptable values for the override MTU are values >= MIN_MTU, which can be validated before
+     *  being set with canOverrideMtuTo().
+     */
+    ssize_t overrideMtu = std::numeric_limits<ssize_t>::max();
+    
+    uint64_t C = 100000000; // 100Mbps
+    size_t vqSize = 20;
   };
 
   /** \brief counters provided by GenericLinkService
@@ -167,7 +188,17 @@ public:
   setOptions(const Options& options);
 
   const Counters&
-  getCounters() const override;
+  getCounters() const OVERRIDE_WITH_TESTS_ELSE_FINAL;
+
+  ssize_t
+  getEffectiveMtu() const OVERRIDE_WITH_TESTS_ELSE_FINAL;
+
+  /** \brief Whether MTU can be overridden to the specified value
+   *
+   *  If the transport MTU is unlimited, then this will always return false.
+   */
+  bool
+  canOverrideMtuTo(ssize_t mtu) const;
 
 PROTECTED_WITH_TESTS_ELSE_PRIVATE: // send path
   /** \brief request an IDLE packet to transmit pending service fields
@@ -175,26 +206,24 @@ PROTECTED_WITH_TESTS_ELSE_PRIVATE: // send path
   void
   requestIdlePacket();
 
-  /** \brief send an LpPacket fragment
-   *  \param pkt LpPacket to send
+  /** \brief send an LpPacket
    */
   void
   sendLpPacket(lp::Packet&& pkt);
 
-  /** \brief send Interest
-   */
   void
-  doSendInterest(const Interest& interest) override;
+  doSendInterest(const Interest& interest) OVERRIDE_WITH_TESTS_ELSE_FINAL;
 
-  /** \brief send Data
-   */
   void
-  doSendData(const Data& data) override;
+  doSendData(const Data& data) OVERRIDE_WITH_TESTS_ELSE_FINAL;
 
-  /** \brief send Nack
+  void
+  doSendNack(const ndn::lp::Nack& nack) OVERRIDE_WITH_TESTS_ELSE_FINAL;
+
+  /** \brief assign consecutive sequence numbers to LpPackets
    */
   void
-  doSendNack(const ndn::lp::Nack& nack) override;
+  assignSequences(std::vector<lp::Packet>& pkts);
 
 private: // send path
   /** \brief encode link protocol fields from tags onto an outgoing LpPacket
@@ -211,16 +240,6 @@ private: // send path
   void
   sendNetPacket(lp::Packet&& pkt, bool isInterest);
 
-  /** \brief assign a sequence number to an LpPacket
-   */
-  void
-  assignSequence(lp::Packet& pkt);
-
-  /** \brief assign consecutive sequence numbers to LpPackets
-   */
-  void
-  assignSequences(std::vector<lp::Packet>& pkts);
-
   /** \brief if the send queue is found to be congested, add a congestion mark to the packet
    *         according to CoDel
    *  \sa https://tools.ietf.org/html/rfc8289
@@ -229,24 +248,24 @@ private: // send path
   checkCongestionLevel(lp::Packet& pkt);
 
 private: // receive path
-  /** \brief receive Packet from Transport
-   */
   void
-  doReceivePacket(Transport::Packet&& packet) override;
+  doReceivePacket(const Block& packet, const EndpointId& endpoint) OVERRIDE_WITH_TESTS_ELSE_FINAL;
 
   /** \brief decode incoming network-layer packet
    *  \param netPkt reassembled network-layer packet
    *  \param firstPkt LpPacket of first fragment
+   *  \param endpointId endpoint of peer who sent the packet
    *
    *  If decoding is successful, a receive signal is emitted;
    *  otherwise, a warning is logged.
    */
   void
-  decodeNetPacket(const Block& netPkt, const lp::Packet& firstPkt);
+  decodeNetPacket(const Block& netPkt, const lp::Packet& firstPkt, const EndpointId& endpointId);
 
   /** \brief decode incoming Interest
    *  \param netPkt reassembled network-layer packet; TLV-TYPE must be Interest
    *  \param firstPkt LpPacket of first fragment; must not have Nack field
+   *  \param endpointId endpoint of peer who sent the Interest
    *
    *  If decoding is successful, receiveInterest signal is emitted;
    *  otherwise, a warning is logged.
@@ -254,11 +273,12 @@ private: // receive path
    *  \throw tlv::Error parse error in an LpHeader field
    */
   void
-  decodeInterest(const Block& netPkt, const lp::Packet& firstPkt);
+  decodeInterest(const Block& netPkt, const lp::Packet& firstPkt, const EndpointId& endpointId);
 
   /** \brief decode incoming Interest
    *  \param netPkt reassembled network-layer packet; TLV-TYPE must be Data
    *  \param firstPkt LpPacket of first fragment
+   *  \param endpointId endpoint of peer who sent the Data
    *
    *  If decoding is successful, receiveData signal is emitted;
    *  otherwise, a warning is logged.
@@ -266,11 +286,12 @@ private: // receive path
    *  \throw tlv::Error parse error in an LpHeader field
    */
   void
-  decodeData(const Block& netPkt, const lp::Packet& firstPkt);
+  decodeData(const Block& netPkt, const lp::Packet& firstPkt, const EndpointId& endpointId);
 
   /** \brief decode incoming Interest
    *  \param netPkt reassembled network-layer packet; TLV-TYPE must be Interest
    *  \param firstPkt LpPacket of first fragment; must have Nack field
+   *  \param endpointId endpoint of peer who sent the Nack
    *
    *  If decoding is successful, receiveNack signal is emitted;
    *  otherwise, a warning is logged.
@@ -278,7 +299,7 @@ private: // receive path
    *  \throw tlv::Error parse error in an LpHeader field
    */
   void
-  decodeNack(const Block& netPkt, const lp::Packet& firstPkt);
+  decodeNack(const Block& netPkt, const lp::Packet& firstPkt, const EndpointId& endpointId);
 
 PROTECTED_WITH_TESTS_ELSE_PRIVATE:
   Options m_options;
@@ -288,16 +309,14 @@ PROTECTED_WITH_TESTS_ELSE_PRIVATE:
   lp::Sequence m_lastSeqNo;
 
 PUBLIC_WITH_TESTS_ELSE_PRIVATE:
-  /// CongestionMark TLV-TYPE (3 octets) + CongestionMark TLV-LENGTH (1 octet) + sizeof(uint64_t)
-  static constexpr size_t CONGESTION_MARK_SIZE = 3 + 1 + sizeof(uint64_t);
-
   /// Time to mark next packet due to send queue congestion
   time::steady_clock::TimePoint m_nextMarkTime;
-  /// Time last packet was marked
-  time::steady_clock::TimePoint m_lastMarkTime;
   /// number of marked packets in the current incident of congestion
   size_t m_nMarkedSinceInMarkingState;
 
+  GlobalSP globalSp;
+  bool canScheduler = true;
+  std::function<void(std::shared_ptr<VirtualQueueItem>)> sendPacketCallback;
   friend class LpReliability;
 };
 

daemon/face/internal-face.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2015,  Regents of the University of California,
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,7 +26,7 @@
 #include "internal-face.hpp"
 #include "generic-link-service.hpp"
 #include "internal-transport.hpp"
-#include "core/global-io.hpp"
+#include "common/global.hpp"
 
 namespace nfd {
 namespace face {

daemon/face/internal-transport.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,7 +24,7 @@
  */
 
 #include "internal-transport.hpp"
-#include "core/global-io.hpp"
+#include "common/global.hpp"
 
 namespace nfd {
 namespace face {
@@ -42,25 +42,25 @@ InternalForwarderTransport::InternalForwarderTransport(const FaceUri& localUri,
   this->setLinkType(linkType);
   this->setMtu(MTU_UNLIMITED);
 
-  NFD_LOG_FACE_INFO("Creating transport");
+  NFD_LOG_FACE_DEBUG("Creating transport");
 }
 
 void
-InternalForwarderTransport::receiveFromLink(const Block& packet)
+InternalForwarderTransport::receivePacket(const Block& packet)
 {
-  NFD_LOG_FACE_TRACE(__func__);
-
-  Packet p;
-  p.packet = packet;
-  this->receive(std::move(p));
+  getGlobalIoService().post([this, packet] {
+    NFD_LOG_FACE_TRACE("Received: " << packet.size() << " bytes");
+    receive(packet);
+  });
 }
 
 void
-InternalForwarderTransport::doSend(Packet&& packet)
+InternalForwarderTransport::doSend(const Block& packet)
 {
-  NFD_LOG_FACE_TRACE(__func__);
+  NFD_LOG_FACE_TRACE("Sending to " << m_peer);
 
-  this->emitSignal(afterSend, packet.packet);
+  if (m_peer)
+    m_peer->receivePacket(packet);
 }
 
 void
@@ -68,50 +68,59 @@ InternalForwarderTransport::doClose()
 {
   NFD_LOG_FACE_TRACE(__func__);
 
-  this->setState(TransportState::CLOSED);
+  setState(TransportState::CLOSED);
 }
 
-static void
-asyncReceive(InternalTransportBase* recipient, const Block& packet)
+InternalClientTransport::~InternalClientTransport()
 {
-  getGlobalIoService().post([packet, recipient] {
-    recipient->receiveFromLink(packet);
-  });
+  if (m_forwarder != nullptr) {
+    m_forwarder->setPeer(nullptr);
+  }
 }
 
 void
-InternalClientTransport::connectToForwarder(InternalForwarderTransport* forwarderTransport)
+InternalClientTransport::connectToForwarder(InternalForwarderTransport* forwarder)
 {
-  NFD_LOG_DEBUG(__func__ << " " << forwarderTransport);
+  NFD_LOG_DEBUG(__func__ << " " << forwarder);
 
-  m_fwToClientTransmitConn.disconnect();
-  m_clientToFwTransmitConn.disconnect();
-  m_fwTransportStateConn.disconnect();
+  if (m_forwarder != nullptr) {
+    // disconnect from the old forwarder transport
+    m_forwarder->setPeer(nullptr);
+    m_fwTransportStateConn.disconnect();
+  }
 
-  if (forwarderTransport != nullptr) {
-    m_fwToClientTransmitConn = forwarderTransport->afterSend.connect(bind(&asyncReceive, this, _1));
-    m_clientToFwTransmitConn = this->afterSend.connect(bind(&asyncReceive, forwarderTransport, _1));
-    m_fwTransportStateConn = forwarderTransport->afterStateChange.connect(
+  m_forwarder = forwarder;
+
+  if (m_forwarder != nullptr) {
+    // connect to the new forwarder transport
+    m_forwarder->setPeer(this);
+    m_fwTransportStateConn = m_forwarder->afterStateChange.connect(
       [this] (TransportState oldState, TransportState newState) {
         if (newState == TransportState::CLOSED) {
-          this->connectToForwarder(nullptr);
+          connectToForwarder(nullptr);
         }
       });
   }
 }
 
 void
-InternalClientTransport::receiveFromLink(const Block& packet)
+InternalClientTransport::receivePacket(const Block& packet)
 {
-  if (m_receiveCallback) {
-    m_receiveCallback(packet);
-  }
+  getGlobalIoService().post([this, packet] {
+    NFD_LOG_TRACE("Received: " << packet.size() << " bytes");
+    if (m_receiveCallback) {
+      m_receiveCallback(packet);
+    }
+  });
 }
 
 void
 InternalClientTransport::send(const Block& wire)
 {
-  this->emitSignal(afterSend, wire);
+  NFD_LOG_TRACE("Sending to " << m_forwarder);
+
+  if (m_forwarder)
+    m_forwarder->receivePacket(wire);
 }
 
 void
@@ -121,7 +130,7 @@ InternalClientTransport::send(const Block& header, const Block& payload)
   encoder.appendByteArray(header.wire(), header.size());
   encoder.appendByteArray(payload.wire(), payload.size());
 
-  this->send(encoder.block());
+  send(encoder.block());
 }
 
 } // namespace face

daemon/face/internal-transport.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -33,7 +33,7 @@
 namespace nfd {
 namespace face {
 
-/** \brief abstracts a transport that can be paired with another
+/** \brief Abstracts a transport that can be paired with another.
  */
 class InternalTransportBase
 {
@@ -41,49 +41,53 @@ public:
   virtual
   ~InternalTransportBase() = default;
 
-  /** \brief causes the transport to receive a link-layer packet
-   */
   virtual void
-  receiveFromLink(const Block& packet) = 0;
-
-  signal::Signal<InternalTransportBase, Block> afterSend;
-
-protected:
-  DECLARE_SIGNAL_EMIT(afterSend)
+  receivePacket(const Block& packet) = 0;
 };
 
-/** \brief implements a forwarder-side transport that can be paired with another
+/** \brief Implements a forwarder-side transport that can be paired with another transport.
  */
-class InternalForwarderTransport : public Transport, public InternalTransportBase
+class InternalForwarderTransport final : public Transport, public InternalTransportBase
 {
 public:
+  explicit
   InternalForwarderTransport(const FaceUri& localUri = FaceUri("internal://"),
                              const FaceUri& remoteUri = FaceUri("internal://"),
                              ndn::nfd::FaceScope scope = ndn::nfd::FACE_SCOPE_LOCAL,
                              ndn::nfd::LinkType linkType = ndn::nfd::LINK_TYPE_POINT_TO_POINT);
 
   void
-  receiveFromLink(const Block& packet) override;
+  setPeer(InternalTransportBase* peer)
+  {
+    m_peer = peer;
+  }
+
+  void
+  receivePacket(const Block& packet) final;
 
 protected:
   void
-  doClose() override;
+  doClose() final;
 
 private:
   void
-  doSend(Packet&& packet) override;
+  doSend(const Block& packet) final;
 
 private:
   NFD_LOG_MEMBER_DECL();
+
+  InternalTransportBase* m_peer = nullptr;
 };
 
-/** \brief implements a client-side transport that can be paired with another
+/** \brief Implements a client-side transport that can be paired with an InternalForwarderTransport.
  */
-class InternalClientTransport : public ndn::Transport, public InternalTransportBase
+class InternalClientTransport final : public ndn::Transport, public InternalTransportBase
 {
 public:
-  /** \brief connect to a forwarder-side transport
-   *  \param forwarderTransport the forwarder-side transport to connect to; may be nullptr
+  ~InternalClientTransport() final;
+
+  /** \brief Connect to a forwarder-side transport.
+   *  \param forwarder the forwarder-side transport to connect to; may be nullptr
    *
    *  The connected forwarder-side transport will be disconnected automatically if this method
    *  is called again, or if that transport is closed.
@@ -91,37 +95,36 @@ public:
    *  all sent packets would be lost, and nothing would be received.
    */
   void
-  connectToForwarder(InternalForwarderTransport* forwarderTransport);
+  connectToForwarder(InternalForwarderTransport* forwarder);
 
   void
-  receiveFromLink(const Block& packet) override;
+  receivePacket(const Block& packet) final;
 
   void
-  close() override
+  send(const Block& wire) final;
+
+  void
+  send(const Block& header, const Block& payload) final;
+
+  void
+  close() final
   {
   }
 
   void
-  pause() override
+  pause() final
   {
   }
 
   void
-  resume() override
+  resume() final
   {
   }
 
-  void
-  send(const Block& wire) override;
-
-  void
-  send(const Block& header, const Block& payload) override;
-
 private:
   NFD_LOG_MEMBER_DECL();
 
-  signal::ScopedConnection m_fwToClientTransmitConn;
-  signal::ScopedConnection m_clientToFwTransmitConn;
+  InternalForwarderTransport* m_forwarder = nullptr;
   signal::ScopedConnection m_fwTransportStateConn;
 };
 

daemon/face/link-service.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -85,39 +85,39 @@ LinkService::sendNack(const ndn::lp::Nack& nack)
 }
 
 void
-LinkService::receiveInterest(const Interest& interest)
+LinkService::receiveInterest(const Interest& interest, const EndpointId& endpoint)
 {
   NFD_LOG_FACE_TRACE(__func__);
 
   ++this->nInInterests;
 
-  afterReceiveInterest(interest);
+  afterReceiveInterest(interest, endpoint);
 }
 
 void
-LinkService::receiveData(const Data& data)
+LinkService::receiveData(const Data& data, const EndpointId& endpoint)
 {
   NFD_LOG_FACE_TRACE(__func__);
 
   ++this->nInData;
 
-  afterReceiveData(data);
+  afterReceiveData(data, endpoint);
 }
 
 void
-LinkService::receiveNack(const ndn::lp::Nack& nack)
+LinkService::receiveNack(const ndn::lp::Nack& nack, const EndpointId& endpoint)
 {
   NFD_LOG_FACE_TRACE(__func__);
 
   ++this->nInNacks;
 
-  afterReceiveNack(nack);
+  afterReceiveNack(nack, endpoint);
 }
 
 void
 LinkService::notifyDroppedInterest(const Interest& interest)
 {
-  ++this->nDroppedInterests;
+  ++this->nInterestsExceededRetx;
   onDroppedInterest(interest);
 }
 

daemon/face/link-service.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2017,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,15 +26,13 @@
 #ifndef NFD_DAEMON_FACE_LINK_SERVICE_HPP
 #define NFD_DAEMON_FACE_LINK_SERVICE_HPP
 
-#include "core/counter.hpp"
-#include "face-log.hpp"
+#include "face-common.hpp"
 #include "transport.hpp"
+#include "common/counter.hpp"
 
 namespace nfd {
 namespace face {
 
-class Face;
-
 /** \brief counters provided by LinkService
  *  \note The type name 'LinkServiceCounters' is implementation detail.
  *        Use 'LinkService::Counters' in public API.
@@ -52,7 +50,7 @@ public:
 
   /** \brief count of Interests dropped by reliability system for exceeding allowed number of retx
    */
-  PacketCounter nDroppedInterests;
+  PacketCounter nInterestsExceededRetx;
 
   /** \brief count of incoming Data packets
    */
@@ -111,20 +109,23 @@ public:
   virtual const Counters&
   getCounters() const;
 
+  virtual ssize_t
+  getEffectiveMtu() const;
+
 public: // upper interface to be used by forwarding
-  /** \brief send Interest
+  /** \brief Send Interest
    *  \pre setTransport has been called
    */
   void
   sendInterest(const Interest& interest);
 
-  /** \brief send Data
+  /** \brief Send Data
    *  \pre setTransport has been called
    */
   void
   sendData(const Data& data);
 
-  /** \brief send Nack
+  /** \brief Send Nack
    *  \pre setTransport has been called
    */
   void
@@ -132,15 +133,15 @@ public: // upper interface to be used by forwarding
 
   /** \brief signals on Interest received
    */
-  signal::Signal<LinkService, Interest> afterReceiveInterest;
+  signal::Signal<LinkService, Interest, EndpointId> afterReceiveInterest;
 
   /** \brief signals on Data received
    */
-  signal::Signal<LinkService, Data> afterReceiveData;
+  signal::Signal<LinkService, Data, EndpointId> afterReceiveData;
 
   /** \brief signals on Nack received
    */
-  signal::Signal<LinkService, lp::Nack> afterReceiveNack;
+  signal::Signal<LinkService, lp::Nack, EndpointId> afterReceiveNack;
 
   /** \brief signals on Interest dropped by reliability system for exceeding allowed number of retx
    */
@@ -150,29 +151,29 @@ public: // lower interface to be invoked by Transport
   /** \brief performs LinkService specific operations to receive a lower-layer packet
    */
   void
-  receivePacket(Transport::Packet&& packet);
+  receivePacket(const Block& packet, const EndpointId& endpoint);
 
 protected: // upper interface to be invoked in subclass (receive path termination)
   /** \brief delivers received Interest to forwarding
    */
   void
-  receiveInterest(const Interest& interest);
+  receiveInterest(const Interest& interest, const EndpointId& endpoint);
 
   /** \brief delivers received Data to forwarding
    */
   void
-  receiveData(const Data& data);
+  receiveData(const Data& data, const EndpointId& endpoint);
 
   /** \brief delivers received Nack to forwarding
    */
   void
-  receiveNack(const lp::Nack& nack);
+  receiveNack(const lp::Nack& nack, const EndpointId& endpoint);
 
 protected: // lower interface to be invoked in subclass (send path termination)
-  /** \brief sends a lower-layer packet via Transport
+  /** \brief send a lower-layer packet via Transport
    */
   void
-  sendPacket(Transport::Packet&& packet);
+  sendPacket(const Block& packet);
 
 protected:
   void
@@ -196,7 +197,7 @@ private: // upper interface to be overridden in subclass (send path entrypoint)
 
 private: // lower interface to be overridden in subclass
   virtual void
-  doReceivePacket(Transport::Packet&& packet) = 0;
+  doReceivePacket(const Block& packet, const EndpointId& endpoint) = 0;
 
 private:
   Face* m_face;
@@ -227,16 +228,22 @@ LinkService::getCounters() const
   return *this;
 }
 
-inline void
-LinkService::receivePacket(Transport::Packet&& packet)
+inline ssize_t
+LinkService::getEffectiveMtu() const
 {
-  doReceivePacket(std::move(packet));
+  return m_transport->getMtu();
 }
 
 inline void
-LinkService::sendPacket(Transport::Packet&& packet)
+LinkService::receivePacket(const Block& packet, const EndpointId& endpoint)
 {
-  m_transport->send(std::move(packet));
+  doReceivePacket(packet, endpoint);
+}
+
+inline void
+LinkService::sendPacket(const Block& packet)
+{
+  m_transport->send(packet);
 }
 
 std::ostream&

daemon/face/lp-fragmenter.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,16 +26,13 @@
 #ifndef NFD_DAEMON_FACE_LP_FRAGMENTER_HPP
 #define NFD_DAEMON_FACE_LP_FRAGMENTER_HPP
 
-#include "core/common.hpp"
-#include "face-log.hpp"
+#include "face-common.hpp"
 
 #include <ndn-cxx/lp/packet.hpp>
 
 namespace nfd {
 namespace face {
 
-class LinkService;
-
 /** \brief fragments network-layer packets into NDNLPv2 link-layer packets
  *  \sa https://redmine.named-data.net/projects/nfd/wiki/NDNLPv2
  */

daemon/face/lp-reassembler.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -25,6 +25,7 @@
 
 #include "lp-reassembler.hpp"
 #include "link-service.hpp"
+#include "common/global.hpp"
 
 #include <numeric>
 
@@ -40,7 +41,7 @@ LpReassembler::LpReassembler(const LpReassembler::Options& options, const LinkSe
 }
 
 std::tuple<bool, Block, lp::Packet>
-LpReassembler::receiveFragment(Transport::EndpointId remoteEndpoint, const lp::Packet& packet)
+LpReassembler::receiveFragment(EndpointId remoteEndpoint, const lp::Packet& packet)
 {
   BOOST_ASSERT(packet.has<lp::FragmentField>());
 
@@ -113,7 +114,7 @@ LpReassembler::receiveFragment(Transport::EndpointId remoteEndpoint, const lp::P
   }
 
   // set drop timer
-  pp.dropTimer = scheduler::schedule(m_options.reassemblyTimeout, [=] { timeoutPartialPacket(key); });
+  pp.dropTimer = getScheduler().schedule(m_options.reassemblyTimeout, [=] { timeoutPartialPacket(key); });
 
   return FALSE_RETURN;
 }

daemon/face/lp-reassembler.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,17 +26,13 @@
 #ifndef NFD_DAEMON_FACE_LP_REASSEMBLER_HPP
 #define NFD_DAEMON_FACE_LP_REASSEMBLER_HPP
 
-#include "core/scheduler.hpp"
-#include "face-log.hpp"
-#include "transport.hpp"
+#include "face-common.hpp"
 
 #include <ndn-cxx/lp/packet.hpp>
 
 namespace nfd {
 namespace face {
 
-class LinkService;
-
 /** \brief reassembles fragmented network-layer packets
  *  \sa https://redmine.named-data.net/projects/nfd/wiki/NDNLPv2
  */
@@ -73,17 +69,17 @@ public:
   const LinkService*
   getLinkService() const;
 
-  /** \brief adds received fragment to buffer
-   *  \param remoteEndpoint endpoint whose sends the packet
-   *  \param packet received fragment;
-   *                must have Fragment field
-   *  \return whether network-layer packet has been completely received,
+  /** \brief adds received fragment to the buffer
+   *  \param remoteEndpoint endpoint that sent the packet
+   *  \param packet received fragment; must have Fragment field
+   *  \return a tuple containing:
+   *          whether a network-layer packet has been completely received,
    *          the reassembled network-layer packet,
-   *          and the first fragment for inspecting other NDNLPv2 headers
+   *          the first fragment for inspecting other NDNLPv2 headers
    *  \throw tlv::Error packet is malformed
    */
   std::tuple<bool, Block, lp::Packet>
-  receiveFragment(Transport::EndpointId remoteEndpoint, const lp::Packet& packet);
+  receiveFragment(EndpointId remoteEndpoint, const lp::Packet& packet);
 
   /** \brief count of partial packets
    */
@@ -97,7 +93,7 @@ public:
    *  Before it's erased, this signal is emitted with the remote endpoint,
    *  and the number of fragments being dropped.
    */
-  signal::Signal<LpReassembler, Transport::EndpointId, size_t> beforeTimeout;
+  signal::Signal<LpReassembler, EndpointId, size_t> beforeTimeout;
 
 private:
   /** \brief holds all fragments of packet until reassembled
@@ -113,7 +109,7 @@ private:
   /** \brief index key for PartialPackets
    */
   typedef std::tuple<
-    Transport::EndpointId, // remoteEndpoint
+    EndpointId, // remoteEndpoint
     lp::Sequence // message identifier (sequence of the first fragment)
   > Key;
 
@@ -125,8 +121,8 @@ private:
 
 private:
   Options m_options;
-  std::map<Key, PartialPacket> m_partialPackets;
   const LinkService* m_linkService;
+  std::map<Key, PartialPacket> m_partialPackets;
 };
 
 std::ostream&

daemon/face/lp-reliability.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,19 +26,20 @@
 #include "lp-reliability.hpp"
 #include "generic-link-service.hpp"
 #include "transport.hpp"
+#include "common/global.hpp"
 
 namespace nfd {
 namespace face {
 
+NFD_LOG_INIT(LpReliability);
+
 LpReliability::LpReliability(const LpReliability::Options& options, GenericLinkService* linkService)
   : m_options(options)
   , m_linkService(linkService)
   , m_firstUnackedFrag(m_unackedFrags.begin())
   , m_lastTxSeqNo(-1) // set to "-1" to start TxSequence numbers at 0
-  , m_isIdleAckTimerRunning(false)
 {
   BOOST_ASSERT(m_linkService != nullptr);
-
   BOOST_ASSERT(m_options.idleAckTimerPeriod > 0_ns);
 }
 
@@ -48,7 +49,7 @@ LpReliability::setOptions(const Options& options)
   BOOST_ASSERT(options.idleAckTimerPeriod > 0_ns);
 
   if (m_options.isEnabled && !options.isEnabled) {
-    this->stopIdleAckTimer();
+    m_idleAckTimer.cancel();
   }
 
   m_options = options;
@@ -72,6 +73,9 @@ LpReliability::handleOutgoing(std::vector<lp::Packet>& frags, lp::Packet&& pkt,
   netPkt->unackedFrags.reserve(frags.size());
 
   for (lp::Packet& frag : frags) {
+    // Non-IDLE packets are required to have assigned Sequence numbers with LpReliability enabled
+    BOOST_ASSERT(frag.has<lp::SequenceField>());
+
     // Assign TxSequence number
     lp::Sequence txSeq = assignTxSequence(frag);
 
@@ -81,7 +85,13 @@ LpReliability::handleOutgoing(std::vector<lp::Packet>& frags, lp::Packet&& pkt,
                                                  std::forward_as_tuple(txSeq),
                                                  std::forward_as_tuple(frag));
     unackedFragsIt->second.sendTime = sendTime;
-    unackedFragsIt->second.rtoTimer = scheduler::schedule(m_rto.computeRto(), [=] { onLpPacketLost(txSeq); });
+    auto rto = m_rttEst.getEstimatedRto();
+    lp::Sequence seq = frag.get<lp::SequenceField>();
+    NFD_LOG_FACE_TRACE("transmitting seq=" << seq << ", txseq=" << txSeq << ", rto=" <<
+                       time::duration_cast<time::milliseconds>(rto).count() << "ms");
+    unackedFragsIt->second.rtoTimer = getScheduler().schedule(rto, [=] {
+      onLpPacketLost(txSeq, true);
+    });
     unackedFragsIt->second.netPkt = netPkt;
 
     if (m_unackedFrags.size() == 1) {
@@ -93,18 +103,20 @@ LpReliability::handleOutgoing(std::vector<lp::Packet>& frags, lp::Packet&& pkt,
   }
 }
 
-void
+bool
 LpReliability::processIncomingPacket(const lp::Packet& pkt)
 {
   BOOST_ASSERT(m_options.isEnabled);
 
+  bool isDuplicate = false;
   auto now = time::steady_clock::now();
 
   // Extract and parse Acks
-  for (lp::Sequence ackSeq : pkt.list<lp::AckField>()) {
-    auto fragIt = m_unackedFrags.find(ackSeq);
+  for (lp::Sequence ackTxSeq : pkt.list<lp::AckField>()) {
+    auto fragIt = m_unackedFrags.find(ackTxSeq);
     if (fragIt == m_unackedFrags.end()) {
       // Ignore an Ack for an unknown TxSequence number
+      NFD_LOG_FACE_DEBUG("received ack for unknown txseq=" << ackTxSeq);
       continue;
     }
     auto& frag = fragIt->second;
@@ -113,12 +125,19 @@ LpReliability::processIncomingPacket(const lp::Packet& pkt)
     frag.rtoTimer.cancel();
 
     if (frag.retxCount == 0) {
-      // This sequence had no retransmissions, so use it to calculate the RTO
-      m_rto.addMeasurement(time::duration_cast<RttEstimator::Duration>(now - frag.sendTime));
+      NFD_LOG_FACE_TRACE("received ack for seq=" << frag.pkt.get<lp::SequenceField>() << ", txseq=" <<
+                         ackTxSeq << ", retx=0, rtt=" <<
+                         time::duration_cast<time::milliseconds>(now - frag.sendTime).count() << "ms");
+      // This sequence had no retransmissions, so use it to estimate the RTO
+      m_rttEst.addMeasurement(now - frag.sendTime);
+    }
+    else {
+      NFD_LOG_FACE_TRACE("received ack for seq=" << frag.pkt.get<lp::SequenceField>() << ", txseq=" <<
+                         ackTxSeq << ", retx=" << frag.retxCount);
     }
 
-    // Look for frags with TxSequence numbers < ackSeq (allowing for wraparound) and consider them
-    // lost if a configurable number of Acks containing greater TxSequence numbers have been
+    // Look for frags with TxSequence numbers < ackTxSeq (allowing for wraparound) and consider
+    // them lost if a configurable number of Acks containing greater TxSequence numbers have been
     // received.
     auto lostLpPackets = findLostLpPackets(fragIt);
 
@@ -135,8 +154,8 @@ LpReliability::processIncomingPacket(const lp::Packet& pkt)
     // Resend or fail fragments considered lost. Potentially increment the start of the window.
     for (lp::Sequence txSeq : lostLpPackets) {
       if (removedLpPackets.find(txSeq) == removedLpPackets.end()) {
-        auto removedThisTxSeq = this->onLpPacketLost(txSeq);
-        for (auto removedTxSeq : removedThisTxSeq) {
+        auto removedTxSeqs = onLpPacketLost(txSeq, false);
+        for (auto removedTxSeq : removedTxSeqs) {
           removedLpPackets.insert(removedTxSeq);
         }
       }
@@ -145,11 +164,29 @@ LpReliability::processIncomingPacket(const lp::Packet& pkt)
 
   // If packet has Fragment and TxSequence fields, extract TxSequence and add to AckQueue
   if (pkt.has<lp::FragmentField>() && pkt.has<lp::TxSequenceField>()) {
+    NFD_LOG_FACE_TRACE("queueing ack for remote txseq=" << pkt.get<lp::TxSequenceField>());
     m_ackQueue.push(pkt.get<lp::TxSequenceField>());
-    if (!m_isIdleAckTimerRunning) {
-      this->startIdleAckTimer();
+
+    // Check for received frames with duplicate Sequences
+    if (pkt.has<lp::SequenceField>()) {
+      lp::Sequence pktSequence = pkt.get<lp::SequenceField>();
+      isDuplicate = m_recentRecvSeqs.count(pktSequence) > 0;
+      // Check for recent received Sequences to remove
+      auto now = time::steady_clock::now();
+      auto rto = m_rttEst.getEstimatedRto();
+      while (m_recentRecvSeqsQueue.size() > 0 &&
+             now > m_recentRecvSeqs[m_recentRecvSeqsQueue.front()] + rto) {
+        m_recentRecvSeqs.erase(m_recentRecvSeqsQueue.front());
+        m_recentRecvSeqsQueue.pop();
+      }
+      m_recentRecvSeqs.emplace(pktSequence, now);
+      m_recentRecvSeqsQueue.push(pktSequence);
     }
+
+    startIdleAckTimer();
   }
+
+  return !isDuplicate;
 }
 
 void
@@ -166,8 +203,8 @@ LpReliability::piggyback(lp::Packet& pkt, ssize_t mtu)
   remainingSpace -= pktSize;
 
   while (!m_ackQueue.empty()) {
-    lp::Sequence ackSeq = m_ackQueue.front();
-    // Ack size = Ack TLV-TYPE (3 octets) + TLV-LENGTH (1 octet) + uint64_t (8 octets)
+    lp::Sequence ackTxSeq = m_ackQueue.front();
+    // Ack size = Ack TLV-TYPE (3 octets) + TLV-LENGTH (1 octet) + lp::Sequence (8 octets)
     const ssize_t ackSize = tlv::sizeOfVarNumber(lp::tlv::Ack) +
                             tlv::sizeOfVarNumber(sizeof(lp::Sequence)) +
                             sizeof(lp::Sequence);
@@ -176,7 +213,9 @@ LpReliability::piggyback(lp::Packet& pkt, ssize_t mtu)
       break;
     }
 
-    pkt.add<lp::AckField>(ackSeq);
+    NFD_LOG_FACE_TRACE("piggybacking ack for remote txseq=" << ackTxSeq);
+
+    pkt.add<lp::AckField>(ackTxSeq);
     m_ackQueue.pop();
     remainingSpace -= ackSize;
   }
@@ -188,7 +227,7 @@ LpReliability::assignTxSequence(lp::Packet& frag)
   lp::Sequence txSeq = ++m_lastTxSeqNo;
   frag.set<lp::TxSequenceField>(txSeq);
   if (m_unackedFrags.size() > 0 && m_lastTxSeqNo == m_firstUnackedFrag->first) {
-    BOOST_THROW_EXCEPTION(std::length_error("TxSequence range exceeded"));
+    NDN_THROW(std::length_error("TxSequence range exceeded"));
   }
   return m_lastTxSeqNo;
 }
@@ -196,25 +235,18 @@ LpReliability::assignTxSequence(lp::Packet& frag)
 void
 LpReliability::startIdleAckTimer()
 {
-  BOOST_ASSERT(!m_isIdleAckTimerRunning);
-  m_isIdleAckTimerRunning = true;
+  if (m_idleAckTimer) {
+    // timer is already running, do nothing
+    return;
+  }
 
-  m_idleAckTimer = scheduler::schedule(m_options.idleAckTimerPeriod, [this] {
+  m_idleAckTimer = getScheduler().schedule(m_options.idleAckTimerPeriod, [this] {
     while (!m_ackQueue.empty()) {
       m_linkService->requestIdlePacket();
     }
-
-    m_isIdleAckTimerRunning = false;
   });
 }
 
-void
-LpReliability::stopIdleAckTimer()
-{
-  m_idleAckTimer.cancel();
-  m_isIdleAckTimerRunning = false;
-}
-
 std::vector<lp::Sequence>
 LpReliability::findLostLpPackets(LpReliability::UnackedFrags::iterator ackIt)
 {
@@ -231,6 +263,8 @@ LpReliability::findLostLpPackets(LpReliability::UnackedFrags::iterator ackIt)
 
     auto& unackedFrag = it->second;
     unackedFrag.nGreaterSeqAcks++;
+    NFD_LOG_FACE_TRACE("received ack=" << ackIt->first << " before=" << it->first <<
+                       ", before count=" << unackedFrag.nGreaterSeqAcks);
 
     if (unackedFrag.nGreaterSeqAcks >= m_options.seqNumLossThreshold) {
       lostLpPackets.push_back(it->first);
@@ -241,7 +275,7 @@ LpReliability::findLostLpPackets(LpReliability::UnackedFrags::iterator ackIt)
 }
 
 std::vector<lp::Sequence>
-LpReliability::onLpPacketLost(lp::Sequence txSeq)
+LpReliability::onLpPacketLost(lp::Sequence txSeq, bool isTimeout)
 {
   BOOST_ASSERT(m_unackedFrags.count(txSeq) > 0);
   auto txSeqIt = m_unackedFrags.find(txSeq);
@@ -250,9 +284,19 @@ LpReliability::onLpPacketLost(lp::Sequence txSeq)
   txFrag.rtoTimer.cancel();
   auto netPkt = txFrag.netPkt;
   std::vector<lp::Sequence> removedThisTxSeq;
+  lp::Sequence seq = txFrag.pkt.get<lp::SequenceField>();
+
+  if (isTimeout) {
+    NFD_LOG_FACE_TRACE("rto timer expired for seq=" << seq << ", txseq=" << txSeq);
+  }
+  else { // lost due to out-of-order TxSeqs
+    NFD_LOG_FACE_TRACE("seq=" << seq << ", txseq=" << txSeq <<
+                       " considered lost from acks for more recent txseqs");
+  }
 
   // Check if maximum number of retransmissions exceeded
   if (txFrag.retxCount >= m_options.maxRetx) {
+    NFD_LOG_FACE_DEBUG("seq=" << seq << " exceeded allowed retransmissions: DROP");
     // Delete all LpPackets of NetPkt from m_unackedFrags (except this one)
     for (size_t i = 0; i < netPkt->unackedFrags.size(); i++) {
       if (netPkt->unackedFrags[i] != txSeqIt) {
@@ -272,6 +316,7 @@ LpReliability::onLpPacketLost(lp::Sequence txSeq)
       onDroppedInterest(Interest(frag));
     }
 
+    // Delete this LpPacket from m_unackedFrags
     removedThisTxSeq.push_back(txSeqIt->first);
     deleteUnackedFrag(txSeqIt);
   }
@@ -303,8 +348,15 @@ LpReliability::onLpPacketLost(lp::Sequence txSeq)
     // Retransmit fragment
     m_linkService->sendLpPacket(lp::Packet(newTxFrag.pkt));
 
+    auto rto = m_rttEst.getEstimatedRto();
+    NFD_LOG_FACE_TRACE("retransmitting seq=" << seq << ", txseq=" << newTxSeq << ", retx=" <<
+                       txFrag.retxCount << ", rto=" <<
+                       time::duration_cast<time::milliseconds>(rto).count() << "ms");
+
     // Start RTO timer for this sequence
-    newTxFrag.rtoTimer = scheduler::schedule(m_rto.computeRto(), [=] { onLpPacketLost(newTxSeq); });
+    newTxFrag.rtoTimer = getScheduler().schedule(rto, [=] {
+      onLpPacketLost(newTxSeq, true);
+    });
   }
 
   return removedThisTxSeq;
@@ -370,5 +422,17 @@ LpReliability::NetPkt::NetPkt(lp::Packet&& pkt, bool isInterest)
 {
 }
 
+std::ostream&
+operator<<(std::ostream& os, const FaceLogHelper<LpReliability>& flh)
+{
+  if (flh.obj.getLinkService() == nullptr) {
+    os << "[id=0,local=unknown,remote=unknown] ";
+  }
+  else {
+    os << FaceLogHelper<LinkService>(*flh.obj.getLinkService());
+  }
+  return os;
+}
+
 } // namespace face
 } // namespace nfd

daemon/face/lp-reliability.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,11 +26,11 @@
 #ifndef NFD_DAEMON_FACE_LP_RELIABILITY_HPP
 #define NFD_DAEMON_FACE_LP_RELIABILITY_HPP
 
-#include "core/rtt-estimator.hpp"
-#include "core/scheduler.hpp"
+#include "face-common.hpp"
 
 #include <ndn-cxx/lp/packet.hpp>
 #include <ndn-cxx/lp/sequence.hpp>
+#include <ndn-cxx/util/rtt-estimator.hpp>
 
 #include <queue>
 
@@ -93,8 +93,9 @@ public:
 
   /** \brief extract and parse all Acks and add Ack for contained Fragment (if any) to AckQueue
    *  \param pkt incoming LpPacket
+   *  \return whether incoming LpPacket is new and not a duplicate
    */
-  void
+  bool
   processIncomingPacket(const lp::Packet& pkt);
 
   /** \brief called by GenericLinkService to attach Acks onto an outgoing LpPacket
@@ -127,11 +128,6 @@ PUBLIC_WITH_TESTS_ELSE_PRIVATE:
   void
   startIdleAckTimer();
 
-  /** \brief cancel the idle Ack timer
-   */
-  void
-  stopIdleAckTimer();
-
   /** \brief find and mark as lost fragments where a configurable number of Acks
    *         (\p m_options.seqNumLossThreshold) have been received for greater TxSequence numbers
    *  \param ackIt iterator pointing to acknowledged fragment
@@ -144,7 +140,7 @@ PUBLIC_WITH_TESTS_ELSE_PRIVATE:
    *  \return vector of the TxSequences of fragments removed due to a network packet being removed
    */
   std::vector<lp::Sequence>
-  onLpPacketLost(lp::Sequence txSeq);
+  onLpPacketLost(lp::Sequence txSeq, bool isTimeout);
 
   /** \brief remove the fragment with the given sequence number from the map of unacknowledged
    *         fragments, as well as its associated network packet (if any)
@@ -199,8 +195,10 @@ PUBLIC_WITH_TESTS_ELSE_PRIVATE:
   };
 
 public:
-  /// TxSequence TLV-TYPE (3 octets) + TxSequence TLV-LENGTH (1 octet) + sizeof(lp::Sequence)
-  static constexpr size_t RESERVED_HEADER_SPACE = 3 + 1 + sizeof(lp::Sequence);
+  /// TxSequence TLV-TYPE (3 octets) + TLV-LENGTH (1 octet) + lp::Sequence (8 octets)
+  static constexpr size_t RESERVED_HEADER_SPACE = tlv::sizeOfVarNumber(lp::tlv::TxSequence) +
+                                                  tlv::sizeOfVarNumber(sizeof(lp::Sequence)) +
+                                                  sizeof(lp::Sequence);
 
 PUBLIC_WITH_TESTS_ELSE_PRIVATE:
   Options m_options;
@@ -213,12 +211,16 @@ PUBLIC_WITH_TESTS_ELSE_PRIVATE:
    */
   UnackedFrags::iterator m_firstUnackedFrag;
   std::queue<lp::Sequence> m_ackQueue;
+  std::map<lp::Sequence, time::steady_clock::TimePoint> m_recentRecvSeqs;
+  std::queue<lp::Sequence> m_recentRecvSeqsQueue;
   lp::Sequence m_lastTxSeqNo;
   scheduler::ScopedEventId m_idleAckTimer;
-  bool m_isIdleAckTimerRunning;
-  RttEstimator m_rto;
+  ndn::util::RttEstimator m_rttEst;
 };
 
+std::ostream&
+operator<<(std::ostream& os, const FaceLogHelper<LpReliability>& flh);
+
 } // namespace face
 } // namespace nfd
 

daemon/face/multicast-ethernet-transport.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,7 +24,7 @@
  */
 
 #include "multicast-ethernet-transport.hpp"
-#include "core/global-io.hpp"
+#include "common/global.hpp"
 
 #include <cerrno>         // for errno
 #include <cstring>        // for memcpy(), strerror(), strncpy()
@@ -63,7 +63,7 @@ MulticastEthernetTransport::MulticastEthernetTransport(const ndn::net::NetworkIn
   this->setLinkType(linkType);
   this->setMtu(localEndpoint.getMtu());
 
-  NFD_LOG_FACE_INFO("Creating transport");
+  NFD_LOG_FACE_DEBUG("Creating transport");
 
   char filter[110];
   // note #1: we cannot use std::snprintf because it's not available
@@ -144,7 +144,7 @@ MulticastEthernetTransport::joinMulticastGroup()
   NFD_LOG_FACE_WARN("ioctl(SIOCADDMULTI) failed: " << std::strerror(errno));
 #endif
 
-  BOOST_THROW_EXCEPTION(Error("Failed to join multicast group"));
+  NDN_THROW(Error("Failed to join multicast group"));
 }
 
 } // namespace face

daemon/face/multicast-udp-transport.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -27,7 +27,7 @@
 #include "socket-utils.hpp"
 #include "udp-protocol.hpp"
 
-#include "core/privilege-helper.hpp"
+#include "common/privilege-helper.hpp"
 
 #include <boost/functional/hash.hpp>
 
@@ -68,7 +68,7 @@ MulticastUdpTransport::MulticastUdpTransport(const protocol::endpoint& multicast
     this->setSendQueueCapacity(sendBufferSizeOption.value());
   }
 
-  NFD_LOG_FACE_INFO("Creating transport");
+  NFD_LOG_FACE_DEBUG("Creating transport");
 }
 
 ssize_t
@@ -82,13 +82,13 @@ MulticastUdpTransport::getSendQueueLength()
 }
 
 void
-MulticastUdpTransport::doSend(Transport::Packet&& packet)
+MulticastUdpTransport::doSend(const Block& packet)
 {
   NFD_LOG_FACE_TRACE(__func__);
 
-  m_sendSocket.async_send_to(boost::asio::buffer(packet.packet), m_multicastGroup,
-                             // packet.packet is copied into the lambda to retain the underlying Buffer
-                             [this, p = packet.packet] (auto&&... args) {
+  m_sendSocket.async_send_to(boost::asio::buffer(packet), m_multicastGroup,
+                             // 'packet' is copied into the lambda to retain the underlying Buffer
+                             [this, packet] (auto&&... args) {
                                this->handleSend(std::forward<decltype(args)>(args)...);
                              });
 }
@@ -118,15 +118,16 @@ bindToDevice(int fd, const std::string& ifname)
   // receive all packets sent to the other interfaces as well.
   // This is needed only on Linux. On macOS, the boost::asio::ip::multicast::join_group
   // option is sufficient to obtain the desired behavior.
+  // We dont't set SO_BINDTODEVICE on Android because this operation requires root privilege
+  // which is not allowed on Android, it will cause "Operation not permitted" error.
 
-#ifdef __linux__
+#if defined(__linux__) && !defined(__ANDROID__)
   PrivilegeHelper::runElevated([=] {
     if (::setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, ifname.data(), ifname.size() + 1) < 0) {
-      BOOST_THROW_EXCEPTION(MulticastUdpTransport::Error("Cannot bind multicast rx socket to " +
-                                                         ifname + ": " + std::strerror(errno)));
+      NDN_THROW_ERRNO(MulticastUdpTransport::Error("Cannot bind multicast rx socket to " + ifname));
     }
   });
-#endif // __linux__
+#endif
 }
 
 void
@@ -190,7 +191,7 @@ MulticastUdpTransport::openTxSocket(protocol::socket& sock,
 }
 
 template<>
-Transport::EndpointId
+EndpointId
 DatagramTransport<boost::asio::ip::udp, Multicast>::makeEndpointId(const protocol::endpoint& ep)
 {
   if (ep.address().is_v4()) {

daemon/face/multicast-udp-transport.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -40,7 +40,7 @@ NFD_LOG_MEMBER_DECL_SPECIALIZED((DatagramTransport<boost::asio::ip::udp, Multica
 // that would cause an implicit instantiation to take place, in every translation
 // unit in which such a use occurs".
 template<>
-Transport::EndpointId
+EndpointId
 DatagramTransport<boost::asio::ip::udp, Multicast>::makeEndpointId(const protocol::endpoint& ep);
 
 /**
@@ -52,11 +52,7 @@ public:
   class Error : public std::runtime_error
   {
   public:
-    explicit
-    Error(const std::string& what)
-      : std::runtime_error(what)
-    {
-    }
+    using std::runtime_error::runtime_error;
   };
 
   /**
@@ -88,7 +84,7 @@ public:
 
 private:
   void
-  doSend(Transport::Packet&& packet) final;
+  doSend(const Block& packet) final;
 
   void
   doClose() final;

daemon/face/netdev-bound.cpp

@@ -0,0 +1,149 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
+ *                           Arizona Board of Regents,
+ *                           Colorado State University,
+ *                           University Pierre & Marie Curie, Sorbonne University,
+ *                           Washington University in St. Louis,
+ *                           Beijing Institute of Technology,
+ *                           The University of Memphis.
+ *
+ * This file is part of NFD (Named Data Networking Forwarding Daemon).
+ * See AUTHORS.md for complete list of NFD authors and contributors.
+ *
+ * NFD is free software: you can redistribute it and/or modify it under the terms
+ * of the GNU General Public License as published by the Free Software Foundation,
+ * either version 3 of the License, or (at your option) any later version.
+ *
+ * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "netdev-bound.hpp"
+#include "face-system.hpp"
+#include "common/logger.hpp"
+
+namespace nfd {
+namespace face {
+
+NFD_LOG_INIT(NetdevBound);
+
+NetdevBound::NetdevBound(const ProtocolFactoryCtorParams& params, const FaceSystem& faceSystem)
+  : m_faceSystem(faceSystem)
+  , m_addFace(params.addFace)
+  , m_netmon(params.netmon)
+{
+}
+
+void
+NetdevBound::processConfig(OptionalConfigSection configSection,
+                           FaceSystem::ConfigContext& context)
+{
+  std::vector<Rule> rules;
+  if (configSection) {
+    int ruleIndex = 0;
+    for (const auto& pair : *configSection) {
+      const std::string& key = pair.first;
+      const ConfigSection& value = pair.second;
+      if (key == "rule") {
+        rules.push_back(parseRule(ruleIndex++, value));
+      }
+      else {
+        NDN_THROW(ConfigFile::Error("Unrecognized option face_system.netdev_bound." + key));
+      }
+    }
+  }
+
+  if (context.isDryRun) {
+    return;
+  }
+
+  ///\todo #3521 this should be verified in dry-run, but PFs won't publish their *+dev schemes
+  ///            in dry-run
+  for (size_t i = 0; i < rules.size(); ++i) {
+    const Rule& rule = rules[i];
+    for (const FaceUri& remote : rule.remotes) {
+      std::string devScheme = remote.getScheme() + "+dev";
+      if (!m_faceSystem.hasFactoryForScheme(devScheme)) {
+        NDN_THROW(RuleParseError(i, "scheme '" + devScheme + "' for " +
+                                 remote.toString() + " is unavailable"));
+      }
+    }
+  }
+  NFD_LOG_DEBUG("processConfig: processed " << rules.size() << " rules");
+
+  m_rules.swap(rules);
+  std::map<Key, shared_ptr<Face>> oldFaces;
+  oldFaces.swap(m_faces);
+
+  ///\todo #3521 for each face needed under m_rules:
+  ///            if it's in oldFaces, add to m_faces and remove from oldFaces;
+  ///            otherwise, create via factory and add to m_faces
+
+  ///\todo #3521 close faces in oldFaces
+}
+
+NetdevBound::Rule
+NetdevBound::parseRule(int index, const ConfigSection& confRule) const
+{
+  Rule rule;
+
+  bool hasWhitelist = false;
+  bool hasBlacklist = false;
+  for (const auto& pair : confRule) {
+    const std::string& key = pair.first;
+    const ConfigSection& value = pair.second;
+    if (key == "remote") {
+      try {
+        rule.remotes.emplace_back(value.get_value<std::string>());
+      }
+      catch (const FaceUri::Error&) {
+        NDN_THROW_NESTED(RuleParseError(index, "invalid remote FaceUri"));
+      }
+      if (!rule.remotes.back().isCanonical()) {
+        NDN_THROW(RuleParseError(index, "remote FaceUri is not canonical"));
+      }
+    }
+    else if (key == "whitelist") {
+      if (hasWhitelist) {
+        NDN_THROW(RuleParseError(index, "duplicate whitelist"));
+      }
+      try {
+        rule.netifPredicate.parseWhitelist(value);
+      }
+      catch (const ConfigFile::Error&) {
+        NDN_THROW_NESTED(RuleParseError(index, "invalid whitelist"));
+      }
+      hasWhitelist = true;
+    }
+    else if (key == "blacklist") {
+      if (hasBlacklist) {
+        NDN_THROW(RuleParseError(index, "duplicate blacklist"));
+      }
+      try {
+        rule.netifPredicate.parseBlacklist(value);
+      }
+      catch (const ConfigFile::Error&) {
+        NDN_THROW_NESTED(RuleParseError(index, "invalid blacklist"));
+      }
+      hasBlacklist = true;
+    }
+    else {
+      NDN_THROW(RuleParseError(index, "unrecognized option " + key));
+    }
+  }
+
+  if (rule.remotes.empty()) {
+    NDN_THROW(RuleParseError(index, "remote FaceUri is missing"));
+  }
+
+  ///\todo #3521 for each remote, check that there is a factory providing scheme+dev scheme
+  return rule;
+}
+
+} // namespace face
+} // namespace nfd

daemon/face/netdev-bound.hpp

@@ -0,0 +1,88 @@
+/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
+ *                           Arizona Board of Regents,
+ *                           Colorado State University,
+ *                           University Pierre & Marie Curie, Sorbonne University,
+ *                           Washington University in St. Louis,
+ *                           Beijing Institute of Technology,
+ *                           The University of Memphis.
+ *
+ * This file is part of NFD (Named Data Networking Forwarding Daemon).
+ * See AUTHORS.md for complete list of NFD authors and contributors.
+ *
+ * NFD is free software: you can redistribute it and/or modify it under the terms
+ * of the GNU General Public License as published by the Free Software Foundation,
+ * either version 3 of the License, or (at your option) any later version.
+ *
+ * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef NFD_DAEMON_FACE_NETDEV_BOUND_HPP
+#define NFD_DAEMON_FACE_NETDEV_BOUND_HPP
+
+#include "protocol-factory.hpp"
+
+namespace nfd {
+namespace face {
+
+class FaceSystem;
+
+/** \brief manages netdev-bound faces
+ */
+class NetdevBound : noncopyable
+{
+public:
+  class RuleParseError : public ConfigFile::Error
+  {
+  public:
+    RuleParseError(int index, std::string msg)
+      : Error("Error parsing face_system.netdev_bound.rule[" + to_string(index) + "]: " + msg)
+      , index(index)
+      , msg(std::move(msg))
+    {
+    }
+
+  public:
+    int index;
+    std::string msg;
+  };
+
+  NetdevBound(const ProtocolFactoryCtorParams& params, const FaceSystem& faceSystem);
+
+  /** \brief process face_system.netdev_bound config section
+   */
+  void
+  processConfig(OptionalConfigSection configSection,
+                FaceSystem::ConfigContext& context);
+
+PUBLIC_WITH_TESTS_ELSE_PRIVATE:
+  struct Rule
+  {
+    std::vector<FaceUri> remotes;
+    NetworkInterfacePredicate netifPredicate;
+  };
+
+  Rule
+  parseRule(int index, const ConfigSection& confRule) const;
+
+PUBLIC_WITH_TESTS_ELSE_PRIVATE:
+  const FaceSystem& m_faceSystem;
+  FaceCreatedCallback m_addFace;
+  shared_ptr<ndn::net::NetworkMonitor> m_netmon;
+
+  std::vector<Rule> m_rules;
+
+  using Key = std::pair<FaceUri, std::string>;
+  std::map<Key, shared_ptr<Face>> m_faces;
+};
+
+} // namespace face
+} // namespace nfd
+
+#endif // NFD_DAEMON_FACE_NETDEV_BOUND_HPP

daemon/face/network-predicate.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,13 +24,13 @@
  */
 
 #include "network-predicate.hpp"
-
-#include "config-file.hpp"
-#include "network.hpp"
+#include "common/config-file.hpp"
+#include "core/network.hpp"
 
 #include <fnmatch.h>
 
 namespace nfd {
+namespace face {
 
 NetworkPredicateBase::NetworkPredicateBase()
 {
@@ -47,7 +47,9 @@ NetworkPredicateBase::clear()
 }
 
 void
-NetworkPredicateBase::parseList(std::set<std::string>& set, const boost::property_tree::ptree& list, const std::string& section)
+NetworkPredicateBase::parseList(std::set<std::string>& set,
+                                const boost::property_tree::ptree& list,
+                                const std::string& section)
 {
   set.clear();
 
@@ -58,12 +60,14 @@ NetworkPredicateBase::parseList(std::set<std::string>& set, const boost::propert
     }
     else {
       if (!isRuleSupported(item.first)) {
-        BOOST_THROW_EXCEPTION(ConfigFile::Error("Unrecognized rule \"" + item.first + "\" in \"" + section + "\" section"));
+        NDN_THROW(ConfigFile::Error("Unrecognized rule '" + item.first +
+                                    "' in section '" + section + "'"));
       }
 
       auto value = item.second.get_value<std::string>();
       if (!isRuleValid(item.first, value)) {
-        BOOST_THROW_EXCEPTION(ConfigFile::Error("Malformed " + item.first + " \"" + value + "\" in \"" + section + "\" section"));
+        NDN_THROW(ConfigFile::Error("Malformed " + item.first + " '" + value +
+                                    "' in section '" + section + "'"));
       }
       set.insert(value);
     }
@@ -71,7 +75,8 @@ NetworkPredicateBase::parseList(std::set<std::string>& set, const boost::propert
 }
 
 void
-NetworkPredicateBase::parseList(std::set<std::string>& set, std::initializer_list<std::pair<std::string, std::string>> list)
+NetworkPredicateBase::parseList(std::set<std::string>& set,
+                                std::initializer_list<std::pair<std::string, std::string>> list)
 {
   set.clear();
 
@@ -82,11 +87,11 @@ NetworkPredicateBase::parseList(std::set<std::string>& set, std::initializer_lis
     }
     else {
       if (!isRuleSupported(item.first)) {
-        BOOST_THROW_EXCEPTION(std::runtime_error("Unrecognized rule \"" + item.first + "\""));
+        NDN_THROW(std::runtime_error("Unrecognized rule '" + item.first + "'"));
       }
 
       if (!isRuleValid(item.first, item.second)) {
-        BOOST_THROW_EXCEPTION(std::runtime_error("Malformed " + item.first + " \"" + item.second + "\""));
+        NDN_THROW(std::runtime_error("Malformed " + item.first + " '" + item.second + "'"));
       }
       set.insert(item.second);
     }
@@ -135,7 +140,7 @@ NetworkInterfacePredicate::isRuleValid(const std::string& key, const std::string
     return Network::isValidCidr(value);
   }
   else {
-    BOOST_THROW_EXCEPTION(std::logic_error("Only supported rules are expected"));
+    NDN_THROW(std::logic_error("Only supported rules are expected"));
   }
 }
 
@@ -153,7 +158,7 @@ IpAddressPredicate::isRuleValid(const std::string& key, const std::string& value
     return Network::isValidCidr(value);
   }
   else {
-    BOOST_THROW_EXCEPTION(std::logic_error("Only supported rules are expected"));
+    NDN_THROW(std::logic_error("Only supported rules are expected"));
   }
 }
 
@@ -218,4 +223,5 @@ IpAddressPredicate::operator()(const boost::asio::ip::address& address) const
          std::none_of(m_blacklist.begin(), m_blacklist.end(), bind(&doesAddressMatchRule, std::cref(address), _1));
 }
 
+} // namespace face
 } // namespace nfd

daemon/face/network-predicate.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,13 +23,15 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_CORE_NETWORK_PREDICATE_HPP
-#define NFD_CORE_NETWORK_PREDICATE_HPP
+#ifndef NFD_DAEMON_FACE_NETWORK_PREDICATE_HPP
+#define NFD_DAEMON_FACE_NETWORK_PREDICATE_HPP
+
+#include "core/common.hpp"
 
-#include "common.hpp"
 #include <ndn-cxx/net/network-interface.hpp>
 
 namespace nfd {
+namespace face {
 
 class NetworkPredicateBase
 {
@@ -128,6 +130,7 @@ private:
   isRuleValid(const std::string& key, const std::string& value) final;
 };
 
+} // namespace face
 } // namespace nfd
 
-#endif // NFD_CORE_NETWORK_PREDICATE_HPP
+#endif // NFD_DAEMON_FACE_NETWORK_PREDICATE_HPP

daemon/face/null-face.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2015,  Regents of the University of California,
+/*
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,20 +24,19 @@
  */
 
 #include "null-face.hpp"
-#include "generic-link-service.hpp"
-#include "internal-transport.hpp"
+#include "null-link-service.hpp"
+#include "null-transport.hpp"
 
 namespace nfd {
 namespace face {
 
-// FIB could restrict creating a nexthop record toward non-local face in /localhost namespace.
-// NullFace has scope=local to enable creating a "blackhole" FIB entry under /localhost.
-
 shared_ptr<Face>
 makeNullFace(const FaceUri& uri)
 {
-  return make_shared<Face>(make_unique<GenericLinkService>(),
-                           make_unique<InternalForwarderTransport>(uri, uri, ndn::nfd::FACE_SCOPE_LOCAL));
+  // FIB could restrict creating a nexthop record toward a non-local face in /localhost namespace.
+  // Therefore, NullFace has scope=local to enable creating a "blackhole" FIB entry under /localhost.
+  return make_shared<Face>(make_unique<NullLinkService>(),
+                           make_unique<NullTransport>(uri, uri, ndn::nfd::FACE_SCOPE_LOCAL));
 }
 
 } // namespace face

daemon/face/null-link-service.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,15 +23,41 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_CORE_FIB_MAX_DEPTH_HPP
-#define NFD_CORE_FIB_MAX_DEPTH_HPP
+#ifndef NFD_DAEMON_FACE_NULL_LINK_SERVICE_HPP
+#define NFD_DAEMON_FACE_NULL_LINK_SERVICE_HPP
+
+#include "link-service.hpp"
 
 namespace nfd {
+namespace face {
 
-/** \brief Maximum number of components in a FIB entry prefix.
+/** \brief A LinkService that drops every packet.
  */
-static const int FIB_MAX_DEPTH = 32;
+class NullLinkService final : public LinkService
+{
+private:
+  void
+  doSendInterest(const Interest&) final
+  {
+  }
 
+  void
+  doSendData(const Data&) final
+  {
+  }
+
+  void
+  doSendNack(const lp::Nack&) final
+  {
+  }
+
+  void
+  doReceivePacket(const Block&, const EndpointId&) final
+  {
+  }
+};
+
+} // namespace face
 } // namespace nfd
 
-#endif // NFD_CORE_FIB_MAX_DEPTH_HPP
+#endif // NFD_DAEMON_FACE_NULL_LINK_SERVICE_HPP

daemon/face/null-transport.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2017,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,24 +23,25 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/** \file
- *  \brief declares ContentStore internal types
- */
-
-#ifndef NFD_DAEMON_TABLE_CS_INTERNAL_HPP
-#define NFD_DAEMON_TABLE_CS_INTERNAL_HPP
-
-#include "core/common.hpp"
+#include "null-transport.hpp"
 
 namespace nfd {
-namespace cs {
+namespace face {
 
-class EntryImpl;
+NFD_LOG_INIT(NullTransport);
 
-typedef std::set<EntryImpl> Table;
-typedef Table::const_iterator iterator;
+NullTransport::NullTransport(const FaceUri& localUri, const FaceUri& remoteUri,
+                             ndn::nfd::FaceScope scope, ndn::nfd::FacePersistency persistency)
+{
+  this->setLocalUri(localUri);
+  this->setRemoteUri(remoteUri);
+  this->setScope(scope);
+  this->setPersistency(persistency);
+  this->setLinkType(ndn::nfd::LINK_TYPE_POINT_TO_POINT);
+  this->setMtu(MTU_UNLIMITED);
 
-} // namespace cs
+  NFD_LOG_FACE_DEBUG("Creating transport");
+}
+
+} // namespace face
 } // namespace nfd
-
-#endif // NFD_DAEMON_TABLE_CS_INTERNAL_HPP

daemon/face/null-transport.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2016,  Regents of the University of California,
+/*
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -23,36 +23,40 @@
  * NFD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef NFD_DAEMON_MGMT_NFD_MANAGER_BASE_HPP
-#define NFD_DAEMON_MGMT_NFD_MANAGER_BASE_HPP
+#ifndef NFD_DAEMON_FACE_NULL_TRANSPORT_HPP
+#define NFD_DAEMON_FACE_NULL_TRANSPORT_HPP
 
-#include "core/manager-base.hpp"
-#include "command-authenticator.hpp"
+#include "transport.hpp"
 
 namespace nfd {
+namespace face {
 
-using ndn::mgmt::Dispatcher;
-using ndn::nfd::ControlParameters;
-
-/**
- * @brief a collection of common functions shared by all NFD managers,
- *        such as communicating with the dispatcher and command validator.
+/** \brief A Transport that drops every packet.
  */
-class NfdManagerBase : public ManagerBase
+class NullTransport FINAL_UNLESS_WITH_TESTS : public Transport
 {
 public:
-  NfdManagerBase(Dispatcher& dispatcher,
-                 CommandAuthenticator& authenticator,
-                 const std::string& module);
+  explicit
+  NullTransport(const FaceUri& localUri = FaceUri("null://"),
+                const FaceUri& remoteUri = FaceUri("null://"),
+                ndn::nfd::FaceScope scope = ndn::nfd::FACE_SCOPE_NON_LOCAL,
+                ndn::nfd::FacePersistency persistency = ndn::nfd::FACE_PERSISTENCY_PERMANENT);
 
-PUBLIC_WITH_TESTS_ELSE_PRIVATE: // command validation
-  virtual ndn::mgmt::Authorization
-  makeAuthorization(const std::string& verb) override;
+protected:
+  void
+  doClose() OVERRIDE_WITH_TESTS_ELSE_FINAL
+  {
+    setState(TransportState::CLOSED);
+  }
 
 private:
-  CommandAuthenticator& m_authenticator;
+  void
+  doSend(const Block&) OVERRIDE_WITH_TESTS_ELSE_FINAL
+  {
+  }
 };
 
+} // namespace face
 } // namespace nfd
 
-#endif // NFD_DAEMON_MGMT_NFD_MANAGER_BASE_HPP
+#endif // NFD_DAEMON_FACE_NULL_TRANSPORT_HPP

daemon/face/pcap-helper.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,6 +24,7 @@
  */
 
 #include "pcap-helper.hpp"
+#include "ethernet-protocol.hpp"
 
 #include <pcap/pcap.h>
 #include <unistd.h>
@@ -41,14 +42,17 @@ PcapHelper::PcapHelper(const std::string& interfaceName)
   char errbuf[PCAP_ERRBUF_SIZE] = {};
   m_pcap = pcap_create(interfaceName.data(), errbuf);
   if (!m_pcap)
-    BOOST_THROW_EXCEPTION(Error("pcap_create: " + std::string(errbuf)));
+    NDN_THROW(Error("pcap_create: " + std::string(errbuf)));
 
   // Enable "immediate mode", effectively disabling any read buffering in the kernel.
   // This corresponds to the BIOCIMMEDIATE ioctl on BSD-like systems (including macOS)
   // where libpcap uses a BPF device. On Linux this forces libpcap not to use TPACKET_V3,
   // even if the kernel supports it, thus preventing bug #1511.
   if (pcap_set_immediate_mode(m_pcap, 1) < 0)
-    BOOST_THROW_EXCEPTION(Error("pcap_set_immediate_mode failed"));
+    NDN_THROW(Error("pcap_set_immediate_mode failed"));
+
+  pcap_set_snaplen(m_pcap, ethernet::HDR_LEN + ndn::MAX_NDN_PACKET_SIZE);
+  pcap_set_buffer_size(m_pcap, 4 * 1024 * 1024);
 }
 
 PcapHelper::~PcapHelper()
@@ -61,13 +65,13 @@ PcapHelper::activate(int dlt)
 {
   int ret = pcap_activate(m_pcap);
   if (ret < 0)
-    BOOST_THROW_EXCEPTION(Error("pcap_activate: " + std::string(pcap_statustostr(ret))));
+    NDN_THROW(Error("pcap_activate: " + std::string(pcap_statustostr(ret))));
 
   if (pcap_set_datalink(m_pcap, dlt) < 0)
-    BOOST_THROW_EXCEPTION(Error("pcap_set_datalink: " + getLastError()));
+    NDN_THROW(Error("pcap_set_datalink: " + getLastError()));
 
   if (pcap_setdirection(m_pcap, PCAP_D_IN) < 0)
-    BOOST_THROW_EXCEPTION(Error("pcap_setdirection: " + getLastError()));
+    NDN_THROW(Error("pcap_setdirection: " + getLastError()));
 }
 
 void
@@ -84,7 +88,7 @@ PcapHelper::getFd() const
 {
   int fd = pcap_get_selectable_fd(m_pcap);
   if (fd < 0)
-    BOOST_THROW_EXCEPTION(Error("pcap_get_selectable_fd failed"));
+    NDN_THROW(Error("pcap_get_selectable_fd failed"));
 
   // we need to duplicate the fd, otherwise both pcap_close() and the
   // caller may attempt to close the same fd and one of them will fail
@@ -102,7 +106,7 @@ PcapHelper::getNDropped() const
 {
   pcap_stat ps{};
   if (pcap_stats(m_pcap, &ps) < 0)
-    BOOST_THROW_EXCEPTION(Error("pcap_stats: " + getLastError()));
+    NDN_THROW(Error("pcap_stats: " + getLastError()));
 
   return ps.ps_drop;
 }
@@ -112,12 +116,12 @@ PcapHelper::setPacketFilter(const char* filter) const
 {
   bpf_program prog;
   if (pcap_compile(m_pcap, &prog, filter, 1, PCAP_NETMASK_UNKNOWN) < 0)
-    BOOST_THROW_EXCEPTION(Error("pcap_compile: " + getLastError()));
+    NDN_THROW(Error("pcap_compile: " + getLastError()));
 
   int ret = pcap_setfilter(m_pcap, &prog);
   pcap_freecode(&prog);
   if (ret < 0)
-    BOOST_THROW_EXCEPTION(Error("pcap_setfilter: " + getLastError()));
+    NDN_THROW(Error("pcap_setfilter: " + getLastError()));
 }
 
 std::tuple<const uint8_t*, size_t, std::string>

daemon/face/protocol-factory.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2017,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,6 +24,7 @@
  */
 
 #include "protocol-factory.hpp"
+
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
 
@@ -66,5 +67,67 @@ ProtocolFactory::ProtocolFactory(const CtorParams& params)
   BOOST_ASSERT(netmon != nullptr);
 }
 
+ProtocolFactory::~ProtocolFactory() = default;
+
+void
+ProtocolFactory::processConfig(OptionalConfigSection configSection,
+                               FaceSystem::ConfigContext& context)
+{
+  doProcessConfig(configSection, context);
+}
+
+void
+ProtocolFactory::doProcessConfig(OptionalConfigSection,
+                                 FaceSystem::ConfigContext&)
+{
+}
+
+void
+ProtocolFactory::createFace(const CreateFaceRequest& req,
+                            const FaceCreatedCallback& onCreated,
+                            const FaceCreationFailedCallback& onFailure)
+{
+  BOOST_ASSERT(!FaceUri::canCanonize(req.remoteUri.getScheme()) ||
+               req.remoteUri.isCanonical());
+  BOOST_ASSERT(!req.localUri || !FaceUri::canCanonize(req.localUri->getScheme()) ||
+               req.localUri->isCanonical());
+  doCreateFace(req, onCreated, onFailure);
+}
+
+void
+ProtocolFactory::doCreateFace(const CreateFaceRequest&,
+                              const FaceCreatedCallback&,
+                              const FaceCreationFailedCallback& onFailure)
+{
+  onFailure(406, "Unsupported protocol");
+}
+
+shared_ptr<Face>
+ProtocolFactory::createNetdevBoundFace(const FaceUri& remote,
+                                       const shared_ptr<const ndn::net::NetworkInterface>& netif)
+{
+  BOOST_ASSERT(remote.isCanonical());
+  return doCreateNetdevBoundFace(remote, netif);
+}
+
+shared_ptr<Face>
+ProtocolFactory::doCreateNetdevBoundFace(const FaceUri&,
+                                         const shared_ptr<const ndn::net::NetworkInterface>&)
+{
+  NDN_THROW(Error("This protocol factory does not support netdev-bound faces"));
+}
+
+std::vector<shared_ptr<const Channel>>
+ProtocolFactory::getChannels() const
+{
+  return doGetChannels();
+}
+
+std::vector<shared_ptr<const Channel>>
+ProtocolFactory::doGetChannels() const
+{
+  return {};
+}
+
 } // namespace face
 } // namespace nfd

daemon/face/protocol-factory.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -27,11 +27,11 @@
 #define NFD_DAEMON_FACE_PROTOCOL_FACTORY_HPP
 
 #include "channel.hpp"
+#include "face.hpp"
 #include "face-system.hpp"
 
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
-#include <ndn-cxx/encoding/nfd-constants.hpp>
 
 namespace nfd {
 namespace face {
@@ -62,7 +62,7 @@ public: // registry
   using CtorParams = ProtocolFactoryCtorParams;
 
   /** \brief Register a protocol factory type
-   *  \tparam S subclass of ProtocolFactory
+   *  \tparam PF subclass of ProtocolFactory
    *  \param id factory identifier
    */
   template<typename PF>
@@ -71,16 +71,16 @@ public: // registry
   {
     Registry& registry = getRegistry();
     BOOST_ASSERT(registry.count(id) == 0);
-    registry[id] = &make_unique<PF, const CtorParams&>;
+    registry[id] = [] (const CtorParams& p) { return make_unique<PF>(p); };
   }
 
   /** \brief Create a protocol factory instance
-   *  \retval nullptr if factory with \p id is not registered
+   *  \retval nullptr if a factory with the given \p id is not registered
    */
   static unique_ptr<ProtocolFactory>
   create(const std::string& id, const CtorParams& params);
 
-  /** \brief Get registered protocol factory ids
+  /** \brief Get all registered protocol factory ids
    */
   static std::set<std::string>
   listRegistered();
@@ -91,44 +91,40 @@ public:
   class Error : public std::runtime_error
   {
   public:
-    explicit
-    Error(const std::string& what)
-      : std::runtime_error(what)
-    {
-    }
+    using std::runtime_error::runtime_error;
   };
 
+  explicit
+  ProtocolFactory(const CtorParams& params);
+
   virtual
-  ~ProtocolFactory() = default;
+  ~ProtocolFactory() = 0;
 
 #ifdef DOXYGEN
-  /** \brief Get id for this ProtocolFactory
+  /** \brief Get id for this protocol factory
    *
    *  face_system.factory-id config section is processed by the protocol factory.
    */
   static const std::string&
-  getId();
+  getId() noexcept;
 #endif
 
-  /** \brief Process face_system subsection that corresponds to this ProtocolFactory type
-   *  \param configSection the configuration section or boost::null to indicate it is omitted
-   *  \param context provides access to data structures and contextual information
-   *  \throw ConfigFile::Error invalid configuration
-   *
-   *  This function updates \p providedSchemes
-   */
-  virtual void
-  processConfig(OptionalConfigSection configSection,
-                FaceSystem::ConfigContext& context) = 0;
-
-  /** \brief Get FaceUri schemes accepted by this ProtocolFactory
+  /** \brief Get FaceUri schemes accepted by this protocol factory
    */
   const std::set<std::string>&
-  getProvidedSchemes()
+  getProvidedSchemes() const
   {
     return providedSchemes;
   }
 
+  /** \brief Process face_system subsection that corresponds to this protocol factory id
+   *  \param configSection the configuration section or boost::none to indicate it is omitted
+   *  \param context provides access to data structures and contextual information
+   *  \throw ConfigFile::Error invalid configuration
+   */
+  void
+  processConfig(OptionalConfigSection configSection, FaceSystem::ConfigContext& context);
+
   /** \brief Encapsulates a face creation request and all its parameters
    *
    *  Parameters are passed as a struct rather than individually, so that a future change in the list
@@ -141,25 +137,35 @@ public:
     FaceParams params;
   };
 
-  /** \brief Try to create a unicast face using the supplied parameters
-   *
-   * \param req request object containing the face creation parameters
-   * \param onCreated callback if face creation succeeds or face already exists; the settings
-   *                  of an existing face are not updated if they differ from the request
-   * \param onFailure callback if face creation fails
+  /** \brief Create a unicast face
+   *  \param req request object containing the face creation parameters
+   *  \param onCreated callback if face creation succeeds or face already exists; the settings
+   *                   of an existing face are not updated if they differ from the request
+   *  \param onFailure callback if face creation fails
    */
-  virtual void
+  void
   createFace(const CreateFaceRequest& req,
              const FaceCreatedCallback& onCreated,
-             const FaceCreationFailedCallback& onFailure) = 0;
+             const FaceCreationFailedCallback& onFailure);
 
-  virtual std::vector<shared_ptr<const Channel>>
-  getChannels() const = 0;
+  /** \brief Create a netdev-bound face
+   *  \param remote remote FaceUri, must be canonical
+   *  \param netdev local network interface
+   *  \return new face
+   *  \throw Error cannot create a face using specified arguments
+   *  \note The caller must ensure there is no existing netdev-bound face with same remote FaceUri
+   *        on the same local network interface.
+   */
+  shared_ptr<Face>
+  createNetdevBoundFace(const FaceUri& remote,
+                        const shared_ptr<const ndn::net::NetworkInterface>& netdev);
+
+  /** \brief Get list of open channels (listening + non-listening)
+   */
+  std::vector<shared_ptr<const Channel>>
+  getChannels() const;
 
 protected:
-  explicit
-  ProtocolFactory(const CtorParams& params);
-
   template<typename ChannelMap>
   static std::vector<shared_ptr<const Channel>>
   getChannelsFromMap(const ChannelMap& channelMap)
@@ -169,6 +175,58 @@ protected:
     return channels;
   }
 
+private:
+  /** \brief Process face_system subsection that corresponds to this protocol factory id
+   *  \sa processConfig
+   *
+   *  A subclass should override this method if it supports configuration options in the config
+   *  file, and do all the required processing here. The subclass should throw ConfigFile::Error
+   *  if it encounters unrecognized options or invalid values. It should also update
+   *  \p providedSchemes as needed.
+   *
+   *  The base class implementation does nothing.
+   */
+  virtual void
+  doProcessConfig(OptionalConfigSection configSection, FaceSystem::ConfigContext& context);
+
+  /** \brief Create a unicast face
+   *  \sa createFace
+   *
+   *  The base class implementation always invokes the failure callback with error code 406,
+   *  indicating unicast face creation is not supported.
+   */
+  virtual void
+  doCreateFace(const CreateFaceRequest& req,
+               const FaceCreatedCallback& onCreated,
+               const FaceCreationFailedCallback& onFailure);
+
+  /** \brief Create a netdev-bound face
+   *  \sa createNetdevBoundFace
+   *
+   *  The base class implementation always throws Error, indicating netdev-bound faces are not
+   *  supported.
+   *
+   *  A subclass that offers netdev-bound faces should override this method, and also expose
+   *  "scheme+dev" in providedSchemes. For example, UdpFactory should provide "udp4+dev" scheme,
+   *  in addition to "udp4" scheme.
+   *
+   *  The face should be constructed immediately. Face persistency shall be reported as PERMANENT.
+   *  Face state shall remain DOWN until underlying transport is connected. The face shall remain
+   *  open until after .close() is invoked, and survive all socket errors; in case the network
+   *  interface disappears, the face shall remain DOWN until .close() is invoked.
+   */
+  virtual shared_ptr<Face>
+  doCreateNetdevBoundFace(const FaceUri& remote,
+                          const shared_ptr<const ndn::net::NetworkInterface>& netif);
+
+  /** \brief Get list of open channels (listening + non-listening)
+   *  \sa getChannels
+   *
+   *  The base class implementation returns an empty list.
+   */
+  virtual std::vector<shared_ptr<const Channel>>
+  doGetChannels() const;
+
 private: // registry
   using CreateFunc = std::function<unique_ptr<ProtocolFactory>(const CtorParams&)>;
   using Registry = std::map<std::string, CreateFunc>; // indexed by factory id
@@ -177,7 +235,7 @@ private: // registry
   getRegistry();
 
 protected:
-  std::set<std::string> providedSchemes; ///< FaceUri schemes provided by this ProtocolFactory
+  std::set<std::string> providedSchemes; ///< FaceUri schemes provided by this protocol factory
   FaceCreatedCallback addFace; ///< callback when a new face is created
 
   /** \brief NetworkMonitor for listing available network interfaces and monitoring their changes
@@ -191,9 +249,9 @@ protected:
 } // namespace face
 } // namespace nfd
 
-/** \brief registers a protocol factory
+/** \brief Registers a protocol factory
  *
- *  This macro should appear once in .cpp of each protocol factory.
+ *  This macro should appear once in the .cpp file of each protocol factory.
  */
 #define NFD_REGISTER_PROTOCOL_FACTORY(PF)                      \
 static class NfdAuto ## PF ## ProtocolFactoryRegistrationClass \

daemon/face/queues.cpp

@@ -0,0 +1,534 @@
+#include "queues.hpp"
+#include "common/global.hpp"
+#include <ndn-cxx/encoding/estimator.hpp>
+namespace nfd
+{
+    namespace face
+    {
+        NFD_LOG_INIT(QSCCPQueue);
+        bool VirtualQueue::push(int seq, const std::shared_ptr<const Interest> &interest,
+                                uint64_t dataSize, bool needInsert)
+        {
+            this->recvBits += dataSize;
+            if (!needInsert)
+            {
+                return false;
+            }
+            if (this->currentSize >= this->size)
+            {
+
+                return false;
+            }
+            this->lastSeq = seq;
+            VirtualQueueItem vqi;
+            vqi.seq = seq;
+            vqi.item = interest;
+            vqi.queue = shared_from_this();
+            vqi.dataSize = dataSize;
+            this->innerQueue.push_back(vqi);
+            this->currentSize++;
+            auto serviceClass = interest->getServiceClass();
+            if (serviceClass && *serviceClass > 7)
+            {
+                this->penaltyFactor = 0.5;
+            }
+            return true;
+        }
+        WDRRQueue::WDRRQueue(uint32_t rateLimit, uint32_t availableBandwidth, double weight, const std::string &name,
+                             uint32_t tos, size_t vqSize) : availableBandwidth(availableBandwidth),
+                                                            weight(weight), name(name), tos(tos), vqSize(vqSize)
+        {
+
+            if (rateLimit > 0)
+            {
+                this->needRateLimit = true;
+                this->tokenBucket = std::make_shared<TokenBucket>(rateLimit, 20 * 1000 * 8, name);
+                // this->tokenBucket->start();
+            }
+            else
+            {
+                this->needRateLimit = false;
+            }
+        }
+        void WDRRQueue::updateAvailableBandwidth(uint32_t C)
+        {
+            this->availableBandwidth = C;
+        }
+        bool WDRRQueue::appendInterest(const Interest &interest)
+        {
+            std::string key = interest.getName().getPrefix(1).toUri();
+            if (this->virtualQueues.count(key) == 0)
+            {
+                this->virtualQueues[key] = std::make_shared<VirtualQueue>(1, this->vqSize);
+                this->virtualQueues[key]->tos = this->tos;
+                this->flows.push_back(key);
+                this->totalWeight += 1;
+                for (auto &item : this->virtualQueues)
+                {
+                    item.second->objectRate = this->availableBandwidth * item.second->weight / this->totalWeight;
+                    item.second->objectRate = item.second->objectRate * item.second->penaltyFactor;
+                }
+            }
+            bool needInsert = true;
+            if (this->cdt > 0 && this->currentPacketNum >= this->cdt)
+            {
+
+                needInsert = false;
+            }
+            uint64_t dataSize = 9000;
+            auto dsz = interest.getDsz();
+            if (dsz)
+            {
+                dataSize = *dsz;
+            }
+            this->recvBits += dataSize;
+            auto success = this->virtualQueues[key]->push(0, interest.shared_from_this(), dataSize, needInsert);
+            if (success)
+            {
+                this->currentPacketNum++;
+            }
+            return success;
+        }
+        std::shared_ptr<VirtualQueueItem> WDRRQueue::scheduleNext()
+        {
+            if (this->nextScheduleQueue >= this->flows.size())
+            {
+                for (auto &key : this->flows)
+                {
+                    if (this->virtualQueues.count(key) == 0)
+                    {
+                        continue;
+                    }
+                    auto &item = this->virtualQueues[key];
+                    item->balance += item->weight * item->penaltyFactor * this->MTU_QUANTA;
+                }
+                this->nextScheduleQueue = 0;
+            }
+            std::shared_ptr<VirtualQueue> selectedVQ = nullptr;
+            for (; this->nextScheduleQueue < this->flows.size(); this->nextScheduleQueue++)
+            {
+                auto &item = this->virtualQueues[this->flows[this->nextScheduleQueue]];
+                if (item->empty())
+                {
+                    item->balance = 0;
+                    continue;
+                }
+                if (item->front().dataSize < item->balance)
+                {
+                    selectedVQ = item;
+                    break;
+                }
+                if (item->len() > 10)
+                {
+                }
+            }
+            if (selectedVQ == nullptr && this->currentPacketNum > 0)
+            {
+                return scheduleNext();
+            }
+            if (selectedVQ != nullptr)
+            {
+                if (needRateLimit && !this->tokenBucket->use(selectedVQ->front().dataSize))
+                {
+                    return nullptr;
+                }
+                auto item = std::make_shared<VirtualQueueItem>(selectedVQ->front());
+                selectedVQ->balance -= item->dataSize;
+                selectedVQ->pop();
+                if (selectedVQ->penaltyFactor < 0.9)
+                {
+                    item->item->setServiceClass(selectedVQ->tos + 8);
+                }
+                this->sendBits += item->dataSize;
+                this->currentPacketNum--;
+                return item;
+            }
+            return nullptr;
+        }
+        uint32_t WDRRQueue::calObjectRate(bool getCurrentRateOnly)
+        {
+            uint32_t currentRate = this->recvBits * 1000 / this->calObjectRateInterval;
+            uint32_t currentSendRate = this->sendBits * 1000 / this->calObjectRateInterval;
+            if (getCurrentRateOnly)
+            {
+                return currentRate;
+            }
+            // if (currentRate > 0) {
+            //     std::cout << "currentRate: " << currentRate << ", " << this->recvBits << "," << this->calObjectRateInterval << ", AvaliableBandwidth: " << this->availableBandwidth << std::endl;
+            // }
+            bool hasCleanFlow = false;
+            for (auto it = this->virtualQueues.begin(); it != this->virtualQueues.end();)
+            {
+                // std::cout << "key: " << it->first << ", recvBits" << it->second->recvBits << std::endl;
+                if (it->second->recvBits == 0 && it->second->empty())
+                {
+                    this->totalWeight -= it->second->weight;
+                    this->virtualQueues.erase(it++); // here is the key
+                    // std::cout << "do clean: " << std::endl;
+                    hasCleanFlow = true;
+                }
+                else
+                {
+                    it++;
+                }
+            }
+            if (hasCleanFlow)
+            {
+                this->flows.resize(this->virtualQueues.size());
+                int idx = 0;
+                for (auto it = this->virtualQueues.begin(); it != this->virtualQueues.end(); it++, idx++)
+                {
+                    this->flows[idx] = it->first;
+                }
+            }
+            double totalHightSpeedFlowWeight = 0;
+            int hightSppedFlowNum = 0;
+            uint32_t consumeRate = 0;
+            double totalWeightThisTerm = 0;
+            for (auto &item : this->virtualQueues)
+            {
+                totalWeightThisTerm += (item.second->weight * item.second->penaltyFactor);
+            }
+
+            for (auto &item : this->virtualQueues)
+            {
+                item.second->objectRate = this->availableBandwidth * item.second->weight * item.second->penaltyFactor / totalWeightThisTerm;
+                item.second->currentFlowRate = item.second->recvBits * 1000 / this->calObjectRateInterval;
+                item.second->currentRatio = item.second->currentFlowRate * 1.0 / item.second->objectRate;
+
+                auto targetHighFlowRate = (item.second->objectRate - 500000) * 1.0 / item.second->objectRate;
+                if (item.second->currentRatio > targetHighFlowRate)
+                {
+
+                    if (item.second->penaltyFactor > 0.99)
+                    {
+                        hightSppedFlowNum++;
+                        totalHightSpeedFlowWeight += item.second->weight;
+                    }
+                    consumeRate += item.second->objectRate;
+                }
+                else
+                {
+                    consumeRate += item.second->currentFlowRate;
+                }
+                NFD_LOG_DEBUG(this->name << " => currentRate: " << item.second->currentFlowRate << ", consumerRate: " << consumeRate << ", objectRate: " << item.second->objectRate << ", availableBandwidth" << this->availableBandwidth << ", weight: " << item.second->weight << ", totalWeight: " << this->totalWeight << ", currentSendRate: " << currentSendRate);
+                // std::cout << this->name << " => currentRate: " << item.second->currentFlowRate << ", consumerRate: " << consumeRate << ", objectRate: " << item.second->objectRate <<
+                //     ", availableBandwidth" << this->availableBandwidth << ", weight: " << item.second->weight << ", totalWeight: " <<
+                //     this->totalWeight << ", currentSendRate: " << currentSendRate << std::endl;
+
+                item.second->recvBits = 0;
+            }
+
+            if (consumeRate < this->availableBandwidth && hightSppedFlowNum > 0)
+            {
+
+                auto remainRate = this->availableBandwidth - consumeRate;
+                for (auto &item : this->virtualQueues)
+                {
+                    if (item.second->penaltyFactor > 0.99 && item.second->currentRatio > 0.8)
+                    {
+                        item.second->objectRate += (remainRate * item.second->weight / totalHightSpeedFlowWeight);
+                    }
+                    NFD_LOG_DEBUG(this->name << " => objectRate: " << item.second->objectRate << ", remainRate: " << remainRate << ", item.weight: " << item.second->weight << ", totalWeight: " << totalHightSpeedFlowWeight);
+                    // std::cout << this->name << " => objectRate: " << item.second->objectRate << ", remainRate: " <<
+                    // remainRate << ", item.weight: " << item.second->weight << ", totalWeight: " << totalHightSpeedFlowWeight << std::endl;
+                }
+            }
+
+            for (auto &item : this->virtualQueues)
+            {
+
+                if (item.second->currentFlowRate * 1.0 / item.second->objectRate > item.second->gredyRatio)
+                {
+                    if (item.second->gredyTimes < item.second->gredyThreshold)
+                    {
+                        item.second->gredyTimes++;
+                    }
+                    if (item.second->gredyTimes == item.second->gredyThreshold)
+                    {
+                        // std::cout << item.first << ": PenaltyFactor => " << item.second->gredyTimes << ", currentFlowRate: " << item.second->currentFlowRate << ", objectRate: " << item.second->objectRate << std::endl;
+                        item.second->penaltyFactor = 0.5;
+                        item.second->size = 20;
+                    }
+                }
+                else
+                {
+                    if (item.second->gredyTimes > 0)
+                    {
+                        item.second->gredyTimes--;
+                    }
+                }
+            }
+            // if (this->virtualQueues.size() > 0)
+            // {
+            //     std::cout << "\n\n=====================: " << this->availableBandwidth << std::endl;
+            // }
+            for (auto &item : this->virtualQueues)
+            {
+                if (item.second->penaltyFactor > 0.99)
+                {
+                    auto rate = this->calDiscountFactor(item.second->currentSize * 1.0 / item.second->size);
+                    item.second->objectRate *= rate;
+                }
+                // std::cout << item.first << ", currentFlowRate: " << item.second->currentFlowRate
+                //           << ", objectRate: " << item.second->objectRate << ", size: " << item.second->currentSize
+                //           << ", weight: " << item.second->weight << ", penaltyFactor: " << item.second->penaltyFactor
+                //           << std::endl;
+            }
+            // if (this->virtualQueues.size() > 0)
+            // {
+            //     std::cout << "\n----------------------" << std::endl;
+            // }
+            this->sendBits = 0;
+            this->recvBits = 0;
+            return currentRate;
+        }
+        uint32_t WDRRQueue::scheduleOnePacketForWFQ(uint32_t totalLastSeq)
+        {
+            if (this->cachePacketForWFQ != nullptr)
+            {
+                return this->cachePacketForWFQ->seq;
+            }
+            if (this->currentPacketNum == 0)
+            {
+                return UINT32_MAX;
+            }
+            this->cachePacketForWFQ = this->scheduleNext();
+            if (this->cachePacketForWFQ == nullptr)
+            {
+
+                return UINT32_MAX;
+            }
+            if (this->lastSeq == -1)
+            {
+                this->lastSeq = totalLastSeq;
+            }
+            this->cachePacketForWFQ->seq = this->lastSeq + 1.0 * this->cachePacketForWFQ->dataSize / this->weight;
+            if (this->currentPacketNum == 0)
+            {
+                this->lastSeq = -1;
+            }
+            else
+            {
+                this->lastSeq = this->cachePacketForWFQ->seq;
+            }
+
+            return this->cachePacketForWFQ->seq;
+        }
+        std::shared_ptr<VirtualQueueItem> DelaySensitiveServiceSP::scheduleNext()
+        {
+            auto res = this->CS7Queue->scheduleNext();
+            if (res == nullptr)
+            {
+                res = this->CS6Queue->scheduleNext();
+            }
+            if (res == nullptr)
+            {
+                res = this->EFQueue->scheduleNext();
+            }
+            return res;
+        }
+        uint32_t DelaySensitiveServiceSP::calObjectRate(bool getCurrentRateOnly)
+        {
+            uint32_t res = this->CS7Queue->calObjectRate(getCurrentRateOnly);
+            res += this->CS6Queue->calObjectRate(getCurrentRateOnly);
+            res += this->EFQueue->calObjectRate(getCurrentRateOnly);
+            return res;
+        }
+        std::shared_ptr<VirtualQueueItem> WFQQueue::scheduleNext()
+        {
+            std::shared_ptr<WDRRQueue> selectedQueue = nullptr;
+            uint32_t currentMinSeq = UINT32_MAX;
+            for (auto &queue : this->queues)
+            {
+                uint32_t seq = queue->scheduleOnePacketForWFQ(this->lastSeq);
+                if (seq < currentMinSeq)
+                {
+                    currentMinSeq = seq;
+                    selectedQueue = queue;
+                }
+            }
+            if (selectedQueue != nullptr)
+            {
+                this->lastSeq = currentMinSeq;
+                auto selectPacket = selectedQueue->frontForWFQ(this->lastSeq);
+                selectedQueue->popForWFQ();
+
+                return selectPacket;
+            }
+            return nullptr;
+        }
+        uint32_t WFQQueue::calObjectRate(uint32_t availableBandwidth)
+        {
+            int totalRate = 0;
+            double totalHightSpeedFlowWeight = 0;
+            int hightSppedFlowNum = 0;
+            double totalHasFlowQueueWeight = 0;
+            int hasFlowQueueNum = 0;
+            for (auto &queue : this->queues)
+            {
+                auto recvRate = queue->calObjectRate(true);
+                queue->originAvaliableBandwidth = (queue->getWeight() / totalWeight) * availableBandwidth;
+                auto remainRate = queue->getRemainBandwidthRate(queue->originAvaliableBandwidth);
+                if (remainRate < 0.2)
+                {
+                    hightSppedFlowNum++;
+                    totalHightSpeedFlowWeight += queue->getWeight();
+                    totalRate += queue->originAvaliableBandwidth;
+                }
+                else if (remainRate < 0.95)
+                {
+                    hasFlowQueueNum++;
+                    totalHasFlowQueueWeight += queue->getWeight();
+                    totalRate += recvRate;
+                }
+                else
+                {
+                    totalRate += recvRate;
+                }
+            }
+            this->availableBandwidth = availableBandwidth;
+            int remain = this->availableBandwidth - totalRate;
+            if (hightSppedFlowNum > 0)
+            {
+                // std::cout << "high speed flow num: " << hightSppedFlowNum << ", totalHightSpeedFlowWeight: " << totalHightSpeedFlowWeight << std::endl;
+                for (auto &queue : this->queues)
+                {
+                    if (queue->getRemainBandwidthRate(queue->originAvaliableBandwidth) < 0.2)
+                    {
+                        // std::cout << "!!!" << queue->getWeight() * remain * 1.0 / totalHightSpeedFlowWeight +
+                        // queue->originAvaliableBandwidth << std::endl;
+                        queue->updateAvailableBandwidth(
+                            queue->getWeight() * remain * 1.0 / totalHightSpeedFlowWeight +
+                            queue->originAvaliableBandwidth);
+                    }
+                    else
+                    {
+                        queue->updateAvailableBandwidth(queue->originAvaliableBandwidth);
+                    }
+                }
+            }
+            else
+            {
+                // std::cout << "has flow queue num: " << hasFlowQueueNum << ", totalHasFlowQueueWeight: " << totalHasFlowQueueWeight << std::endl;
+                for (auto &queue : this->queues)
+                {
+                    if (queue->getRemainBandwidthRate(queue->originAvaliableBandwidth) < 0.95)
+                    {
+                        queue->updateAvailableBandwidth(
+                            queue->getWeight() * remain * 1.0 / totalHasFlowQueueWeight +
+                            queue->originAvaliableBandwidth);
+                    }
+                    else
+                    {
+                        queue->updateAvailableBandwidth(queue->originAvaliableBandwidth);
+                    }
+                }
+            }
+            uint32_t currentTotalRate = 0;
+
+            for (auto &queue : this->queues)
+            {
+                currentTotalRate += queue->calObjectRate(false);
+            }
+            return currentTotalRate;
+        }
+        std::shared_ptr<VirtualQueueItem> GlobalSP::scheduleNext()
+        {
+            std::shared_ptr<VirtualQueueItem> selectedPacket = this->delaySensitiveServiceSp.scheduleNext();
+            if (selectedPacket == nullptr)
+            {
+                selectedPacket = wfqQueue.scheduleNext();
+            }
+            if (selectedPacket != nullptr)
+            {
+                selectedPacket->waitNsTime = selectedPacket->dataSize * 1000000000.0 / this->availableBandwidth + 1;
+                // 计算 DR => DR'(/p, j) = min(OR(/p, j), RR(/p, j) / sum(RR(/p)) * sum(AR(/p)))
+                auto currentObjectRate = selectedPacket->queue->objectRate;
+                auto downstreamRate = selectedPacket->item->getDownstreamRate();
+                if (downstreamRate)
+                {
+                    if (*downstreamRate > currentObjectRate)
+                    {
+                        selectedPacket->item->setDownstreamRate(currentObjectRate);
+                    }
+                }
+                else
+                {
+                    selectedPacket->item->setDownstreamRate(currentObjectRate);
+                }
+            }
+            return selectedPacket;
+        }
+        std::shared_ptr<WDRRQueue> GlobalSP::getQueueByTos(int tosValue)
+        {
+            switch (tosValue)
+            {
+            case 0:
+                return this->delaySensitiveServiceSp.getCS7Queue();
+            case 1:
+                return this->delaySensitiveServiceSp.getCS6Queue();
+            case 2:
+                return this->delaySensitiveServiceSp.getEFQueue();
+            case 3:
+                return this->wfqQueue.getAF4Queue();
+            case 4:
+                return this->wfqQueue.getAF3Queue();
+            case 5:
+                return this->wfqQueue.getAF2Queue();
+            case 6:
+                return this->wfqQueue.getAF1Queue();
+            case 7:
+            default:
+                return this->wfqQueue.getBEQueue();
+            }
+        }
+        bool GlobalSP::appendInterest(const Interest &interest)
+        {
+            int serviceClass = 7;
+            if (interest.getServiceClass())
+            {
+                serviceClass = (*interest.getServiceClass()) % 8;
+            }
+            // std::cout << "appendInterest => serviceClass: " << serviceClass << std::endl;
+            return this->getQueueByTos(serviceClass)->appendInterest(interest);
+        }
+        void GlobalSP::receiveInterest(const Interest &interest)
+        {
+            ndn::encoding::EncodingEstimator estimator;
+            auto size = interest.wireEncode(estimator) + 9;
+            this->interestBytes += size;
+            // std::cout << this << "receiveInterest => size: " << size << ", interestBytes: " << this->interestBytes << std::endl;
+        }
+
+        void GlobalSP::calObjectRate(bool getCurrentRateOnly)
+        {
+            // getScheduler().schedule(time::nanoseconds(1000000 * this->calObjectRateInterval),
+            //                             [this] { this->calObjectRate(false); });
+            uint32_t remain = this->availableBandwidth;
+            remain -= this->interestBytes * 8000 / this->calObjectRateInterval;
+            this->interestBytes = 0;
+            remain -= this->delaySensitiveServiceSp.calObjectRate(false);
+
+            // std::cout << "AvaliableBandwidth: " << this->availableBandwidth << ", remain: " << remain << ", interestBytes" << this->interestBytes << std::endl;
+
+            this->wfqQueue.calObjectRate(remain);
+        }
+        void GlobalSP::assignObjectRate(const Data &data)
+        {
+            std::string key = data.getName().getPrefix(1).toUri();
+            int serviceClass = 7;
+            if (data.getServiceClass())
+            {
+                serviceClass = (*data.getServiceClass()) % 8;
+            }
+            // std::cout << "assignObjectRate => serviceClass: " << serviceClass << std::endl;
+            auto objectRate = this->getQueueByTos(serviceClass)->getObjectRateByFlowKey(key);
+            auto targetRate = data.getTargetRate();
+            if (!targetRate || *targetRate > objectRate)
+            {
+                data.setTargetRate(objectRate);
+            }
+        }
+    }
+}

daemon/face/queues.hpp

@@ -0,0 +1,309 @@
+#ifndef NS_QUEUES_HPP
+#define NS_QUEUES_HPP
+#include <deque>
+#include <unordered_map>
+#include <memory>
+#include <iostream>
+#include "common/global.hpp"
+#include "link-service.hpp"
+#include <ndn-cxx/lp/tags.hpp>
+#include "TokenBucket.hpp"
+namespace nfd {
+    namespace face {
+        class VirtualQueue;
+        struct VirtualQueueItem {
+            int seq;
+            std::shared_ptr<const Interest> item;
+            uint32_t dataSize;
+            uint32_t waitNsTime;
+            std::shared_ptr<VirtualQueue> queue;
+        };
+        class VirtualQueue : public std::enable_shared_from_this<VirtualQueue>{
+        public:
+            explicit VirtualQueue(double weight, int size) :
+                    std::enable_shared_from_this<VirtualQueue>(),
+                    penaltyFactor(1.0),
+                    weight(weight), size(size), currentSize(0), lastSeq(0),
+                    C(0) {
+            }
+            void enableTokenBucket(uint32_t limitRate) {
+                this->C = limitRate;
+            }
+            bool push(int seq, const std::shared_ptr<const Interest>& interest,
+                      uint64_t dataSize, bool needInsert);
+            bool empty() {
+                return this->innerQueue.empty();
+            }
+            uint32_t frontSeq() {
+                if (this->innerQueue.empty()) {
+                    return this->lastSeq;
+                }
+                return this->innerQueue.front().seq;
+            }
+            VirtualQueueItem front() {
+                return this->innerQueue.front();
+            }
+            uint32_t backSeq() {
+                return this->lastSeq;
+            }
+            VirtualQueueItem back() {
+                return this->innerQueue.back();
+            }
+            void pop() {
+                if (this->currentSize <= 0) {
+                    return;
+                }
+                this->currentSize--;
+                this->innerQueue.pop_front();
+            }
+            void popBack() {
+                if (this->currentSize <= 0) {
+                    return;
+                }
+                this->currentSize--;
+                this->innerQueue.pop_back();
+            }
+            int len() {
+                return this->innerQueue.size();
+            }
+            void setLastSeq(uint32_t seq) {
+                this->lastSeq = seq;
+            }
+            uint32_t getLastSeq() {
+                return lastSeq;
+            }
+            void setWeight(double weight) {
+                this->weight = weight;
+            }
+            double getWeight() {
+                return this->weight;
+            }
+        public:
+            uint32_t objectRate;
+            double penaltyFactor = 1.0;
+            uint32_t gredyTimes = 0;
+            double gredyRatio = 1.2;
+            double gredyThreshold = 10;
+            double weight = 1.0;
+            uint32_t tos = 5;
+            double balance = 0;
+            int size = 0;
+            int currentSize = 0;
+            uint32_t recvBits = 0;
+            uint32_t currentFlowRate = 0;
+            double currentRatio = 0.0;
+        private:
+            uint32_t lastSeq;
+            int C;
+            std::deque<VirtualQueueItem> innerQueue;
+        };
+        class WDRRQueue {
+        public:
+            explicit WDRRQueue(uint32_t rateLimit, uint32_t availableBandwidth, double weight, const std::string& name,
+                                uint32_t tos = 5, size_t vqSize = 20);
+            void updateAvailableBandwidth(uint32_t C);
+            bool appendInterest(const Interest &interest);
+            std::shared_ptr<VirtualQueueItem> scheduleNext();
+            uint32_t calObjectRate(bool getCurrentRateOnly);
+            void setCDTLimit(int cdt) {
+                this->cdt = cdt;
+            }
+            uint32_t scheduleOnePacketForWFQ(uint32_t totalLastSeq);
+            std::shared_ptr<VirtualQueueItem> frontForWFQ(uint32_t totalLastSeq) {
+                if (this->cachePacketForWFQ == nullptr) {
+                    this->scheduleOnePacketForWFQ(totalLastSeq);
+                }
+                return this->cachePacketForWFQ;
+            }
+            void popForWFQ() {
+                this->cachePacketForWFQ = nullptr;
+            }
+            double getRemainBandwidthRate(double curAvailableBandWidth) {
+                auto currentRate = this->calObjectRate(true);
+                if (currentRate > curAvailableBandWidth) {
+                    return 0;
+                }
+                return (curAvailableBandWidth - currentRate) * 1.0 / curAvailableBandWidth;
+            }
+            uint32_t getRemainBandwidth() {
+                return this->availableBandwidth - this->calObjectRate(true);
+            }
+            double getWeight() {
+                return this->weight;
+            }
+            uint32_t getAvailableBandwidth() {
+                return this->availableBandwidth;
+            }
+            /**
+             * @brief 
+             * 
+             * \sigma=\frac{1}{3}\arccot\funcapply(8\delta-4)
+             * @param x 
+             * @return double 
+             */
+            double calDiscountFactor(double x) {
+                return 1.0 / 3 * (M_PI / 2 - atan(8 * x - 4)) + 0.034;
+            }
+            /**
+             * @brief Get the Object Rate By Flow Key object
+             * 
+             * @param key 
+             * @return uint32_t 
+             */
+            uint32_t getObjectRateByFlowKey(const std::string& key) {
+                if (this->virtualQueues.count(key) == 0) {
+                    std::cout << "FUCK: " << key << ", count: " << this->virtualQueues.size() << 
+                    ", flow: " << this->flows.size() << "availbleRate: " << this->availableBandwidth << std::endl;
+                    return 0;
+                }
+                return this->virtualQueues[key]->objectRate;
+            }
+
+            void triggerByCurrentTime(long currentTime) {
+                if (this->needRateLimit) {
+                    this->tokenBucket->generateTokenByCurrentTime(currentTime);
+                }
+            }
+
+        public:
+            double originAvaliableBandwidth = 0;
+        private:
+            std::unordered_map<std::string, std::shared_ptr<VirtualQueue>> virtualQueues;
+            std::vector<std::string> flows;
+            size_t nextScheduleQueue = 0;
+            std::shared_ptr<TokenBucket> tokenBucket;
+            uint32_t availableBandwidth;
+            // uint32_t extraBandwidth;
+            double weight;
+            std::string name;
+            uint32_t tos = 5;
+            bool needRateLimit;
+            double totalWeight;
+            uint32_t sendBits = 0;
+            uint32_t recvBits = 0;
+            int vqSize = 20;
+            int cdt = -1;
+            int currentPacketNum = 0;
+            int MTU_QUANTA = 2 * 1000 * 8;
+            int calObjectRateInterval = 100;
+            int64_t lastSeq = -1;
+            std::shared_ptr<VirtualQueueItem> cachePacketForWFQ = nullptr;
+        };
+        class DelaySensitiveServiceSP {
+        public:
+            explicit DelaySensitiveServiceSP(uint32_t availableBandwidth, size_t vqSize = 20) {
+                this->CS7Queue = std::make_shared<WDRRQueue>((uint32_t) (0.2 * availableBandwidth), (uint32_t) (0.2 * availableBandwidth), 2, "CS7", 2, vqSize);
+                this->CS6Queue = std::make_shared<WDRRQueue>((uint32_t) (0.2 * availableBandwidth), (uint32_t) (0.2 * availableBandwidth), 2, "CS6", 1, vqSize);
+                this->EFQueue = std::make_shared<WDRRQueue>((uint32_t) (0.3 * availableBandwidth), (uint32_t) (0.3 * availableBandwidth), 3, "EF", 0, vqSize);
+            }
+            std::shared_ptr<VirtualQueueItem> scheduleNext();
+            uint32_t calObjectRate(bool getCurrentRateOnly);
+            std::shared_ptr<WDRRQueue> getCS7Queue() {
+                return this->CS7Queue;
+            }
+            std::shared_ptr<WDRRQueue> getCS6Queue() {
+                return this->CS6Queue;
+            }
+            std::shared_ptr<WDRRQueue> getEFQueue() {
+                return this->EFQueue;
+            }
+            void triggerByCurrentTime(long currentTime) {
+                this->CS7Queue->triggerByCurrentTime(currentTime);
+                this->CS6Queue->triggerByCurrentTime(currentTime);
+                this->EFQueue->triggerByCurrentTime(currentTime);
+            }
+        private:
+            std::shared_ptr<WDRRQueue> CS7Queue;
+            std::shared_ptr<WDRRQueue> CS6Queue;
+            std::shared_ptr<WDRRQueue> EFQueue;
+        };
+        class WFQQueue {
+        public:
+            explicit WFQQueue(uint32_t availableBandwidth, size_t vqSize) :
+                    AF4Weight(5),
+                    AF3Weight(4),
+                    AF2Weight(3),
+                    AF1Weight(2),
+                    BEWeight(1),
+                    totalWeight(AF4Weight + AF3Weight + AF2Weight + AF1Weight + BEWeight),
+                    queues(5),
+                    lastSeq(0),
+                    availableBandwidth(availableBandwidth) {
+                this->queues[0] = std::make_shared<WDRRQueue>(0, availableBandwidth * AF4Weight / totalWeight, 5, "AF4", 3, vqSize);
+                this->queues[1] = std::make_shared<WDRRQueue>(0, availableBandwidth * AF3Weight / totalWeight, 4, "AF3", 4, vqSize);
+                this->queues[2] = std::make_shared<WDRRQueue>(0, availableBandwidth * AF2Weight / totalWeight, 3, "AF2", 5, vqSize);
+                this->queues[3] = std::make_shared<WDRRQueue>(0, availableBandwidth * AF1Weight / totalWeight, 2, "AF1", 6, vqSize);
+                this->queues[4] = std::make_shared<WDRRQueue>(0, availableBandwidth * BEWeight / totalWeight, 1, "BE", 7, vqSize);
+                for (auto &queue: this->queues) {
+                    queue->setCDTLimit(this->cdt);
+                }
+            }
+            std::shared_ptr<VirtualQueueItem> scheduleNext();
+            uint32_t calObjectRate(uint32_t availableBandwidth);
+            std::shared_ptr<WDRRQueue> getAF4Queue() {
+                return this->queues[0];
+            }
+            std::shared_ptr<WDRRQueue> getAF3Queue() {
+                return this->queues[1];
+            }
+            std::shared_ptr<WDRRQueue> getAF2Queue() {
+                return this->queues[2];
+            }
+            std::shared_ptr<WDRRQueue> getAF1Queue() {
+                return this->queues[3];
+            }
+            std::shared_ptr<WDRRQueue> getBEQueue() {
+                return this->queues[4];
+            }
+        private:
+            double AF4Weight = 5;
+            double AF3Weight = 4;
+            double AF2Weight = 3;
+            double AF1Weight = 2;
+            double BEWeight = 1;
+            double totalWeight = 15;
+            std::vector<std::shared_ptr<WDRRQueue>> queues;
+            uint32_t lastSeq;
+            u_int32_t availableBandwidth;
+            int cdt = 200;
+            int hql;
+        };
+        class GlobalSP {
+        public:
+            explicit GlobalSP(uint32_t availableBandwidth, size_t vqSize = 20) :
+                    delaySensitiveServiceSp(availableBandwidth, vqSize),
+                    wfqQueue(availableBandwidth, vqSize),
+                    availableBandwidth(availableBandwidth) {
+                lastTriggerTime = getCurrentTime();
+                // getScheduler().schedule(time::nanoseconds(1000000 * this->calObjectRateInterval),
+                //                         [this] { this->calObjectRate(false); });
+            }
+            std::shared_ptr<VirtualQueueItem> scheduleNext();
+            bool appendInterest(const Interest &interest);
+            void receiveInterest(const Interest &interest);
+            void calObjectRate(bool getCurrentRateOnly);
+            std::shared_ptr<WDRRQueue> getQueueByTos(int tosValue);
+            long getCurrentTime() {
+                return std::chrono::duration_cast<std::chrono::milliseconds>(
+                        std::chrono::system_clock::now().time_since_epoch()).count();
+            }
+            void triggerCalObjectRate() {
+                auto currentTime = getCurrentTime();
+                this->delaySensitiveServiceSp.triggerByCurrentTime(currentTime);
+                if (currentTime - lastTriggerTime > calObjectRateInterval) {
+                    this->calObjectRate(false);
+                    lastTriggerTime = currentTime;
+                }
+            }
+            void assignObjectRate(const Data &data);
+        private:
+            DelaySensitiveServiceSP delaySensitiveServiceSp;
+            WFQQueue wfqQueue;
+            int calObjectRateInterval = 100;
+            uint32_t availableBandwidth;
+            size_t interestBytes = 0;
+            long lastTriggerTime = 0;
+        };
+    }
+}
+#endif //NS_QUEUES_HPP

daemon/face/stream-transport.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -28,7 +28,7 @@
 
 #include "transport.hpp"
 #include "socket-utils.hpp"
-#include "core/global-io.hpp"
+#include "common/global.hpp"
 
 #include <queue>
 
@@ -63,7 +63,7 @@ protected:
   deferredClose();
 
   void
-  doSend(Transport::Packet&& packet) override;
+  doSend(const Block& packet) override;
 
   void
   sendFromQueue();
@@ -180,7 +180,7 @@ StreamTransport<T>::deferredClose()
 
 template<class T>
 void
-StreamTransport<T>::doSend(Transport::Packet&& packet)
+StreamTransport<T>::doSend(const Block& packet)
 {
   NFD_LOG_FACE_TRACE(__func__);
 
@@ -188,8 +188,8 @@ StreamTransport<T>::doSend(Transport::Packet&& packet)
     return;
 
   bool wasQueueEmpty = m_sendQueue.empty();
-  m_sendQueue.push(packet.packet);
-  m_sendQueueBytes += packet.packet.size();
+  m_sendQueue.push(packet);
+  m_sendQueueBytes += packet.size();
 
   if (wasQueueEmpty)
     sendFromQueue();
@@ -255,7 +255,7 @@ StreamTransport<T>::handleReceive(const boost::system::error_code& error,
     offset += element.size();
     BOOST_ASSERT(offset <= m_receiveBufferSize);
 
-    this->receive(Transport::Packet(std::move(element)));
+    this->receive(element);
   }
 
   if (!isOk && m_receiveBufferSize == ndn::MAX_NDN_PACKET_SIZE && offset == 0) {

daemon/face/tcp-channel.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,9 +24,10 @@
  */
 
 #include "tcp-channel.hpp"
-#include "core/global-io.hpp"
+#include "face.hpp"
 #include "generic-link-service.hpp"
 #include "tcp-transport.hpp"
+#include "common/global.hpp"
 
 namespace nfd {
 namespace face {
@@ -83,8 +84,8 @@ TcpChannel::connect(const tcp::Endpoint& remoteEndpoint,
     return;
   }
 
-  auto clientSocket = make_shared<ip::tcp::socket>(std::ref(getGlobalIoService()));
-  auto timeoutEvent = scheduler::schedule(timeout, [=] {
+  auto clientSocket = make_shared<ip::tcp::socket>(getGlobalIoService());
+  auto timeoutEvent = getScheduler().schedule(timeout, [=] {
     handleConnectTimeout(remoteEndpoint, clientSocket, onConnectFailed);
   });
 
@@ -113,7 +114,7 @@ TcpChannel::createFace(ip::tcp::socket&& socket,
       options.allowCongestionMarking = m_wantCongestionMarking;
     }
     else {
-      options.allowCongestionMarking = params.wantCongestionMarking;
+      options.allowCongestionMarking = bool(params.wantCongestionMarking);
     }
 
     if (params.baseCongestionMarkingInterval) {
@@ -122,12 +123,16 @@ TcpChannel::createFace(ip::tcp::socket&& socket,
     if (params.defaultCongestionThreshold) {
       options.defaultCongestionThreshold = *params.defaultCongestionThreshold;
     }
+    if (params.bandwidth) {
+      options.C = *params.bandwidth;
+    }
 
     auto linkService = make_unique<GenericLinkService>(options);
     auto faceScope = m_determineFaceScope(socket.local_endpoint().address(),
                                           socket.remote_endpoint().address());
     auto transport = make_unique<TcpTransport>(std::move(socket), params.persistency, faceScope);
     face = make_shared<Face>(std::move(linkService), std::move(transport));
+    face->setChannel(shared_from_this()); // use weak_from_this() in C++17
 
     m_channelFaces[remoteEndpoint] = face;
     connectFaceClosedSignal(*face, [this, remoteEndpoint] { m_channelFaces.erase(remoteEndpoint); });
@@ -187,7 +192,7 @@ TcpChannel::handleConnect(const boost::system::error_code& error,
                           const FaceCreatedCallback& onFaceCreated,
                           const FaceCreationFailedCallback& onConnectFailed)
 {
-  scheduler::cancel(connectTimeoutEvent);
+  connectTimeoutEvent.cancel();
 
   if (error) {
     if (error != boost::asio::error::operation_aborted) {

daemon/face/tcp-channel.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -27,7 +27,6 @@
 #define NFD_DAEMON_FACE_TCP_CHANNEL_HPP
 
 #include "channel.hpp"
-#include "core/scheduler.hpp"
 
 namespace nfd {
 

daemon/face/tcp-factory.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -34,20 +34,15 @@ NFD_LOG_INIT(TcpFactory);
 NFD_REGISTER_PROTOCOL_FACTORY(TcpFactory);
 
 const std::string&
-TcpFactory::getId()
+TcpFactory::getId() noexcept
 {
   static std::string id("tcp");
   return id;
 }
 
-TcpFactory::TcpFactory(const CtorParams& params)
-  : ProtocolFactory(params)
-{
-}
-
 void
-TcpFactory::processConfig(OptionalConfigSection configSection,
-                          FaceSystem::ConfigContext& context)
+TcpFactory::doProcessConfig(OptionalConfigSection configSection,
+                            FaceSystem::ConfigContext& context)
 {
   // tcp
   // {
@@ -61,7 +56,7 @@ TcpFactory::processConfig(OptionalConfigSection configSection,
 
   if (!configSection) {
     if (!context.isDryRun && !m_channels.empty()) {
-      NFD_LOG_WARN("Cannot disable tcp4 and tcp6 channels after initialization");
+      NFD_LOG_WARN("Cannot disable TCP channels after initialization");
     }
     return;
   }
@@ -99,12 +94,12 @@ TcpFactory::processConfig(OptionalConfigSection configSection,
           local.parseBlacklist(localPair.second);
         }
         else {
-          BOOST_THROW_EXCEPTION(ConfigFile::Error("Unrecognized option face_system.tcp.local." + localKey));
+          NDN_THROW(ConfigFile::Error("Unrecognized option face_system.tcp.local." + localKey));
         }
       }
     }
     else {
-      BOOST_THROW_EXCEPTION(ConfigFile::Error("Unrecognized option face_system.tcp." + key));
+      NDN_THROW(ConfigFile::Error("Unrecognized option face_system.tcp." + key));
     }
   }
   if (!isLocalConfigured) {
@@ -112,49 +107,49 @@ TcpFactory::processConfig(OptionalConfigSection configSection,
   }
 
   if (!enableV4 && !enableV6) {
-    BOOST_THROW_EXCEPTION(ConfigFile::Error(
+    NDN_THROW(ConfigFile::Error(
       "IPv4 and IPv6 TCP channels have been disabled. Remove face_system.tcp section to disable "
       "TCP channels or enable at least one channel type."));
   }
 
-  if (!context.isDryRun) {
-    providedSchemes.insert("tcp");
-
-    if (enableV4) {
-      tcp::Endpoint endpoint(ip::tcp::v4(), port);
-      shared_ptr<TcpChannel> v4Channel = this->createChannel(endpoint);
-      if (wantListen && !v4Channel->isListening()) {
-        v4Channel->listen(this->addFace, nullptr);
-      }
-      providedSchemes.insert("tcp4");
-    }
-    else if (providedSchemes.count("tcp4") > 0) {
-      NFD_LOG_WARN("Cannot close tcp4 channel after its creation");
-    }
-
-    if (enableV6) {
-      tcp::Endpoint endpoint(ip::tcp::v6(), port);
-      shared_ptr<TcpChannel> v6Channel = this->createChannel(endpoint);
-      if (wantListen && !v6Channel->isListening()) {
-        v6Channel->listen(this->addFace, nullptr);
-      }
-      providedSchemes.insert("tcp6");
-    }
-    else if (providedSchemes.count("tcp6") > 0) {
-      NFD_LOG_WARN("Cannot close tcp6 channel after its creation");
-    }
-
-    m_local = std::move(local);
+  if (context.isDryRun) {
+    return;
   }
+
+  providedSchemes.insert("tcp");
+
+  if (enableV4) {
+    tcp::Endpoint endpoint(ip::tcp::v4(), port);
+    auto v4Channel = this->createChannel(endpoint);
+    if (wantListen && !v4Channel->isListening()) {
+      v4Channel->listen(this->addFace, nullptr);
+    }
+    providedSchemes.insert("tcp4");
+  }
+  else if (providedSchemes.count("tcp4") > 0) {
+    NFD_LOG_WARN("Cannot close tcp4 channel after its creation");
+  }
+
+  if (enableV6) {
+    tcp::Endpoint endpoint(ip::tcp::v6(), port);
+    auto v6Channel = this->createChannel(endpoint);
+    if (wantListen && !v6Channel->isListening()) {
+      v6Channel->listen(this->addFace, nullptr);
+    }
+    providedSchemes.insert("tcp6");
+  }
+  else if (providedSchemes.count("tcp6") > 0) {
+    NFD_LOG_WARN("Cannot close tcp6 channel after its creation");
+  }
+
+  m_local = std::move(local);
 }
 
 void
-TcpFactory::createFace(const CreateFaceRequest& req,
-                       const FaceCreatedCallback& onCreated,
-                       const FaceCreationFailedCallback& onFailure)
+TcpFactory::doCreateFace(const CreateFaceRequest& req,
+                         const FaceCreatedCallback& onCreated,
+                         const FaceCreationFailedCallback& onFailure)
 {
-  BOOST_ASSERT(req.remoteUri.isCanonical());
-
   if (req.localUri) {
     NFD_LOG_TRACE("Cannot create unicast TCP face with LocalUri");
     onFailure(406, "Unicast TCP faces cannot be created with a LocalUri");
@@ -212,7 +207,7 @@ TcpFactory::createChannel(const tcp::Endpoint& endpoint)
 }
 
 std::vector<shared_ptr<const Channel>>
-TcpFactory::getChannels() const
+TcpFactory::doGetChannels() const
 {
   return getChannelsFromMap(m_channels);
 }

daemon/face/tcp-factory.hpp

@@ -32,27 +32,15 @@
 namespace nfd {
 namespace face {
 
-/** \brief protocol factory for TCP over IPv4 and IPv6
+/** \brief Protocol factory for TCP over IPv4 and IPv6
  */
 class TcpFactory : public ProtocolFactory
 {
 public:
   static const std::string&
-  getId();
+  getId() noexcept;
 
-  explicit
-  TcpFactory(const CtorParams& params);
-
-  /** \brief process face_system.tcp config section
-   */
-  void
-  processConfig(OptionalConfigSection configSection,
-                FaceSystem::ConfigContext& context) override;
-
-  void
-  createFace(const CreateFaceRequest& req,
-             const FaceCreatedCallback& onCreated,
-             const FaceCreationFailedCallback& onFailure) override;
+  using ProtocolFactory::ProtocolFactory;
 
   /**
    * \brief Create TCP-based channel using tcp::Endpoint
@@ -68,10 +56,21 @@ public:
   shared_ptr<TcpChannel>
   createChannel(const tcp::Endpoint& localEndpoint);
 
-  std::vector<shared_ptr<const Channel>>
-  getChannels() const override;
-
 private:
+  /** \brief process face_system.tcp config section
+   */
+  void
+  doProcessConfig(OptionalConfigSection configSection,
+                  FaceSystem::ConfigContext& context) override;
+
+  void
+  doCreateFace(const CreateFaceRequest& req,
+               const FaceCreatedCallback& onCreated,
+               const FaceCreationFailedCallback& onFailure) override;
+
+  std::vector<shared_ptr<const Channel>>
+  doGetChannels() const override;
+
   ndn::nfd::FaceScope
   determineFaceScopeFromAddresses(const boost::asio::ip::address& local,
                                   const boost::asio::ip::address& remote) const;

daemon/face/tcp-transport.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,6 +24,7 @@
  */
 
 #include "tcp-transport.hpp"
+#include "common/global.hpp"
 
 #if defined(__linux__)
 #include <linux/sockios.h>
@@ -39,7 +40,9 @@ time::milliseconds TcpTransport::s_initialReconnectWait = 1_s;
 time::milliseconds TcpTransport::s_maxReconnectWait = 5_min;
 float TcpTransport::s_reconnectWaitMultiplier = 2.0f;
 
-TcpTransport::TcpTransport(protocol::socket&& socket, ndn::nfd::FacePersistency persistency, ndn::nfd::FaceScope faceScope)
+TcpTransport::TcpTransport(protocol::socket&& socket,
+                           ndn::nfd::FacePersistency persistency,
+                           ndn::nfd::FaceScope faceScope)
   : StreamTransport(std::move(socket))
   , m_remoteEndpoint(m_socket.remote_endpoint())
   , m_nextReconnectWait(s_initialReconnectWait)
@@ -51,7 +54,7 @@ TcpTransport::TcpTransport(protocol::socket&& socket, ndn::nfd::FacePersistency
   this->setLinkType(ndn::nfd::LINK_TYPE_POINT_TO_POINT);
   this->setMtu(MTU_UNLIMITED);
 
-  NFD_LOG_FACE_INFO("Creating transport");
+  NFD_LOG_FACE_DEBUG("Creating transport");
 }
 
 ssize_t
@@ -103,8 +106,8 @@ TcpTransport::handleError(const boost::system::error_code& error)
     this->setState(TransportState::DOWN);
 
     // cancel all outstanding operations
-    boost::system::error_code error;
-    m_socket.cancel(error);
+    boost::system::error_code ec;
+    m_socket.cancel(ec);
 
     // do this asynchronously because there could be some callbacks still pending
     getGlobalIoService().post([this] { reconnect(); });
@@ -130,11 +133,18 @@ TcpTransport::reconnect()
   BOOST_ASSERT(getState() == TransportState::DOWN);
 
   // recreate the socket
-  m_socket = protocol::socket(m_socket.get_io_service());
+  m_socket = protocol::socket(
+#if BOOST_VERSION >= 107000
+                              m_socket.get_executor()
+#else
+                              m_socket.get_io_service()
+#endif // BOOST_VERSION >= 107000
+                              );
   this->resetReceiveBuffer();
   this->resetSendQueue();
 
-  m_reconnectEvent = scheduler::schedule(m_nextReconnectWait, [this] { this->handleReconnectTimeout(); });
+  m_reconnectEvent = getScheduler().schedule(m_nextReconnectWait,
+                                             [this] { this->handleReconnectTimeout(); });
   m_socket.async_connect(m_remoteEndpoint, [this] (const auto& e) { this->handleReconnect(e); });
 }
 

daemon/face/tcp-transport.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2019,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -27,7 +27,6 @@
 #define NFD_DAEMON_FACE_TCP_TRANSPORT_HPP
 
 #include "stream-transport.hpp"
-#include "core/scheduler.hpp"
 
 namespace nfd {
 namespace face {

daemon/face/transport.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -31,8 +31,6 @@ namespace face {
 
 NFD_LOG_INIT(Transport);
 
-const ssize_t Transport::MIN_MTU;
-
 std::ostream&
 operator<<(std::ostream& os, TransportState state)
 {
@@ -52,12 +50,6 @@ operator<<(std::ostream& os, TransportState state)
   }
 }
 
-Transport::Packet::Packet(Block&& packet1)
-  : packet(std::move(packet1))
-  , remoteEndpoint(0)
-{
-}
-
 Transport::Transport()
   : m_face(nullptr)
   , m_service(nullptr)
@@ -97,10 +89,11 @@ Transport::close()
 }
 
 void
-Transport::send(Packet&& packet)
+Transport::send(const Block& packet)
 {
+  BOOST_ASSERT(packet.isValid());
   BOOST_ASSERT(this->getMtu() == MTU_UNLIMITED ||
-               packet.packet.size() <= static_cast<size_t>(this->getMtu()));
+               packet.size() <= static_cast<size_t>(this->getMtu()));
 
   TransportState state = this->getState();
   if (state != TransportState::UP && state != TransportState::DOWN) {
@@ -110,22 +103,39 @@ Transport::send(Packet&& packet)
 
   if (state == TransportState::UP) {
     ++this->nOutPackets;
-    this->nOutBytes += packet.packet.size();
+    this->nOutBytes += packet.size();
   }
 
-  this->doSend(std::move(packet));
+  this->doSend(packet);
 }
 
 void
-Transport::receive(Packet&& packet)
+Transport::receive(const Block& packet, const EndpointId& endpoint)
 {
+  BOOST_ASSERT(packet.isValid());
   BOOST_ASSERT(this->getMtu() == MTU_UNLIMITED ||
-               packet.packet.size() <= static_cast<size_t>(this->getMtu()));
+               packet.size() <= static_cast<size_t>(this->getMtu()));
 
   ++this->nInPackets;
-  this->nInBytes += packet.packet.size();
+  this->nInBytes += packet.size();
 
-  m_service->receivePacket(std::move(packet));
+  m_service->receivePacket(packet, endpoint);
+}
+
+void
+Transport::setMtu(ssize_t mtu)
+{
+  BOOST_ASSERT(mtu == MTU_UNLIMITED || mtu >= 0);
+
+  if (mtu == m_mtu) {
+    return;
+  }
+
+  if (m_mtu != MTU_INVALID) {
+    NFD_LOG_FACE_INFO("setMtu " << m_mtu << " -> " << mtu);
+  }
+
+  m_mtu = mtu;
 }
 
 bool
@@ -201,7 +211,7 @@ Transport::setState(TransportState newState)
   }
 
   if (!isValid) {
-    BOOST_THROW_EXCEPTION(std::runtime_error("invalid state transition"));
+    NDN_THROW(std::runtime_error("Invalid state transition"));
   }
 
   NFD_LOG_FACE_INFO("setState " << m_state << " -> " << newState);

daemon/face/transport.hpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -26,18 +26,13 @@
 #ifndef NFD_DAEMON_FACE_TRANSPORT_HPP
 #define NFD_DAEMON_FACE_TRANSPORT_HPP
 
-#include "core/counter.hpp"
-#include "face-log.hpp"
-
-#include <ndn-cxx/encoding/nfd-constants.hpp>
+#include "face-common.hpp"
+#include "common/counter.hpp"
 
 namespace nfd {
 namespace face {
 
-class Face;
-class LinkService;
-
-/** \brief indicates the state of a transport
+/** \brief Indicates the state of a transport.
  */
 enum class TransportState {
   NONE,
@@ -51,9 +46,9 @@ enum class TransportState {
 std::ostream&
 operator<<(std::ostream& os, TransportState state);
 
-/** \brief counters provided by Transport
- *  \note The type name 'TransportCounters' is implementation detail.
- *        Use 'Transport::Counters' in public API.
+/** \brief Counters provided by a transport.
+ *  \note The type name TransportCounters is an implementation detail.
+ *        Use Transport::Counters in public API.
  */
 class TransportCounters
 {
@@ -107,47 +102,20 @@ const ssize_t QUEUE_UNSUPPORTED = -1;
  */
 const ssize_t QUEUE_ERROR = -2;
 
-/** \brief the lower part of a Face
+/** \brief The lower half of a Face.
  *  \sa Face
  */
 class Transport : protected virtual TransportCounters, noncopyable
 {
 public:
-  /** \brief identifies an endpoint on the link
+  /** \brief Counters provided by a transport.
+   *  \sa TransportCounters
    */
-  typedef uint64_t EndpointId;
+  using Counters = TransportCounters;
 
-  /** \brief stores a packet along with the remote endpoint
-   */
-  class Packet
-  {
-  public:
-    Packet() = default;
-
-    explicit
-    Packet(Block&& packet);
-
-  public:
-    /** \brief the packet as a TLV block
-     */
-    Block packet;
-
-    /** \brief identifies the remote endpoint
-     *
-     *  This ID is only meaningful in the context of the same Transport.
-     *  Incoming packets from the same remote endpoint have the same EndpointId,
-     *  and incoming packets from different remote endpoints have different EndpointIds.
-     */
-    EndpointId remoteEndpoint;
-  };
-
-  /** \brief counters provided by Transport
-   */
-  typedef TransportCounters Counters;
-
-  /** \brief constructor
+  /** \brief Default constructor.
    *
-   *  Transport constructor initializes static properties to invalid values.
+   *  This constructor initializes static properties to invalid values.
    *  Subclass constructor must explicitly set every static property.
    *
    *  This constructor initializes TransportState to UP;
@@ -184,7 +152,7 @@ public:
   getCounters() const;
 
 public: // upper interface
-  /** \brief request the transport to be closed
+  /** \brief Request the transport to be closed
    *
    *  This operation is effective only if transport is in UP or DOWN state,
    *  otherwise it has no effect.
@@ -195,12 +163,13 @@ public: // upper interface
   void
   close();
 
-  /** \brief send a link-layer packet
-   *  \note This operation has no effect if \p getState() is neither UP nor DOWN
-   *  \warning undefined behavior if packet size exceeds MTU limit
+  /** \brief Send a link-layer packet
+   *  \param packet the packet to be sent, must be a valid and well-formed TLV block
+   *  \note This operation has no effect if getState() is neither UP nor DOWN
+   *  \warning Behavior is undefined if packet size exceeds the MTU limit
    */
   void
-  send(Packet&& packet);
+  send(const Block& packet);
 
 public: // static properties
   /** \return a FaceUri representing local endpoint
@@ -239,7 +208,7 @@ public: // static properties
   void
   setPersistency(ndn::nfd::FacePersistency newPersistency);
 
-  /** \return whether face is point-to-point or multi-access
+  /** \return the link type of the transport
    */
   ndn::nfd::LinkType
   getLinkType() const;
@@ -290,11 +259,13 @@ public: // dynamic properties
   }
 
 protected: // upper interface to be invoked by subclass
-  /** \brief receive a link-layer packet
-   *  \warning undefined behavior if packet size exceeds MTU limit
+  /** \brief Pass a received link-layer packet to the upper layer for further processing
+   *  \param packet the received packet, must be a valid and well-formed TLV block
+   *  \param endpoint the source endpoint
+   *  \warning Behavior is undefined if packet size exceeds the MTU limit
    */
   void
-  receive(Packet&& packet);
+  receive(const Block& packet, const EndpointId& endpoint = 0);
 
 protected: // properties to be set by subclass
   void
@@ -360,18 +331,11 @@ protected: // to be overridden by subclass
 
 private: // to be overridden by subclass
   /** \brief performs Transport specific operations to send a packet
-   *  \param packet the packet, which must be a well-formed TLV block
-   *  \pre state is either UP or DOWN
+   *  \param packet the packet to be sent, can be assumed to be valid and well-formed
+   *  \pre transport state is either UP or DOWN
    */
   virtual void
-  doSend(Packet&& packet) = 0;
-
-public:
-  /** \brief minimum MTU that may be set on a transport
-   *
-   *  This is done to ensure the NDNLPv2 fragmentation feature functions properly.
-   */
-  static constexpr ssize_t MIN_MTU = 64;
+  doSend(const Block& packet) = 0;
 
 private:
   Face* m_face;
@@ -471,13 +435,6 @@ Transport::getMtu() const
   return m_mtu;
 }
 
-inline void
-Transport::setMtu(ssize_t mtu)
-{
-  BOOST_ASSERT(mtu == MTU_UNLIMITED || mtu > 0);
-  m_mtu = mtu;
-}
-
 inline ssize_t
 Transport::getSendQueueCapacity() const
 {

daemon/face/udp-channel.cpp

@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /*
- * Copyright (c) 2014-2018,  Regents of the University of California,
+ * Copyright (c) 2014-2020,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -24,9 +24,10 @@
  */
 
 #include "udp-channel.hpp"
+#include "face.hpp"
 #include "generic-link-service.hpp"
 #include "unicast-udp-transport.hpp"
-#include "core/global-io.hpp"
+#include "common/global.hpp"
 
 namespace nfd {
 namespace face {
@@ -169,7 +170,7 @@ UdpChannel::createFace(const udp::Endpoint& remoteEndpoint,
     options.allowCongestionMarking = m_wantCongestionMarking;
   }
   else {
-    options.allowCongestionMarking = params.wantCongestionMarking;
+    options.allowCongestionMarking = bool(params.wantCongestionMarking);
   }
 
   if (params.baseCongestionMarkingInterval) {
@@ -179,10 +180,19 @@ UdpChannel::createFace(const udp::Endpoint& remoteEndpoint,
     options.defaultCongestionThreshold = *params.defaultCongestionThreshold;
   }
 
+  if (params.mtu) {
+    options.overrideMtu = *params.mtu;
+  }
+
+  if (params.bandwidth) {
+    options.C = *params.bandwidth;
+  }
+
   auto linkService = make_unique<GenericLinkService>(options);
   auto transport = make_unique<UnicastUdpTransport>(std::move(socket), params.persistency,
-                                                    m_idleFaceTimeout, params.mtu);
+                                                    m_idleFaceTimeout);
   auto face = make_shared<Face>(std::move(linkService), std::move(transport));
+  face->setChannel(shared_from_this()); // use weak_from_this() in C++17
 
   m_channelFaces[remoteEndpoint] = face;
   connectFaceClosedSignal(*face, [this, remoteEndpoint] { m_channelFaces.erase(remoteEndpoint); });