Mirror/zeek
1
0
Fork 0
mirror of https://github.com/zeek/zeek.git synced 2025-10-02 14:48:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge remote-tracking branch 'origin/master' into topic/johanna/table-changes

Browse source 
* origin/master: (33 commits)
  Fix location where CI places build.tgz
  Update submodule(s)
  Disable some deprecation diagnostics for GCC
  Compare pcap_next_ex() result to PCAP_ERROR/PCAP_ERROR_BREAK
  Optimize Connection::RemovalEvent() for bare-mode usage
  Rename BroType to Type
  Update NEWS
  Review cleanup
  Move Type types to zeek namespace
  Review cleanup
  Restrict Cirrus CI to only zeek repo's branches
  GH-977: Improve pcap error handling
  Remove not-useful code in iosource::Manager::OpenPktSrc
  GH-999: Stop formatting DHCP Client ID Hardware Type 0 as MAC
  Remove inline from some static KeyedHash members
  Improve Func.h inclusion
  Fix NVT analyzer memory leak from multiple telnet authn name options
  Rename aux/ to auxil/
  Move Flare/Pipe from the bro namespace to zeek::detail
  Move Attr to the zeek::detail namespace
  ...
This commit is contained in:
Johanna Amann 2020-06-15 14:18:44 -07:00
commit c8a3a90339
324 changed files with 4779 additions and 3673 deletions
Download patch file Download diff file Expand all files Collapse all files

32
.cirrus.yml
View file

@ -3,7 +3,7 @@ btest_jobs: &BTEST_JOBS 4
btest_retries: &BTEST_RETRIES 2
memory: &MEMORY 4GB
config: &CONFIG --build-type=release --enable-cpp-tests --disable-broker-tests
config: &CONFIG --build-type=release --enable-cpp-tests --disable-broker-tests --prefix=$CIRRUS_WORKING_DIR/install
memcheck_config: &MEMCHECK_CONFIG --build-type=debug --enable-cpp-tests --disable-broker-tests --sanitizers=address --enable-fuzzers
resources_template: &RESOURCES_TEMPLATE
@ -13,8 +13,12 @@ resources_template: &RESOURCES_TEMPLATE
ci_template: &CI_TEMPLATE
only_if: >
$CIRRUS_PR != '' ||
$CIRRUS_BRANCH == 'master' ||
$CIRRUS_BRANCH =~ 'release/.*'
( $CIRRUS_REPO_NAME == 'zeek' &&
(
$CIRRUS_BRANCH == 'master' ||
$CIRRUS_BRANCH =~ 'release/.*'
)
)
# Default timeout is 60 minutes, Cirrus hard limit is 120 minutes for free
# tasks, so may as well ask for full time.
@ -53,6 +57,16 @@ env:
# the zeek-testing-private repository.
ZEEK_TESTING_PRIVATE_SSH_KEY: ENCRYPTED[!dbdba93df9c166f926480cebff52dab303589257b3b3ee53aa392021aff2881ed9aafefef26aa9a1b71a49d663d1361c!]
# This is the key used to create HMAC auth keys for the benchmark script. This
# was generated by creating a new key using openssl, and then running sha256
# on it.
ZEEK_BENCHMARK_HMAC_KEY: ENCRYPTED[412224bbea9652030da976537f4d96c79ee79a0ba5a2f93b6c32953e1be0362defdf5fa07b3dc54ae61f9a52be30eac7]
# This is the https endpoint host and port used for benchmarking. It's kept
# encrypted as a security measure to avoid leaking the host's information.
ZEEK_BENCHMARK_HOST: ENCRYPTED[62ecdc93e839800d754d09d9a9070e9cb9b209e7d7dd2472ba38648f786ff272d0e0ea71233d0910025f2c6f3771259c]
ZEEK_BENCHMARK_PORT: ENCRYPTED[fb34ae2d51bac798fc01da052f3772154e17bbe2c1c5615509e82935248e748053fda399a0caf909632b6272cebff9f4]
# Linux EOL timelines: https://linuxlifecycle.com/
# Fedora (~13 months): https://fedoraproject.org/wiki/Fedora_Release_Life_Cycle
@ -70,6 +84,18 @@ centos7_task:
<< : *RESOURCES_TEMPLATE
<< : *CI_TEMPLATE
centos8_task:
container:
# CentOS 8 EOL: May 31, 2029
dockerfile: ci/centos-8/Dockerfile
<< : *RESOURCES_TEMPLATE
env:
ZEEK_CI_CREATE_ARTIFACT: 1
<< : *CI_TEMPLATE
upload_binary_artifacts:
path: build.tgz
benchmark_script: ./ci/benchmark.sh
debian9_task:
container:
# Debian 9 EOL: June 2022

44
.gitmodules vendored
View file

@ -1,14 +1,14 @@
[submodule "aux/zeek-aux"]
path = aux/zeek-aux
[submodule "auxil/zeek-aux"]
path = auxil/zeek-aux
url = https://github.com/zeek/zeek-aux
[submodule "aux/binpac"]
path = aux/binpac
[submodule "auxil/binpac"]
path = auxil/binpac
url = https://github.com/zeek/binpac
[submodule "aux/zeekctl"]
path = aux/zeekctl
[submodule "auxil/zeekctl"]
path = auxil/zeekctl
url = https://github.com/zeek/zeekctl
[submodule "aux/btest"]
path = aux/btest
[submodule "auxil/btest"]
path = auxil/btest
url = https://github.com/zeek/btest
[submodule "cmake"]
path = cmake
@ -16,27 +16,27 @@
[submodule "src/3rdparty"]
path = src/3rdparty
url = https://github.com/zeek/zeek-3rdparty
[submodule "aux/broker"]
path = aux/broker
[submodule "auxil/broker"]
path = auxil/broker
url = https://github.com/zeek/broker
[submodule "aux/netcontrol-connectors"]
path = aux/netcontrol-connectors
[submodule "auxil/netcontrol-connectors"]
path = auxil/netcontrol-connectors
url = https://github.com/zeek/zeek-netcontrol
[submodule "aux/bifcl"]
path = aux/bifcl
[submodule "auxil/bifcl"]
path = auxil/bifcl
url = https://github.com/zeek/bifcl
[submodule "doc"]
path = doc
url = https://github.com/zeek/zeek-docs
[submodule "aux/paraglob"]
path = aux/paraglob
[submodule "auxil/paraglob"]
path = auxil/paraglob
url = https://github.com/zeek/paraglob
[submodule "aux/rapidjson"]
path = aux/rapidjson
[submodule "auxil/rapidjson"]
path = auxil/rapidjson
url = https://github.com/zeek/rapidjson
[submodule "aux/libkqueue"]
path = aux/libkqueue
[submodule "auxil/libkqueue"]
path = auxil/libkqueue
url = https://github.com/zeek/libkqueue
[submodule "aux/highwayhash"]
path = aux/highwayhash
[submodule "auxil/highwayhash"]
path = auxil/highwayhash
url = https://github.com/zeek/highwayhash

131
CHANGES
View file

@ -1,4 +1,135 @@
3.2.0-dev.788 | 2020-06-15 11:04:20 -0700
* Fix location where CI places build.tgz (Jon Siwek, Corelight)
3.2.0-dev.787 | 2020-06-15 10:27:48 -0700
* Add new CI task for running benchmarks on a remote host (Tim Wojtulewicz, Corelight)
3.2.0-dev.783 | 2020-06-11 23:21:41 -0700
* Compare pcap_next_ex() result to PCAP_ERROR/PCAP_ERROR_BREAK (Jon Siwek, Corelight)
* GH-977: Improve pcap error handling (Jon Siwek, Corelight)
Switches from pcap_next() to pcap_next_ex() to better handle all error
conditions. This allows, for example, to have a non-zero exit code for
a Zeek process that fails to fully process all packets in a pcap file.
* Remove not-useful code in iosource::Manager::OpenPktSrc (Jon Siwek, Corelight)
3.2.0-dev.779 | 2020-06-11 23:17:46 -0700
* Rename BroType to zeek::Type (Tim Wojtulewicz, Corelight)
* Move Type types to zeek namespace (Tim Wojtulewicz, Corelight)
* Move Flare/Pipe from the bro namespace to zeek::detail (Tim Wojtulewicz, Corelight)
* Move Attr to the zeek::detail namespace (Tim Wojtulewicz, Corelight)
* Move Trigger into the zeek::detail namespace (Tim Wojtulewicz, Corelight)
* Move ID to the zeek::detail namespace (Tim Wojtulewicz, Corelight)
* Move Anon.h into zeek::detail namespace (Tim Wojtulewicz, Corelight)
* Mark all of the aliased classes in plugin/Plugin.h deprecated (Tim Wojtulewicz, Corelight)
And fix all of the plugins that were using them
* Move all of the base plugin classes into the zeek::plugin namespace (Tim Wojtulewicz, Corelight)
* Expr: move all classes into zeek::detail (Tim Wojtulewicz, Corelight)
* Stmt: move Stmt classes into zeek::detail namespace (Tim Wojtulewicz, Corelight)
* Add utility macro for creating namespaced aliases for classes (Tim Wojtulewicz, Corelight)
3.2.0-dev.763 | 2020-06-10 16:34:31 -0700
* Optimize Connection::RemovalEvent() for bare-mode usage (Jon Siwek, Corelight)
It was creating RecordVals even if they wouldn't be used by any event
handler and that situation is common/expected for `zeek -b` mode.
Normally, there's at least the tunnel scripts with a `new_connection`
handler causing the connection RecordVals to be built.
3.2.0-dev.762 | 2020-06-09 15:19:15 -0700
* Restrict Cirrus CI to only zeek repo's branches (Jon Siwek, Corelight)
3.2.0-dev.761 | 2020-06-09 09:39:31 -0700
* Prevent IP fragment reassembly on packets without minimal IP header (Jon Siwek, Corelight)
The IP fragment reassembly process assumes a packet contains at least
the minimum IP header, but such a check did not previously occur,
resulting in a heap buffer over-read. For example, a self-reported
IPv4 IHL field with a value less than minimum IPv4 header length of
20 bytes. Such packets likely aren't routable on their own, but one
can create an artifical pcap like that or possibly encapsulate it
within another protocol to trigger this bug.
* Fix potential leak of Analyzers added to tree during Analyzer::Done (Jon Siwek, Corelight)
Credit to OSS-Fuzz for discovery
https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=22630
* Fix multiple content-transfer-encoding headers causing a memory leak (Jon Siwek, Corelight)
The MIME analyzer may also leak if it sees many multipart boundary
parameters.
Credit to OSS-Fuzz for discovery
https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=22871
* Fix potential stack overflow in NVT analyzer (Jon Siwek, Corelight)
The NVT_Analyzer (e.g. as instantiated to support the FTP analyzer)
uses a recursive parsing function that may only advance one byte at a
time and can easily cause a stack overflow as a result. This change
replaces the recursive calls with equivalent iterative logic.
Credit to OSS-Fuzz for discovery
https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=22898
https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=22972
* Fix NVT analyzer memory leak from multiple telnet authn name options (Jon Siwek, Corelight)
Credit to OSS-Fuzz for discovery
https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=23069
3.2.0-dev.751 | 2020-06-08 22:30:18 +0000
* GH-999: Stop formatting DHCP Client ID Hardware Type 0 as MAC
For `DHCP::ClientID$hwtype` fields equal to 0, the `hwaddr` field is
no longer misformatted as a MAC and instead just contains the raw bytes
seen in the DHCP Client ID Option. (Jon Siwek, Corelight)
3.2.0-dev.749 | 2020-06-08 11:22:45 -0700
* Remove inline from some static KeyedHash members (Jon Siwek, Corelight)
Coverity Scan builds currently encounter catastrophic error, claiming
alignas requires use on both declaration and definition, so appears to
actually not understand "static inline" in combo with alignas.
* Improve Func.h inclusion (Jon Siwek, Corelight)
Now forward declares some Broker types since Broker/CAF headers
generally slow things down and also Coverity Scan currently has a
catastrophic error on some CAF headers.
Also a few other changes to EventHandler/BifReturnVal to reduce number
of places that depend on Func.h.
* Rename aux/ to auxil/ (Jon Siwek, Corelight)
Since "aux" is not an allowed file/dir name on Windows.
3.2.0-dev.744 | 2020-06-04 15:11:56 -0700
* Fix use-after-move of proc_status_file breaking -U flag (Jon Siwek, Corelight)

28
CMakeLists.txt
View file

@ -1,5 +1,5 @@
# When changing the minimum version here, also adapt
# aux/zeek-aux/plugin-support/skeleton/CMakeLists.txt
# auxil/zeek-aux/plugin-support/skeleton/CMakeLists.txt
cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
project(Zeek C CXX)
@ -186,7 +186,7 @@ FindRequiredPackage(OpenSSL)
FindRequiredPackage(BIND)
FindRequiredPackage(ZLIB)
if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/aux/binpac/CMakeLists.txt)
if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/auxil/binpac/CMakeLists.txt)
set(ENABLE_STATIC_ONLY_SAVED ${ENABLE_STATIC_ONLY})
@ -194,13 +194,13 @@ if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/aux/binpac/CMakeLists.txt)
set(ENABLE_STATIC_ONLY true)
endif()
add_subdirectory(aux/binpac)
add_subdirectory(auxil/binpac)
set(ENABLE_STATIC_ONLY ${ENABLE_STATIC_ONLY_SAVED})
endif ()
FindRequiredPackage(BinPAC)
if ( NOT BIFCL_EXE_PATH )
add_subdirectory(aux/bifcl)
add_subdirectory(auxil/bifcl)
endif ()
if (ENABLE_JEMALLOC)
@ -228,7 +228,7 @@ if ( CAF_ROOT_DIR )
find_package(CAF COMPONENTS core io openssl REQUIRED)
endif ()
add_subdirectory(aux/paraglob)
add_subdirectory(auxil/paraglob)
set(zeekdeps ${zeekdeps} paraglob)
if ( BROKER_ROOT_DIR )
@ -250,7 +250,7 @@ else ()
set(ENABLE_STATIC_ONLY true)
endif()
add_subdirectory(aux/broker)
add_subdirectory(auxil/broker)
set(ENABLE_STATIC_ONLY ${ENABLE_STATIC_ONLY_SAVED})
if ( BUILD_STATIC_BROKER )
@ -258,17 +258,17 @@ else ()
else()
set(zeekdeps ${zeekdeps} broker)
endif()
set(broker_includes ${CMAKE_CURRENT_SOURCE_DIR}/aux/broker/include ${CMAKE_CURRENT_BINARY_DIR}/aux/broker/include)
set(broker_includes ${CMAKE_CURRENT_SOURCE_DIR}/auxil/broker/include ${CMAKE_CURRENT_BINARY_DIR}/auxil/broker/include)
endif ()
# CAF_LIBRARIES and CAF_INCLUDE_DIRS are defined either by calling
# find_package(CAF) or by calling add_subdirectory(aux/broker). In either case,
# find_package(CAF) or by calling add_subdirectory(auxil/broker). In either case,
# we have to care about CAF here because Broker headers can pull in CAF
# headers.
set(zeekdeps ${zeekdeps} ${CAF_LIBRARIES})
include_directories(BEFORE ${broker_includes} ${CAF_INCLUDE_DIRS})
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/aux/paraglob/include)
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/aux/rapidjson/include)
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/auxil/paraglob/include)
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/auxil/rapidjson/include)
include_directories(BEFORE
${PCAP_INCLUDE_DIR}
${BIND_INCLUDE_DIR}
@ -277,7 +277,7 @@ include_directories(BEFORE
${JEMALLOC_INCLUDE_DIR}
)
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/aux/rapidjson/include/rapidjson
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/auxil/rapidjson/include/rapidjson
DESTINATION include/zeek/3rdparty/rapidjson/include)
# Optional Dependencies
@ -332,7 +332,7 @@ endif ()
include_directories(BEFORE ${OPENSSL_INCLUDE_DIR})
# Make everyone find the highwayhash includes
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/aux/highwayhash)
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/auxil/highwayhash)
# Alpine support
if ( ${CMAKE_SYSTEM_NAME} MATCHES Linux AND EXISTS /etc/os-release )
@ -437,8 +437,8 @@ add_subdirectory(man)
include(CheckOptionalBuildSources)
CheckOptionalBuildSources(aux/zeekctl ZeekControl INSTALL_ZEEKCTL)
CheckOptionalBuildSources(aux/zeek-aux Zeek-Aux INSTALL_AUX_TOOLS)
CheckOptionalBuildSources(auxil/zeekctl ZeekControl INSTALL_ZEEKCTL)
CheckOptionalBuildSources(auxil/zeek-aux Zeek-Aux INSTALL_AUX_TOOLS)
########################################################################
## Packaging Setup

2
COPYING.3rdparty
View file

@ -500,7 +500,7 @@ POSSIBILITY OF SUCH DAMAGE.
==============================================================================
%%% aux/highwayhash
%%% auxil/highwayhash
==============================================================================

10
Makefile
View file

@ -42,7 +42,7 @@ dist:
@tar -czf $(VERSION_FULL).tar.gz $(VERSION_FULL)
@echo Package: $(VERSION_FULL).tar.gz
@mv $(VERSION_FULL) $(VERSION_MIN)
@(cd $(VERSION_MIN) && for i in aux/*; do rm -rf $$i/*; done)
@(cd $(VERSION_MIN) && for i in auxil/*; do rm -rf $$i/*; done)
@tar -czf $(VERSION_MIN).tar.gz $(VERSION_MIN)
@echo Package: $(VERSION_MIN).tar.gz
@rm -rf $(VERSION_MIN)
@ -55,10 +55,10 @@ test:
-@( cd testing && make )
test-aux:
-test -d aux/zeekctl && ( cd aux/zeekctl && make test-all )
-test -d aux/btest && ( cd aux/btest && make test )
-test -d aux/zeek-aux && ( cd aux/zeek-aux && make test )
-test -d aux/plugins && ( cd aux/plugins && make test-all )
-test -d auxil/zeekctl && ( cd auxil/zeekctl && make test-all )
-test -d auxil/btest && ( cd auxil/btest && make test )
-test -d auxil/zeek-aux && ( cd auxil/zeek-aux && make test )
-test -d auxil/plugins && ( cd auxil/plugins && make test-all )
test-all: test test-aux

14
NEWS
View file

@ -107,6 +107,14 @@ Changed Functionality
- ``Attributes::Attrs()`` now returns ``const std::vector<IntrusivePtr<Attr>>&``
instead of ``attr_list*``
- Moved a large number of classes from the global namespace into either the
``zeek`` or ``zeek::detail`` namespace. See https://github.com/zeek/zeek/issues/266
for the rationale behind these changes. Most types that were moved and functions
that used them have been marked as deprecated and will generate compiler
warnings if used (a few exceptions will not generate compiler warnings,
but the Deprecated Functionality section below will mention those
ones specifically).
Removed Functionality
---------------------
@ -124,6 +132,12 @@ Deprecated Functionality
method to now use is called ``HookFunctionCall`` and uses ``IntrusivePtr``
arguments and return value.
- The ``plugin::Plugin::MetaHookPre()`` and ``MetaHookPost()`` methods are
deprecated. Note that compilers will not emit a deprecation warning, but
the replacement methods are named the same except use
``zeek::plugin::HookType`` arguments (the type is now from the "zeek"
namespace).
- The ``Func::Call(val_list*, ...)`` method is now deprecated. Use ``Invoke()``
instead which takes a ``zeek::Args`` (``std::vector<IntrusivePtr<Val>>``).
There's also a variadic template for ``Invoke()`` that forwards all arguments

2
VERSION
View file

@ -1 +1 @@
3.2.0-dev.744
3.2.0-dev.788

1
aux/bifcl

@ -1 +0,0 @@
Subproject commit 7d474ff6ac0ff1870eef6159bef93a1bfed953df

1
aux/broker

@ -1 +0,0 @@
Subproject commit 8bba3c45c85d99752dc6f8da9b40b768e3c39804

1
aux/zeek-aux

@ -1 +0,0 @@
Subproject commit 8615abced86b5559fa3203264be55e664b887094

1
aux/zeekctl

@ -1 +0,0 @@
Subproject commit bee11c63923b69a4468838d56067f15bc6ae3a52

1
auxil/bifcl Submodule

@ -0,0 +1 @@
Subproject commit 9c10bb74bb62aa7fb10efc079f1b2e5926e9798c

0
aux/binpac → auxil/binpac
View file

1
auxil/broker Submodule

@ -0,0 +1 @@
Subproject commit 1db381f1d145164db6c9ce1025833e6a2c0b2b8f

0
aux/btest → auxil/btest
View file

0
aux/highwayhash → auxil/highwayhash
View file

0
aux/libkqueue → auxil/libkqueue
View file

0
aux/netcontrol-connectors → auxil/netcontrol-connectors
View file

0
aux/paraglob → auxil/paraglob
View file

0
aux/rapidjson → auxil/rapidjson
View file

1
auxil/zeek-aux Submodule

@ -0,0 +1 @@
Subproject commit 131e9fb1184af9da29745b5fb27d4cd59fc6825d

1
auxil/zeekctl Submodule

@ -0,0 +1 @@
Subproject commit 6e39564420c47b3fd6d03d4383758d7871bc87bf

43
ci/benchmark.sh Executable file
View file

@ -0,0 +1,43 @@
#! /usr/bin/env bash
ZEEK_BENCHMARK_ENDPOINT="/zeek"
# Setting this causes any command failures to immediately cause the script to fail.
set -e
# Don't do this for any branch that isn't from the main zeek repo.
# TODO: is it possible to do this from cirrus.yml instead of here?
if [ "${CIRRUS_REPO_OWNER}" != "zeek" ]; then
echo "Benchmarks are skipped for repositories outside of the main Zeek project"
exit 0
fi
BUILD_URL="https://api.cirrus-ci.com/v1/artifact/build/${CIRRUS_BUILD_ID}/${CIRRUS_TASK_NAME}/upload_binary/build.tgz"
# Generate an md5 hash of the build file. We can do this here because the path to the
# file still exists from the prior scripts.
BUILD_HASH=$(sha256sum build.tgz | awk '{print $1}')
# Generate an HMAC digest for the path plus a timestamp to send as an authentication
# header. Openssl outputs a hex string here so there's no need to base64 encode it.
TIMESTAMP=$(date -u +'%s')
HMAC_DIGEST=$(echo "${ZEEK_BENCHMARK_ENDPOINT}-${TIMESTAMP}-${BUILD_HASH}" | openssl dgst -sha256 -hmac ${ZEEK_BENCHMARK_HMAC_KEY} | awk '{print $2}')
TARGET="https://${ZEEK_BENCHMARK_HOST}:${ZEEK_BENCHMARK_PORT}${ZEEK_BENCHMARK_ENDPOINT}"
# Turn this back off because we want to be able to capture the output from curl if
# it fails.
set +e
# Make a request to the benchmark host.
RESULTS=$(curl -sS --stderr - --fail --insecure -X POST -H "Zeek-HMAC: ${HMAC_DIGEST}" -H "Zeek-HMAC-Timestamp: ${TIMESTAMP}" "${TARGET}?branch=${CIRRUS_BRANCH}&build=${BUILD_URL}&build_hash=${BUILD_HASH}")
STATUS=$?
# If we got a bad status back from the host, we want to make sure to mask the host
# and port from the output.
if [ $STATUS -ne 0 ]; then
RESULTS=$(echo "${RESULTS}" | sed "s/${ZEEK_BENCHMARK_HOST}/<secret>/g" | sed "s/:${ZEEK_BENCHMARK_PORT}/:<secret>/g")
fi
echo "$RESULTS"
exit $STATUS

14
ci/build.sh
View file

@ -3,6 +3,14 @@
set -e
set -x
./configure ${ZEEK_CI_CONFIGURE_FLAGS}
cd build
make -j ${ZEEK_CI_CPUS}
if [ "${ZEEK_CI_CREATE_ARTIFACT}" != "1" ]; then
./configure ${ZEEK_CI_CONFIGURE_FLAGS}
cd build
make -j ${ZEEK_CI_CPUS}
else
./configure ${ZEEK_CI_CONFIGURE_FLAGS} --prefix=${CIRRUS_WORKING_DIR}/install
cd build
make -j ${ZEEK_CI_CPUS} install
cd ..
tar -czf build.tgz ${CIRRUS_WORKING_DIR}/install
fi

35
ci/centos-8/Dockerfile Normal file
View file

@ -0,0 +1,35 @@
FROM centos:8
RUN dnf -y install epel-release dnf-plugins-core \
&& dnf clean all && rm -rf /var/cache/dnf
RUN dnf config-manager --set-enabled PowerTools
RUN dnf -y update && dnf -y install \
git \
cmake3 \
make \
gcc \
gcc-c++ \
flex \
bison \
swig \
openssl \
openssl-devel \
libpcap-devel \
python3 \
python3-devel \
python3-pip \
zlib-devel \
libsqlite3x-devel \
findutils \
which \
&& dnf clean all && rm -rf /var/cache/dnf
# Many distros adhere to PEP 394's recommendation for `python` = `python2` so
# this is a simple workaround until we drop Python 2 support and explicitly
# use `python3` for all invocations (e.g. in shebangs).
RUN ln -sf /usr/bin/python3 /usr/local/bin/python
RUN ln -sf /usr/bin/pip3 /usr/local/bin/pip
RUN pip install junit2html

2
ci/test.sh
View file

@ -5,7 +5,7 @@
# the value of `nproc` if available, otherwise just a single core.
result=0
BTEST=$(pwd)/aux/btest/btest
BTEST=$(pwd)/auxil/btest/btest
if [[ -z "${CIRRUS_CI}" ]]; then
# Set default values to use in place of env. variables set by Cirrus CI.

2
cmake

@ -1 +1 @@
Subproject commit 23f4b88f91c537c59ef9a3ad56ec08f021ec2b2c
Subproject commit 6cb83a5a4a41adb7f7a5cc97661088caaa863180

2
doc

@ -1 +1 @@
Subproject commit 23dbe360d105d1ffadc231b1d9fb06dea437b110
Subproject commit 60546010f9d0e5858b79e01a2982cd6c5b64323b

12
src/Anon.cc
View file

@ -14,7 +14,9 @@
#include "ID.h"
#include "IPAddr.h"
AnonymizeIPAddr* ip_anonymizer[NUM_ADDR_ANONYMIZATION_METHODS] = {nullptr};
using namespace zeek::detail;
AnonymizeIPAddr* zeek::detail::ip_anonymizer[NUM_ADDR_ANONYMIZATION_METHODS] = {nullptr};
static uint32_t rand32()
{
@ -22,7 +24,7 @@ static uint32_t rand32()
}
// From tcpdpriv.
int bi_ffs(uint32_t value)
static int bi_ffs(uint32_t value)
{
int add = 0;
static uint8_t bvals[] = {
@ -360,7 +362,7 @@ static IntrusivePtr<TableVal> anon_preserve_orig_addr;
static IntrusivePtr<TableVal> anon_preserve_resp_addr;
static IntrusivePtr<TableVal> anon_preserve_other_addr;
void init_ip_addr_anonymizers()
void zeek::detail::init_ip_addr_anonymizers()
{
ip_anonymizer[KEEP_ORIG_ADDR] = nullptr;
ip_anonymizer[SEQUENTIALLY_NUMBERED] = new AnonymizeIPAddr_Seq();
@ -384,7 +386,7 @@ void init_ip_addr_anonymizers()
anon_preserve_other_addr = cast_intrusive<TableVal>(id->GetVal());
}
ipaddr32_t anonymize_ip(ipaddr32_t ip, enum ip_addr_anonymization_class_t cl)
ipaddr32_t zeek::detail::anonymize_ip(ipaddr32_t ip, enum ip_addr_anonymization_class_t cl)
{
TableVal* preserve_addr = nullptr;
auto addr = make_intrusive<AddrVal>(ip);
@ -439,7 +441,7 @@ ipaddr32_t anonymize_ip(ipaddr32_t ip, enum ip_addr_anonymization_class_t cl)
#include "NetVar.h"
#include "Event.h"
void log_anonymization_mapping(ipaddr32_t input, ipaddr32_t output)
void zeek::detail::log_anonymization_mapping(ipaddr32_t input, ipaddr32_t output)
{
if ( anonymization_mapping )
mgr.Enqueue(anonymization_mapping,

4
src/Anon.h
View file

@ -14,6 +14,8 @@
#include <map>
#include <cstdint>
namespace zeek::detail {
// TODO: Anon.h may not be the right place to put these functions ...
enum ip_addr_anonymization_class_t {
@ -126,3 +128,5 @@ ipaddr32_t anonymize_ip(ipaddr32_t ip, enum ip_addr_anonymization_class_t cl);
#define LOG_ANONYMIZATION_MAPPING
void log_anonymization_mapping(ipaddr32_t input, ipaddr32_t output);
}

36
src/Attr.cc
View file

@ -9,6 +9,8 @@
#include "IntrusivePtr.h"
#include "threading/SerialTypes.h"
namespace zeek::detail {
const char* attr_name(attr_tag t)
{
static const char* attr_names[int(NUM_ATTRS)] = {
@ -36,9 +38,20 @@ Attr::Attr(attr_tag t)
{
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
Attr::Attr(::attr_tag t, IntrusivePtr<Expr> e) : Attr(static_cast<attr_tag>(t), e)
{
}
Attr::Attr(::attr_tag t) : Attr(static_cast<attr_tag>(t))
{
}
#pragma GCC diagnostic pop
Attr::~Attr() = default;
void Attr::SetAttrExpr(IntrusivePtr<Expr> e)
void Attr::SetAttrExpr(IntrusivePtr<zeek::detail::Expr> e)
{ expr = std::move(e); }
void Attr::Describe(ODesc* d) const
@ -137,7 +150,7 @@ void Attr::AddTag(ODesc* d) const
d->Add(attr_name(Tag()));
}
Attributes::Attributes(attr_list* a, IntrusivePtr<BroType> t, bool arg_in_record, bool is_global)
Attributes::Attributes(attr_list* a, IntrusivePtr<Type> t, bool arg_in_record, bool is_global)
{
attrs.reserve(a->length());
in_record = arg_in_record;
@ -155,14 +168,14 @@ Attributes::Attributes(attr_list* a, IntrusivePtr<BroType> t, bool arg_in_record
delete a;
}
Attributes::Attributes(IntrusivePtr<BroType> t,
Attributes::Attributes(IntrusivePtr<Type> t,
bool arg_in_record, bool is_global)
: Attributes(std::vector<IntrusivePtr<Attr>>{}, std::move(t),
arg_in_record, is_global)
{}
Attributes::Attributes(std::vector<IntrusivePtr<Attr>> a,
IntrusivePtr<BroType> t,
IntrusivePtr<Type> t,
bool arg_in_record, bool is_global)
: type(std::move(t))
{
@ -245,6 +258,19 @@ void Attributes::RemoveAttr(attr_tag t)
}
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
Attr* Attributes::FindAttr(::attr_tag t) const
{
return FindAttr(static_cast<attr_tag>(t));
}
void Attributes::RemoveAttr(::attr_tag t)
{
RemoveAttr(static_cast<attr_tag>(t));
}
#pragma GCC diagnostic pop
void Attributes::Describe(ODesc* d) const
{
if ( attrs.empty() )
@ -686,3 +712,5 @@ bool Attributes::operator==(const Attributes& other) const
return true;
}
}

74
src/Attr.h
View file

@ -8,13 +8,13 @@
#include "BroList.h"
#include "IntrusivePtr.h"
class Expr;
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
// Note that there are two kinds of attributes: the kind (here) which
// modify expressions or supply metadata on types, and the kind that
// are extra metadata on every variable instance.
typedef enum {
enum [[deprecated("Remove in v4.1. Use zeek::detail::attr_tag instead.")]] attr_tag {
ATTR_OPTIONAL,
ATTR_DEFAULT,
ATTR_REDEF,
@ -34,26 +34,61 @@ typedef enum {
ATTR_ON_CHANGE, // for table change tracking
ATTR_BROKER_STORE, // for broker-store backed tables
ATTR_DEPRECATED,
#define NUM_ATTRS (int(ATTR_DEPRECATED) + 1)
} attr_tag;
NUM_ATTRS // this item should always be last
};
namespace zeek::detail {
enum attr_tag {
ATTR_OPTIONAL,
ATTR_DEFAULT,
ATTR_REDEF,
ATTR_ADD_FUNC,
ATTR_DEL_FUNC,
ATTR_EXPIRE_FUNC,
ATTR_EXPIRE_READ,
ATTR_EXPIRE_WRITE,
ATTR_EXPIRE_CREATE,
ATTR_RAW_OUTPUT,
ATTR_PRIORITY,
ATTR_GROUP,
ATTR_LOG,
ATTR_ERROR_HANDLER,
ATTR_TYPE_COLUMN, // for input framework
ATTR_TRACKED, // hidden attribute, tracked by NotifierRegistry
ATTR_ON_CHANGE, // for table change tracking
ATTR_BROKER_STORE, // for broker-store backed tables
ATTR_DEPRECATED,
NUM_ATTRS // this item should always be last
};
class Attr final : public BroObj {
public:
static inline const IntrusivePtr<Attr> nil;
static inline const IntrusivePtr<zeek::detail::Attr> nil;
Attr(attr_tag t, IntrusivePtr<Expr> e);
Attr(attr_tag t, IntrusivePtr<zeek::detail::Expr> e);
explicit Attr(attr_tag t);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
[[deprecated("Remove in v4.1. Use version that takes zeek::detail::attr_tag.")]]
Attr(::attr_tag t, IntrusivePtr<zeek::detail::Expr> e);
[[deprecated("Remove in v4.1. Use version that takes zeek::detail::attr_tag.")]]
explicit Attr(::attr_tag t);
#pragma GCC diagnostic pop
~Attr() override;
attr_tag Tag() const { return tag; }
[[deprecated("Remove in v4.1. Use GetExpr().")]]
Expr* AttrExpr() const { return expr.get(); }
zeek::detail::Expr* AttrExpr() const { return expr.get(); }
const IntrusivePtr<Expr>& GetExpr() const
const IntrusivePtr<zeek::detail::Expr>& GetExpr() const
{ return expr; }
void SetAttrExpr(IntrusivePtr<Expr> e);
void SetAttrExpr(IntrusivePtr<zeek::detail::Expr> e);
void Describe(ODesc* d) const override;
void DescribeReST(ODesc* d, bool shorten = false) const;
@ -83,11 +118,11 @@ protected:
class Attributes final : public BroObj {
public:
[[deprecated("Remove in v4.1. Construct using IntrusivePtrs instead.")]]
Attributes(attr_list* a, IntrusivePtr<BroType> t, bool in_record, bool is_global);
Attributes(attr_list* a, IntrusivePtr<Type> t, bool in_record, bool is_global);
Attributes(std::vector<IntrusivePtr<Attr>> a, IntrusivePtr<BroType> t,
Attributes(std::vector<IntrusivePtr<Attr>> a, IntrusivePtr<Type> t,
bool in_record, bool is_global);
Attributes(IntrusivePtr<BroType> t, bool in_record, bool is_global);
Attributes(IntrusivePtr<Type> t, bool in_record, bool is_global);
void AddAttr(IntrusivePtr<Attr> a);
@ -103,6 +138,14 @@ public:
void RemoveAttr(attr_tag t);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
[[deprecated("Remove in v4.1. Use version that takes zeek::detail::attr_tag.")]]
Attr* FindAttr(::attr_tag t) const;
[[deprecated("Remove in v4.1. Use version that takes zeek::detail::attr_tag.")]]
void RemoveAttr(::attr_tag t);
#pragma GCC diagnostic pop
void Describe(ODesc* d) const override;
void DescribeReST(ODesc* d, bool shorten = false) const;
@ -114,8 +157,13 @@ public:
protected:
void CheckAttr(Attr* attr);
IntrusivePtr<BroType> type;
IntrusivePtr<Type> type;
std::vector<IntrusivePtr<Attr>> attrs;
bool in_record;
bool global_var;
};
}
using Attr [[deprecated("Remove in v4.1. Use zeek::detail::Attr instead.")]] = zeek::detail::Attr;
using Attributes [[deprecated("Remove in v4.1. Use zeek::detail::Attr instead.")]] = zeek::detail::Attributes;

11
src/BifReturnVal.cc Normal file
View file

@ -0,0 +1,11 @@
// See the file "COPYING" in the main distribution directory for copyright.
#include "BifReturnVal.h"
#include "Val.h"
BifReturnVal::BifReturnVal(std::nullptr_t) noexcept
{}
BifReturnVal::BifReturnVal(Val* v) noexcept
: rval(AdoptRef{}, v)
{}

28
src/BifReturnVal.h Normal file
View file

@ -0,0 +1,28 @@
// See the file "COPYING" in the main distribution directory for copyright.
#pragma once
#include "IntrusivePtr.h"
class Val;
/**
* A simple wrapper class to use for the return value of BIFs so that
* they may return either a Val* or IntrusivePtr<Val> (the former could
* potentially be deprecated).
*/
class BifReturnVal {
public:
template <typename T>
BifReturnVal(IntrusivePtr<T> v) noexcept
: rval(AdoptRef{}, v.release())
{ }
BifReturnVal(std::nullptr_t) noexcept;
[[deprecated("Remove in v4.1. Return an IntrusivePtr instead.")]]
BifReturnVal(Val* v) noexcept;
IntrusivePtr<Val> rval;
};

29
src/BroList.h
View file

@ -4,23 +4,24 @@
#include "List.h"
class Expr;
typedef PList<Expr> expr_list;
class ID;
typedef PList<ID> id_list;
class Val;
typedef PList<Val> val_list;
using val_list = PList<Val>;
class Stmt;
typedef PList<Stmt> stmt_list;
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
using expr_list = PList<zeek::detail::Expr>;
class BroType;
typedef PList<BroType> type_list;
ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
using id_list = PList<zeek::detail::ID>;
class Attr;
typedef PList<Attr> attr_list;
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
using stmt_list = PList<zeek::detail::Stmt>;
namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
using type_list = PList<zeek::Type>;
ZEEK_FORWARD_DECLARE_NAMESPACED(Attr, zeek::detail);
using attr_list = PList<zeek::detail::Attr>;
class Timer;
typedef PList<Timer, ListOrder::UNORDERED> timer_list;
using timer_list = PList<Timer, ListOrder::UNORDERED>;

5
src/Brofiler.cc
View file

@ -26,7 +26,7 @@ Brofiler::~Brofiler()
Unref(s);
}
void Brofiler::AddStmt(Stmt* s)
void Brofiler::AddStmt(zeek::detail::Stmt* s)
{
if ( ignoring != 0 )
return;
@ -127,7 +127,7 @@ bool Brofiler::WriteStats()
return false;
}
for ( list<Stmt*>::const_iterator it = stmts.begin();
for ( list<zeek::detail::Stmt*>::const_iterator it = stmts.begin();
it != stmts.end(); ++it )
{
ODesc location_info;
@ -154,4 +154,3 @@ bool Brofiler::WriteStats()
fclose(f);
return true;
}

7
src/Brofiler.h
View file

@ -5,7 +5,8 @@
#include <list>
#include <string>
class Stmt;
#include "util.h"
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
/**
* A simple class for managing stats of Bro script coverage across Bro runs.
@ -39,13 +40,13 @@ public:
void IncIgnoreDepth() { ignoring++; }
void DecIgnoreDepth() { ignoring--; }
void AddStmt(Stmt* s);
void AddStmt(zeek::detail::Stmt* s);
private:
/**
* The current, global Brofiler instance creates this list at parse-time.
*/
std::list<Stmt*> stmts;
std::list<zeek::detail::Stmt*> stmts;
/**
* Indicates whether new statments will not be considered as part of

31
src/CMakeLists.txt
View file

@ -218,6 +218,7 @@ set(MAIN_SRCS
Anon.cc
Attr.cc
Base64.cc
BifReturnVal.cc
Brofiler.cc
BroString.cc
CCL.cc
@ -325,14 +326,14 @@ set(THIRD_PARTY_SRCS
# Highwayhash. Highwayhash is a bit special since it has architecture dependent code...
set(HH_SRCS
../aux/highwayhash/highwayhash/sip_hash.cc
../aux/highwayhash/highwayhash/sip_tree_hash.cc
../aux/highwayhash/highwayhash/scalar_sip_tree_hash.cc
../aux/highwayhash/highwayhash/arch_specific.cc
../aux/highwayhash/highwayhash/instruction_sets.cc
../aux/highwayhash/highwayhash/nanobenchmark.cc
../aux/highwayhash/highwayhash/os_specific.cc
../aux/highwayhash/highwayhash/hh_portable.cc
../auxil/highwayhash/highwayhash/sip_hash.cc
../auxil/highwayhash/highwayhash/sip_tree_hash.cc
../auxil/highwayhash/highwayhash/scalar_sip_tree_hash.cc
../auxil/highwayhash/highwayhash/arch_specific.cc
../auxil/highwayhash/highwayhash/instruction_sets.cc
../auxil/highwayhash/highwayhash/nanobenchmark.cc
../auxil/highwayhash/highwayhash/os_specific.cc
../auxil/highwayhash/highwayhash/hh_portable.cc
)
if (${COMPILER_ARCHITECTURE} STREQUAL "arm")
@ -340,23 +341,23 @@ if (${COMPILER_ARCHITECTURE} STREQUAL "arm")
-mfloat-abi=hard -march=armv7-a -mfpu=neon)
elseif (${COMPILER_ARCHITECTURE} STREQUAL "aarch64")
list(APPEND HH_SRCS
../aux/highwayhash/highwayhash/hh_neon.cc
../auxil/highwayhash/highwayhash/hh_neon.cc
)
elseif (${COMPILER_ARCHITECTURE} STREQUAL "power")
set_source_files_properties(../aux/highwayhash/highwayhash/hh_avx2.cc PROPERTIES COMPILE_FLAGS
set_source_files_properties(../auxil/highwayhash/highwayhash/hh_avx2.cc PROPERTIES COMPILE_FLAGS
-mvsx)
list(APPEND HH_SRCS
../aux/highwayhash/highwayhash/hh_vsc.cc
../auxil/highwayhash/highwayhash/hh_vsc.cc
)
elseif(${COMPILER_ARCHITECTURE} STREQUAL "x86_64")
set_source_files_properties(../aux/highwayhash/highwayhash/hh_avx2.cc PROPERTIES COMPILE_FLAGS
set_source_files_properties(../auxil/highwayhash/highwayhash/hh_avx2.cc PROPERTIES COMPILE_FLAGS
-mavx2)
set_source_files_properties(../aux/highwayhash/highwayhash/hh_sse41.cc PROPERTIES COMPILE_FLAGS
set_source_files_properties(../auxil/highwayhash/highwayhash/hh_sse41.cc PROPERTIES COMPILE_FLAGS
-msse4.1)
list(APPEND HH_SRCS
../aux/highwayhash/highwayhash/hh_avx2.cc
../aux/highwayhash/highwayhash/hh_sse41.cc
../auxil/highwayhash/highwayhash/hh_avx2.cc
../auxil/highwayhash/highwayhash/hh_sse41.cc
)
endif ()

207
src/CompHash.cc
View file

@ -2,6 +2,7 @@
#include "zeek-config.h"
#include <cstring>
#include <vector>
#include <map>
@ -14,17 +15,17 @@
#include "Func.h"
#include "IPAddr.h"
CompositeHash::CompositeHash(IntrusivePtr<TypeList> composite_type)
CompositeHash::CompositeHash(IntrusivePtr<zeek::TypeList> composite_type)
: type(std::move(composite_type))
{
singleton_tag = TYPE_INTERNAL_ERROR;
singleton_tag = zeek::TYPE_INTERNAL_ERROR;
// If the only element is a record, don't treat it as a
// singleton, since it needs to be evaluated specially.
if ( type->Types().size() == 1 )
{
if ( type->Types()[0]->Tag() == TYPE_RECORD )
if ( type->Types()[0]->Tag() == zeek::TYPE_RECORD )
{
is_complex_type = true;
is_singleton = false;
@ -71,10 +72,10 @@ CompositeHash::~CompositeHash()
// Computes the piece of the hash for Val*, returning the new kp.
char* CompositeHash::SingleValHash(bool type_check, char* kp0,
BroType* bt, Val* v, bool optional) const
zeek::Type* bt, Val* v, bool optional) const
{
char* kp1 = nullptr;
InternalTypeTag t = bt->InternalType();
zeek::InternalTypeTag t = bt->InternalType();
if ( optional )
{
@ -89,13 +90,13 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
if ( type_check )
{
InternalTypeTag vt = v->GetType()->InternalType();
zeek::InternalTypeTag vt = v->GetType()->InternalType();
if ( vt != t )
return nullptr;
}
switch ( t ) {
case TYPE_INTERNAL_INT:
case zeek::TYPE_INTERNAL_INT:
{
bro_int_t* kp = AlignAndPadType<bro_int_t>(kp0);
*kp = v->ForceAsInt();
@ -103,7 +104,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
break;
case TYPE_INTERNAL_UNSIGNED:
case zeek::TYPE_INTERNAL_UNSIGNED:
{
bro_uint_t* kp = AlignAndPadType<bro_uint_t>(kp0);
*kp = v->ForceAsUInt();
@ -111,7 +112,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
break;
case TYPE_INTERNAL_ADDR:
case zeek::TYPE_INTERNAL_ADDR:
{
uint32_t* kp = AlignAndPadType<uint32_t>(kp0);
v->AsAddr().CopyIPv6(kp);
@ -119,7 +120,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
break;
case TYPE_INTERNAL_SUBNET:
case zeek::TYPE_INTERNAL_SUBNET:
{
uint32_t* kp = AlignAndPadType<uint32_t>(kp0);
v->AsSubNet().Prefix().CopyIPv6(kp);
@ -128,7 +129,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
break;
case TYPE_INTERNAL_DOUBLE:
case zeek::TYPE_INTERNAL_DOUBLE:
{
double* kp = AlignAndPadType<double>(kp0);
*kp = v->InternalDouble();
@ -136,11 +137,11 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
break;
case TYPE_INTERNAL_VOID:
case TYPE_INTERNAL_OTHER:
case zeek::TYPE_INTERNAL_VOID:
case zeek::TYPE_INTERNAL_OTHER:
{
switch ( v->GetType()->Tag() ) {
case TYPE_FUNC:
case zeek::TYPE_FUNC:
{
uint32_t* kp = AlignAndPadType<uint32_t>(kp0);
*kp = v->AsFunc()->GetUniqueFuncID();
@ -148,7 +149,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
break;
}
case TYPE_PATTERN:
case zeek::TYPE_PATTERN:
{
const char* texts[2] = {
v->AsPattern()->PatternText(),
@ -172,19 +173,19 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
break;
}
case TYPE_RECORD:
case zeek::TYPE_RECORD:
{
char* kp = kp0;
RecordVal* rv = v->AsRecordVal();
RecordType* rt = bt->AsRecordType();
zeek::RecordType* rt = bt->AsRecordType();
int num_fields = rt->NumFields();
for ( int i = 0; i < num_fields; ++i )
{
auto rv_i = rv->GetField(i).get();
Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->Find(ATTR_OPTIONAL));
zeek::detail::Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->Find(zeek::detail::ATTR_OPTIONAL));
if ( ! (rv_i || optional) )
return nullptr;
@ -199,7 +200,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
break;
}
case TYPE_TABLE:
case zeek::TYPE_TABLE:
{
int* kp = AlignAndPadType<int>(kp0);
TableVal* tv = v->AsTableVal();
@ -208,7 +209,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
auto tbl = tv->AsTable();
auto it = tbl->InitForIteration();
auto lv = make_intrusive<ListVal>(TYPE_ANY);
auto lv = make_intrusive<ListVal>(zeek::TYPE_ANY);
struct HashKeyComparer {
bool operator()(const HashKey* a, const HashKey* b) const
@ -258,11 +259,11 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
break;
case TYPE_VECTOR:
case zeek::TYPE_VECTOR:
{
unsigned int* kp = AlignAndPadType<unsigned int>(kp0);
VectorVal* vv = v->AsVectorVal();
VectorType* vt = v->GetType()->AsVectorType();
zeek::VectorType* vt = v->GetType()->AsVectorType();
*kp = vv->Size();
kp1 = reinterpret_cast<char*>(kp+1);
for ( unsigned int i = 0; i < vv->Size(); ++i )
@ -286,7 +287,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
break;
case TYPE_LIST:
case zeek::TYPE_LIST:
{
int* kp = AlignAndPadType<int>(kp0);
ListVal* lv = v->AsListVal();
@ -309,10 +310,10 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
}
break; // case TYPE_INTERNAL_VOID/OTHER
break; // case zeek::TYPE_INTERNAL_VOID/OTHER
}
case TYPE_INTERNAL_STRING:
case zeek::TYPE_INTERNAL_STRING:
{
// Align to int for the length field.
int* kp = AlignAndPadType<int>(kp0);
@ -327,7 +328,7 @@ char* CompositeHash::SingleValHash(bool type_check, char* kp0,
}
break;
case TYPE_INTERNAL_ERROR:
case zeek::TYPE_INTERNAL_ERROR:
return nullptr;
}
@ -342,9 +343,9 @@ std::unique_ptr<HashKey> CompositeHash::MakeHashKey(const Val& argv, bool type_c
if ( is_singleton )
return ComputeSingletonHash(v, type_check);
if ( is_complex_type && v->GetType()->Tag() != TYPE_LIST )
if ( is_complex_type && v->GetType()->Tag() != zeek::TYPE_LIST )
{
ListVal lv(TYPE_ANY);
ListVal lv(zeek::TYPE_ANY);
// Cast away const to use ListVal - but since we
// re-introduce const on the recursive call, it should
@ -368,7 +369,7 @@ std::unique_ptr<HashKey> CompositeHash::MakeHashKey(const Val& argv, bool type_c
const auto& tl = type->Types();
if ( type_check && v->GetType()->Tag() != TYPE_LIST )
if ( type_check && v->GetType()->Tag() != zeek::TYPE_LIST )
return nullptr;
auto lv = v->AsListVal();
@ -389,7 +390,7 @@ std::unique_ptr<HashKey> CompositeHash::MakeHashKey(const Val& argv, bool type_c
std::unique_ptr<HashKey> CompositeHash::ComputeSingletonHash(const Val* v, bool type_check) const
{
if ( v->GetType()->Tag() == TYPE_LIST )
if ( v->GetType()->Tag() == zeek::TYPE_LIST )
{
auto lv = v->AsListVal();
@ -403,25 +404,25 @@ std::unique_ptr<HashKey> CompositeHash::ComputeSingletonHash(const Val* v, bool
return nullptr;
switch ( singleton_tag ) {
case TYPE_INTERNAL_INT:
case TYPE_INTERNAL_UNSIGNED:
case zeek::TYPE_INTERNAL_INT:
case zeek::TYPE_INTERNAL_UNSIGNED:
return std::make_unique<HashKey>(v->ForceAsInt());
case TYPE_INTERNAL_ADDR:
case zeek::TYPE_INTERNAL_ADDR:
return v->AsAddr().MakeHashKey();
case TYPE_INTERNAL_SUBNET:
case zeek::TYPE_INTERNAL_SUBNET:
return v->AsSubNet().MakeHashKey();
case TYPE_INTERNAL_DOUBLE:
case zeek::TYPE_INTERNAL_DOUBLE:
return std::make_unique<HashKey>(v->InternalDouble());
case TYPE_INTERNAL_VOID:
case TYPE_INTERNAL_OTHER:
if ( v->GetType()->Tag() == TYPE_FUNC )
case zeek::TYPE_INTERNAL_VOID:
case zeek::TYPE_INTERNAL_OTHER:
if ( v->GetType()->Tag() == zeek::TYPE_FUNC )
return std::make_unique<HashKey>(v->AsFunc()->GetUniqueFuncID());
if ( v->GetType()->Tag() == TYPE_PATTERN )
if ( v->GetType()->Tag() == zeek::TYPE_PATTERN )
{
const char* texts[2] = {
v->AsPattern()->PatternText(),
@ -437,10 +438,10 @@ std::unique_ptr<HashKey> CompositeHash::ComputeSingletonHash(const Val* v, bool
reporter->InternalError("bad index type in CompositeHash::ComputeSingletonHash");
return nullptr;
case TYPE_INTERNAL_STRING:
case zeek::TYPE_INTERNAL_STRING:
return std::make_unique<HashKey>(v->AsString());
case TYPE_INTERNAL_ERROR:
case zeek::TYPE_INTERNAL_ERROR:
return nullptr;
default:
@ -449,53 +450,53 @@ std::unique_ptr<HashKey> CompositeHash::ComputeSingletonHash(const Val* v, bool
}
}
int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
int CompositeHash::SingleTypeKeySize(zeek::Type* bt, const Val* v,
bool type_check, int sz, bool optional,
bool calc_static_size) const
{
InternalTypeTag t = bt->InternalType();
zeek::InternalTypeTag t = bt->InternalType();
if ( optional )
sz = SizeAlign(sz, sizeof(char));
if ( type_check && v )
{
InternalTypeTag vt = v->GetType()->InternalType();
zeek::InternalTypeTag vt = v->GetType()->InternalType();
if ( vt != t )
return 0;
}
switch ( t ) {
case TYPE_INTERNAL_INT:
case TYPE_INTERNAL_UNSIGNED:
case zeek::TYPE_INTERNAL_INT:
case zeek::TYPE_INTERNAL_UNSIGNED:
sz = SizeAlign(sz, sizeof(bro_int_t));
break;
case TYPE_INTERNAL_ADDR:
case zeek::TYPE_INTERNAL_ADDR:
sz = SizeAlign(sz, sizeof(uint32_t));
sz += sizeof(uint32_t) * 3; // to make a total of 4 words
break;
case TYPE_INTERNAL_SUBNET:
case zeek::TYPE_INTERNAL_SUBNET:
sz = SizeAlign(sz, sizeof(uint32_t));
sz += sizeof(uint32_t) * 4; // to make a total of 5 words
break;
case TYPE_INTERNAL_DOUBLE:
case zeek::TYPE_INTERNAL_DOUBLE:
sz = SizeAlign(sz, sizeof(double));
break;
case TYPE_INTERNAL_VOID:
case TYPE_INTERNAL_OTHER:
case zeek::TYPE_INTERNAL_VOID:
case zeek::TYPE_INTERNAL_OTHER:
{
switch ( bt->Tag() ) {
case TYPE_FUNC:
case zeek::TYPE_FUNC:
{
sz = SizeAlign(sz, sizeof(uint32_t));
break;
}
case TYPE_PATTERN:
case zeek::TYPE_PATTERN:
{
if ( ! v )
return (optional && ! calc_static_size) ? sz : 0;
@ -506,16 +507,16 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
break;
}
case TYPE_RECORD:
case zeek::TYPE_RECORD:
{
const RecordVal* rv = v ? v->AsRecordVal() : nullptr;
RecordType* rt = bt->AsRecordType();
zeek::RecordType* rt = bt->AsRecordType();
int num_fields = rt->NumFields();
for ( int i = 0; i < num_fields; ++i )
{
Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->Find(ATTR_OPTIONAL));
zeek::detail::Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->Find(zeek::detail::ATTR_OPTIONAL));
sz = SingleTypeKeySize(rt->GetFieldType(i).get(),
rv ? rv->GetField(i).get() : nullptr,
@ -528,7 +529,7 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
break;
}
case TYPE_TABLE:
case zeek::TYPE_TABLE:
{
if ( ! v )
return (optional && ! calc_static_size) ? sz : 0;
@ -557,7 +558,7 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
break;
}
case TYPE_VECTOR:
case zeek::TYPE_VECTOR:
{
if ( ! v )
return (optional && ! calc_static_size) ? sz : 0;
@ -579,7 +580,7 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
break;
}
case TYPE_LIST:
case zeek::TYPE_LIST:
{
if ( ! v )
return (optional && ! calc_static_size) ? sz : 0;
@ -603,10 +604,10 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
}
}
break; // case TYPE_INTERNAL_VOID/OTHER
break; // case zeek::TYPE_INTERNAL_VOID/OTHER
}
case TYPE_INTERNAL_STRING:
case zeek::TYPE_INTERNAL_STRING:
if ( ! v )
return (optional && ! calc_static_size) ? sz : 0;
@ -615,7 +616,7 @@ int CompositeHash::SingleTypeKeySize(BroType* bt, const Val* v,
sz += v->AsString()->Len();
break;
case TYPE_INTERNAL_ERROR:
case zeek::TYPE_INTERNAL_ERROR:
return 0;
}
@ -628,7 +629,7 @@ int CompositeHash::ComputeKeySize(const Val* v, bool type_check, bool calc_stati
if ( v )
{
if ( type_check && v->GetType()->Tag() != TYPE_LIST )
if ( type_check && v->GetType()->Tag() != zeek::TYPE_LIST )
return 0;
auto lv = v->AsListVal();
@ -710,7 +711,7 @@ int CompositeHash::SizeAlign(int offset, unsigned int size) const
IntrusivePtr<ListVal> CompositeHash::RecoverVals(const HashKey& k) const
{
auto l = make_intrusive<ListVal>(TYPE_ANY);
auto l = make_intrusive<ListVal>(zeek::TYPE_ANY);
const auto& tl = type->Types();
const char* kp = (const char*) k.Key();
const char* const k_end = kp + k.Size();
@ -730,15 +731,15 @@ IntrusivePtr<ListVal> CompositeHash::RecoverVals(const HashKey& k) const
}
const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
const char* const k_end, BroType* t,
const char* const k_end, zeek::Type* t,
IntrusivePtr<Val>* pval, bool optional) const
{
// k->Size() == 0 for a single empty string.
if ( kp0 >= k_end && k.Size() > 0 )
reporter->InternalError("over-ran key in CompositeHash::RecoverVals");
TypeTag tag = t->Tag();
InternalTypeTag it = t->InternalType();
zeek::TypeTag tag = t->Tag();
zeek::InternalTypeTag it = t->InternalType();
const char* kp1 = nullptr;
if ( optional )
@ -754,16 +755,16 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
switch ( it ) {
case TYPE_INTERNAL_INT:
case zeek::TYPE_INTERNAL_INT:
{
const bro_int_t* const kp = AlignType<bro_int_t>(kp0);
kp1 = reinterpret_cast<const char*>(kp+1);
if ( tag == TYPE_ENUM )
if ( tag == zeek::TYPE_ENUM )
*pval = t->AsEnumType()->GetVal(*kp);
else if ( tag == TYPE_BOOL )
else if ( tag == zeek::TYPE_BOOL )
*pval = val_mgr->Bool(*kp);
else if ( tag == TYPE_INT )
else if ( tag == zeek::TYPE_INT )
*pval = val_mgr->Int(*kp);
else
{
@ -773,18 +774,18 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_INTERNAL_UNSIGNED:
case zeek::TYPE_INTERNAL_UNSIGNED:
{
const bro_uint_t* const kp = AlignType<bro_uint_t>(kp0);
kp1 = reinterpret_cast<const char*>(kp+1);
switch ( tag ) {
case TYPE_COUNT:
case TYPE_COUNTER:
case zeek::TYPE_COUNT:
case zeek::TYPE_COUNTER:
*pval = val_mgr->Count(*kp);
break;
case TYPE_PORT:
case zeek::TYPE_PORT:
*pval = val_mgr->Port(*kp);
break;
@ -796,21 +797,21 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_INTERNAL_DOUBLE:
case zeek::TYPE_INTERNAL_DOUBLE:
{
const double* const kp = AlignType<double>(kp0);
kp1 = reinterpret_cast<const char*>(kp+1);
if ( tag == TYPE_INTERVAL )
if ( tag == zeek::TYPE_INTERVAL )
*pval = make_intrusive<IntervalVal>(*kp, 1.0);
else if ( tag == TYPE_TIME )
else if ( tag == zeek::TYPE_TIME )
*pval = make_intrusive<TimeVal>(*kp);
else
*pval = make_intrusive<DoubleVal>(*kp);
}
break;
case TYPE_INTERNAL_ADDR:
case zeek::TYPE_INTERNAL_ADDR:
{
const uint32_t* const kp = AlignType<uint32_t>(kp0);
kp1 = reinterpret_cast<const char*>(kp+4);
@ -818,7 +819,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
IPAddr addr(IPv6, kp, IPAddr::Network);
switch ( tag ) {
case TYPE_ADDR:
case zeek::TYPE_ADDR:
*pval = make_intrusive<AddrVal>(addr);
break;
@ -830,7 +831,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_INTERNAL_SUBNET:
case zeek::TYPE_INTERNAL_SUBNET:
{
const uint32_t* const kp = AlignType<uint32_t>(kp0);
kp1 = reinterpret_cast<const char*>(kp+5);
@ -838,11 +839,11 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_INTERNAL_VOID:
case TYPE_INTERNAL_OTHER:
case zeek::TYPE_INTERNAL_VOID:
case zeek::TYPE_INTERNAL_OTHER:
{
switch ( t->Tag() ) {
case TYPE_FUNC:
case zeek::TYPE_FUNC:
{
const uint32_t* const kp = AlignType<uint32_t>(kp0);
kp1 = reinterpret_cast<const char*>(kp+1);
@ -858,18 +859,18 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
if ( ! pvt )
reporter->InternalError("bad aggregate Val in CompositeHash::RecoverOneVal()");
else if ( t->Tag() != TYPE_FUNC && ! same_type(pvt, t) )
else if ( t->Tag() != zeek::TYPE_FUNC && ! same_type(pvt, t) )
// ### Maybe fix later, but may be fundamentally
// un-checkable --US
reporter->InternalError("inconsistent aggregate Val in CompositeHash::RecoverOneVal()");
// ### A crude approximation for now.
else if ( t->Tag() == TYPE_FUNC && pvt->Tag() != TYPE_FUNC )
else if ( t->Tag() == zeek::TYPE_FUNC && pvt->Tag() != zeek::TYPE_FUNC )
reporter->InternalError("inconsistent aggregate Val in CompositeHash::RecoverOneVal()");
}
break;
case TYPE_PATTERN:
case zeek::TYPE_PATTERN:
{
RE_Matcher* re = nullptr;
if ( is_singleton )
@ -896,10 +897,10 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_RECORD:
case zeek::TYPE_RECORD:
{
const char* kp = kp0;
RecordType* rt = t->AsRecordType();
zeek::RecordType* rt = t->AsRecordType();
int num_fields = rt->NumFields();
std::vector<IntrusivePtr<Val>> values;
@ -908,8 +909,8 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
{
IntrusivePtr<Val> v;
Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->Find(ATTR_OPTIONAL));
zeek::detail::Attributes* a = rt->FieldDecl(i)->attrs.get();
bool optional = (a && a->Find(zeek::detail::ATTR_OPTIONAL));
kp = RecoverOneVal(k, kp, k_end,
rt->GetFieldType(i).get(), &v, optional);
@ -939,13 +940,13 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_TABLE:
case zeek::TYPE_TABLE:
{
int n;
const int* const kp = AlignType<int>(kp0);
n = *kp;
kp1 = reinterpret_cast<const char*>(kp+1);
TableType* tt = t->AsTableType();
zeek::TableType* tt = t->AsTableType();
auto tv = make_intrusive<TableVal>(IntrusivePtr{NewRef{}, tt});
for ( int i = 0; i < n; ++i )
@ -968,13 +969,13 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_VECTOR:
case zeek::TYPE_VECTOR:
{
unsigned int n;
const unsigned int* kp = AlignType<unsigned int>(kp0);
n = *kp;
kp1 = reinterpret_cast<const char*>(kp+1);
VectorType* vt = t->AsVectorType();
zeek::VectorType* vt = t->AsVectorType();
auto vv = make_intrusive<VectorVal>(IntrusivePtr{NewRef{}, vt});
for ( unsigned int i = 0; i < n; ++i )
@ -998,19 +999,19 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_LIST:
case zeek::TYPE_LIST:
{
int n;
const int* const kp = AlignType<int>(kp0);
n = *kp;
kp1 = reinterpret_cast<const char*>(kp+1);
TypeList* tl = t->AsTypeList();
auto lv = make_intrusive<ListVal>(TYPE_ANY);
zeek::TypeList* tl = t->AsTypeList();
auto lv = make_intrusive<ListVal>(zeek::TYPE_ANY);
for ( int i = 0; i < n; ++i )
{
IntrusivePtr<Val> v;
BroType* it = tl->Types()[i].get();
zeek::Type* it = tl->Types()[i].get();
kp1 = RecoverOneVal(k, kp1, k_end, it, &v, false);
lv->Append(std::move(v));
}
@ -1027,7 +1028,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_INTERNAL_STRING:
case zeek::TYPE_INTERNAL_STRING:
{
// There is a minor issue here -- the pointer does not have to
// be aligned by int in the singleton case.
@ -1050,7 +1051,7 @@ const char* CompositeHash::RecoverOneVal(const HashKey& k, const char* kp0,
}
break;
case TYPE_INTERNAL_ERROR:
case zeek::TYPE_INTERNAL_ERROR:
break;
}

12
src/CompHash.h
View file

@ -12,7 +12,7 @@ class HashKey;
class CompositeHash {
public:
explicit CompositeHash(IntrusivePtr<TypeList> composite_type);
explicit CompositeHash(IntrusivePtr<zeek::TypeList> composite_type);
~CompositeHash();
// Compute the hash corresponding to the given index val,
@ -37,7 +37,7 @@ protected:
// Computes the piece of the hash for Val*, returning the new kp.
// Used as a helper for ComputeHash in the non-singleton case.
char* SingleValHash(bool type_check, char* kp, BroType* bt, Val* v,
char* SingleValHash(bool type_check, char* kp, zeek::Type* bt, Val* v,
bool optional) const;
// Recovers just one Val of possibly many; called from RecoverVals.
@ -46,7 +46,7 @@ protected:
// upon errors, so there is no return value for invalid input.
const char* RecoverOneVal(const HashKey& k,
const char* kp, const char* const k_end,
BroType* t, IntrusivePtr<Val>* pval, bool optional) const;
zeek::Type* t, IntrusivePtr<Val>* pval, bool optional) const;
// Rounds the given pointer up to the nearest multiple of the
// given size, if not already a multiple.
@ -85,11 +85,11 @@ protected:
int ComputeKeySize(const Val* v, bool type_check,
bool calc_static_size) const;
int SingleTypeKeySize(BroType*, const Val*,
int SingleTypeKeySize(zeek::Type*, const Val*,
bool type_check, int sz, bool optional,
bool calc_static_size) const;
IntrusivePtr<TypeList> type;
IntrusivePtr<zeek::TypeList> type;
char* key; // space for composite key
int size;
bool is_singleton; // if just one type in index
@ -97,5 +97,5 @@ protected:
// If one type, but not normal "singleton", e.g. record.
bool is_complex_type;
InternalTypeTag singleton_tag;
zeek::InternalTypeTag singleton_tag;
};

6
src/Conn.cc
View file

@ -457,13 +457,11 @@ void Connection::Match(Rule::PatternType type, const u_char* data, int len, bool
void Connection::RemovalEvent()
{
auto cv = ConnVal();
if ( connection_state_remove )
EnqueueEvent(connection_state_remove, nullptr, cv);
EnqueueEvent(connection_state_remove, nullptr, ConnVal());
if ( is_successful && successful_connection_remove )
EnqueueEvent(successful_connection_remove, nullptr, cv);
EnqueueEvent(successful_connection_remove, nullptr, ConnVal());
}
void Connection::Event(EventHandlerPtr f, analyzer::Analyzer* analyzer, const char* name)

14
src/DNS_Mgr.cc
View file

@ -175,10 +175,10 @@ void DNS_Mgr_mapping_delete_func(void* v)
static IntrusivePtr<TableVal> empty_addr_set()
{
auto addr_t = base_type(TYPE_ADDR);
auto set_index = make_intrusive<TypeList>(addr_t);
auto addr_t = zeek::base_type(zeek::TYPE_ADDR);
auto set_index = make_intrusive<zeek::TypeList>(addr_t);
set_index->Append(std::move(addr_t));
auto s = make_intrusive<SetType>(std::move(set_index), nullptr);
auto s = make_intrusive<zeek::SetType>(std::move(set_index), nullptr);
return make_intrusive<TableVal>(std::move(s));
}
@ -283,7 +283,7 @@ IntrusivePtr<ListVal> DNS_Mapping::Addrs()
if ( ! addrs_val )
{
auto addrs_val = make_intrusive<ListVal>(TYPE_ADDR);
auto addrs_val = make_intrusive<ListVal>(zeek::TYPE_ADDR);
for ( int i = 0; i < num_addrs; ++i )
addrs_val->Append(make_intrusive<AddrVal>(addrs[i]));
@ -450,7 +450,7 @@ void DNS_Mgr::InitSource()
void DNS_Mgr::InitPostScript()
{
dm_rec = zeek::id::find_type<RecordType>("dns_mapping");
dm_rec = zeek::id::find_type<zeek::RecordType>("dns_mapping");
// Registering will call Init()
iosource_mgr->Register(this, true);
@ -465,7 +465,7 @@ static IntrusivePtr<TableVal> fake_name_lookup_result(const char* name)
{
hash128_t hash;
KeyedHash::StaticHash128(name, strlen(name), &hash);
auto hv = make_intrusive<ListVal>(TYPE_ADDR);
auto hv = make_intrusive<ListVal>(zeek::TYPE_ADDR);
hv->Append(make_intrusive<AddrVal>(reinterpret_cast<const uint32_t*>(&hash)));
return hv->ToSetVal();
}
@ -872,7 +872,7 @@ void DNS_Mgr::CompareMappings(DNS_Mapping* prev_dm, DNS_Mapping* new_dm)
IntrusivePtr<ListVal> DNS_Mgr::AddrListDelta(ListVal* al1, ListVal* al2)
{
auto delta = make_intrusive<ListVal>(TYPE_ADDR);
auto delta = make_intrusive<ListVal>(zeek::TYPE_ADDR);
for ( int i = 0; i < al1->Length(); ++i )
{

6
src/DNS_Mgr.h
View file

@ -11,6 +11,7 @@
#include "EventHandler.h"
#include "iosource/IOSource.h"
#include "IPAddr.h"
#include "util.h"
template <class T> class IntrusivePtr;
class Val;
@ -18,9 +19,10 @@ class ListVal;
class TableVal;
class Func;
class EventHandler;
class RecordType;
class DNS_Mgr_Request;
ZEEK_FORWARD_DECLARE_NAMESPACED(RecordType, zeek);
typedef PList<DNS_Mgr_Request> DNS_mgr_request_list;
struct nb_dns_info;
@ -149,7 +151,7 @@ protected:
bool did_init;
IntrusivePtr<RecordType> dm_rec;
IntrusivePtr<zeek::RecordType> dm_rec;
typedef std::list<LookupCallback*> CallbackList;

8
src/DbgBreakpoint.cc
View file

@ -166,7 +166,7 @@ bool DbgBreakpoint::SetLocation(ParseLocationRec plr, std::string_view loc_str)
return true;
}
bool DbgBreakpoint::SetLocation(Stmt* stmt)
bool DbgBreakpoint::SetLocation(zeek::detail::Stmt* stmt)
{
if ( ! stmt )
return false;
@ -258,8 +258,8 @@ BreakCode DbgBreakpoint::HasHit()
return bcHit;
}
if ( ! IsIntegral(yes->GetType()->Tag()) &&
! IsBool(yes->GetType()->Tag()) )
if ( ! zeek::IsIntegral(yes->GetType()->Tag()) &&
! zeek::IsBool(yes->GetType()->Tag()) )
{
PrintHitMsg();
debug_msg("Breakpoint condition should return an integral type");
@ -290,7 +290,7 @@ BreakCode DbgBreakpoint::HasHit()
return bcHit;
}
BreakCode DbgBreakpoint::ShouldBreak(Stmt* s)
BreakCode DbgBreakpoint::ShouldBreak(zeek::detail::Stmt* s)
{
if ( ! IsEnabled() )
return bcNoHit;

10
src/DbgBreakpoint.h
View file

@ -3,9 +3,11 @@
#pragma once
#include <string>
#include "util.h"
struct ParseLocationRec;
class Stmt;
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
enum BreakCode { bcNoHit, bcHit, bcHitAndDelete };
class DbgBreakpoint {
@ -20,7 +22,7 @@ public:
// True if breakpoint could be set; false otherwise
bool SetLocation(ParseLocationRec plr, std::string_view loc_str);
bool SetLocation(Stmt* stmt);
bool SetLocation(zeek::detail::Stmt* stmt);
bool SetLocation(double time);
bool Reset(); // cancel and re-apply bpt when restarting execution
@ -35,7 +37,7 @@ public:
//
// NOTE: If it returns a hit, the DbgBreakpoint object will take
// appropriate action (e.g., resetting counters).
BreakCode ShouldBreak(Stmt* s);
BreakCode ShouldBreak(zeek::detail::Stmt* s);
BreakCode ShouldBreak(double t);
const std::string& GetCondition() const { return condition; }
@ -70,7 +72,7 @@ protected:
bool enabled; // ### comment this and next
bool temporary;
Stmt* at_stmt;
zeek::detail::Stmt* at_stmt;
double at_time; // break when the virtual time is this
// Support for conditional and N'th time breakpoints.

2
src/DbgWatch.cc
View file

@ -12,7 +12,7 @@ DbgWatch::DbgWatch(BroObj* var_to_watch)
reporter->InternalError("DbgWatch unimplemented");
}
DbgWatch::DbgWatch(Expr* expr_to_watch)
DbgWatch::DbgWatch(zeek::detail::Expr* expr_to_watch)
{
reporter->InternalError("DbgWatch unimplemented");
}

9
src/DbgWatch.h
View file

@ -2,16 +2,19 @@
#pragma once
#include "util.h"
class BroObj;
class Expr;
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
class DbgWatch {
public:
explicit DbgWatch(BroObj* var_to_watch);
explicit DbgWatch(Expr* expr_to_watch);
explicit DbgWatch(zeek::detail::Expr* expr_to_watch);
~DbgWatch();
protected:
BroObj* var;
Expr* expr;
zeek::detail::Expr* expr;
};

20
src/Debug.cc
View file

@ -135,7 +135,7 @@ int TraceState::LogTrace(const char* fmt, ...)
// Prefix includes timestamp and file/line info.
fprintf(trace_file, "%.6f ", network_time);
const Stmt* stmt;
const zeek::detail::Stmt* stmt;
Location loc;
loc.filename = nullptr;
@ -174,7 +174,7 @@ int TraceState::LogTrace(const char* fmt, ...)
// Helper functions.
void get_first_statement(Stmt* list, Stmt*& first, Location& loc)
void get_first_statement(zeek::detail::Stmt* list, zeek::detail::Stmt*& first, Location& loc)
{
if ( ! list )
{
@ -231,7 +231,7 @@ static void parse_function_name(vector<ParseLocationRec>& result,
return;
}
Stmt* body = nullptr; // the particular body we care about; 0 = all
zeek::detail::Stmt* body = nullptr; // the particular body we care about; 0 = all
if ( bodies.size() == 1 )
body = bodies[0].stmts.get();
@ -243,7 +243,7 @@ static void parse_function_name(vector<ParseLocationRec>& result,
"Please choose one of the following options:\n");
for ( unsigned int i = 0; i < bodies.size(); ++i )
{
Stmt* first;
zeek::detail::Stmt* first;
Location stmt_loc;
get_first_statement(bodies[i].stmts.get(), first, stmt_loc);
debug_msg("[%d] %s:%d\n", i+1, stmt_loc.filename, stmt_loc.first_line);
@ -286,7 +286,7 @@ static void parse_function_name(vector<ParseLocationRec>& result,
plr.type = plrFunction;
// Find first atomic (non-STMT_LIST) statement
Stmt* first;
zeek::detail::Stmt* first;
Location stmt_loc;
if ( body )
@ -728,7 +728,7 @@ static char* get_prompt(bool reset_counter = false)
return prompt;
}
string get_context_description(const Stmt* stmt, const Frame* frame)
string get_context_description(const zeek::detail::Stmt* stmt, const Frame* frame)
{
ODesc d;
const BroFunc* func = frame ? frame->GetFunction() : nullptr;
@ -776,7 +776,7 @@ int dbg_handle_debug_input()
else
current_module = GLOBAL_MODULE_NAME;
const Stmt* stmt = curr_frame->GetNextStmt();
const zeek::detail::Stmt* stmt = curr_frame->GetNextStmt();
if ( ! stmt )
reporter->InternalError("Assertion failed: stmt != 0");
@ -840,7 +840,7 @@ int dbg_handle_debug_input()
// Return true to continue execution, false to abort.
bool pre_execute_stmt(Stmt* stmt, Frame* f)
bool pre_execute_stmt(zeek::detail::Stmt* stmt, Frame* f)
{
if ( ! g_policy_debug ||
stmt->Tag() == STMT_LIST || stmt->Tag() == STMT_NULL )
@ -905,7 +905,7 @@ bool pre_execute_stmt(Stmt* stmt, Frame* f)
return true;
}
bool post_execute_stmt(Stmt* stmt, Frame* f, Val* result, stmt_flow_type* flow)
bool post_execute_stmt(zeek::detail::Stmt* stmt, Frame* f, Val* result, stmt_flow_type* flow)
{
// Handle the case where someone issues a "next" debugger command,
// but we're at a return statement, so the next statement is in
@ -935,7 +935,7 @@ bool post_execute_stmt(Stmt* stmt, Frame* f, Val* result, stmt_flow_type* flow)
// Evaluates the given expression in the context of the currently selected
// frame. Returns the resulting value, or nil if none (or there was an error).
Expr* g_curr_debug_expr = nullptr;
zeek::detail::Expr* g_curr_debug_expr = nullptr;
const char* g_curr_debug_error = nullptr;
bool in_debug = false;

20
src/Debug.h
View file

@ -5,6 +5,7 @@
#include "Obj.h"
#include "Queue.h"
#include "StmtEnums.h"
#include "util.h"
#include <vector>
#include <map>
@ -12,14 +13,15 @@
template <class T> class IntrusivePtr;
class Val;
class Stmt;
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
// This needs to be defined before we do the includes that come after it.
enum ParseLocationRecType { plrUnknown, plrFileAndLine, plrFunction };
struct ParseLocationRec {
ParseLocationRecType type;
int32_t line;
Stmt* stmt;
zeek::detail::Stmt* stmt;
const char* filename;
};
@ -33,7 +35,7 @@ class DbgDisplay;
class StmtHashFn;
typedef std::map<int, DbgBreakpoint*> BPIDMapType;
typedef std::multimap<const Stmt*, DbgBreakpoint*> BPMapType;
typedef std::multimap<const zeek::detail::Stmt*, DbgBreakpoint*> BPMapType;
extern std::string current_module;
@ -104,15 +106,15 @@ private:
class StmtLocMapping {
public:
StmtLocMapping() { }
StmtLocMapping(const Location* l, Stmt* s) { loc = *l; stmt = s; }
StmtLocMapping(const Location* l, zeek::detail::Stmt* s) { loc = *l; stmt = s; }
bool StartsAfter(const StmtLocMapping* m2);
const Location& Loc() const { return loc; }
Stmt* Statement() const { return stmt; }
zeek::detail::Stmt* Statement() const { return stmt; }
protected:
Location loc;
Stmt* stmt;
zeek::detail::Stmt* stmt;
};
@ -143,8 +145,8 @@ std::vector<ParseLocationRec> parse_location_string(const std::string& s);
// Debugging hooks.
// Return true to continue execution, false to abort.
bool pre_execute_stmt(Stmt* stmt, Frame* f);
bool post_execute_stmt(Stmt* stmt, Frame* f, Val* result, stmt_flow_type* flow);
bool pre_execute_stmt(zeek::detail::Stmt* stmt, Frame* f);
bool post_execute_stmt(zeek::detail::Stmt* stmt, Frame* f, Val* result, stmt_flow_type* flow);
// Returns 1 if successful, 0 otherwise.
// If cmdfile is non-nil, it contains the location of a file of commands
@ -168,7 +170,7 @@ IntrusivePtr<Val> dbg_eval_expr(const char* expr);
int dbg_read_internal_state();
// Get line that looks like "In FnFoo(arg = val) at File:Line".
std::string get_context_description(const Stmt* stmt, const Frame* frame);
std::string get_context_description(const zeek::detail::Stmt* stmt, const Frame* frame);
extern Frame* g_dbg_locals; // variables created within debugger context

26
src/DebugCmds.cc
View file

@ -30,13 +30,13 @@ using namespace std;
//
// Helper routines
//
bool string_is_regex(const string& s)
static bool string_is_regex(const string& s)
{
return strpbrk(s.data(), "?*\\+");
}
void lookup_global_symbols_regex(const string& orig_regex, vector<ID*>& matches,
bool func_only = false)
static void lookup_global_symbols_regex(const string& orig_regex, vector<zeek::detail::ID*>& matches,
bool func_only = false)
{
if ( streq(orig_regex.c_str(), "") )
return;
@ -61,18 +61,18 @@ void lookup_global_symbols_regex(const string& orig_regex, vector<ID*>& matches,
Scope* global = global_scope();
const auto& syms = global->Vars();
ID* nextid;
zeek::detail::ID* nextid;
for ( const auto& sym : syms )
{
ID* nextid = sym.second.get();
if ( ! func_only || nextid->GetType()->Tag() == TYPE_FUNC )
zeek::detail::ID* nextid = sym.second.get();
if ( ! func_only || nextid->GetType()->Tag() == zeek::TYPE_FUNC )
if ( ! regexec (&re, nextid->Name(), 0, 0, 0) )
matches.push_back(nextid);
}
}
void choose_global_symbols_regex(const string& regex, vector<ID*>& choices,
bool func_only = false)
static void choose_global_symbols_regex(const string& regex, vector<zeek::detail::ID*>& choices,
bool func_only = false)
{
lookup_global_symbols_regex(regex, choices, func_only);
@ -111,7 +111,7 @@ void choose_global_symbols_regex(const string& regex, vector<ID*>& choices,
int option = atoi(input.c_str());
if ( option > 0 && option <= (int) choices.size() )
{
ID* choice = choices[option - 1];
zeek::detail::ID* choice = choices[option - 1];
choices.clear();
choices.push_back(choice);
return;
@ -216,7 +216,7 @@ static int dbg_backtrace_internal(int start, int end)
for ( int i = start; i >= end; --i )
{
const Frame* f = g_frame_stack[i];
const Stmt* stmt = f ? f->GetNextStmt() : nullptr;
const zeek::detail::Stmt* stmt = f ? f->GetNextStmt() : nullptr;
string context = get_context_description(stmt, f);
debug_msg("#%d %s\n",
@ -333,7 +333,7 @@ int dbg_cmd_frame(DebugCmd cmd, const vector<string>& args)
// Set the current location to the new frame being looked at
// for 'list', 'break', etc.
const Stmt* stmt = g_frame_stack[user_frame_number]->GetNextStmt();
const zeek::detail::Stmt* stmt = g_frame_stack[user_frame_number]->GetNextStmt();
if ( ! stmt )
reporter->InternalError("Assertion failed: %s", "stmt != 0");
@ -373,7 +373,7 @@ int dbg_cmd_break(DebugCmd cmd, const vector<string>& args)
g_frame_stack.size() - 1 -
g_debugger_state.curr_frame_idx;
Stmt* stmt = g_frame_stack[user_frame_number]->GetNextStmt();
zeek::detail::Stmt* stmt = g_frame_stack[user_frame_number]->GetNextStmt();
if ( ! stmt )
reporter->InternalError("Assertion failed: %s", "stmt != 0");
@ -398,7 +398,7 @@ int dbg_cmd_break(DebugCmd cmd, const vector<string>& args)
vector<string> locstrings;
if ( string_is_regex(args[0]) )
{
vector<ID*> choices;
vector<zeek::detail::ID*> choices;
choose_global_symbols_regex(args[0], choices, true);
for ( unsigned int i = 0; i < choices.size(); ++i )
locstrings.push_back(choices[i]->Name());

2
src/DebugLogger.cc
View file

@ -163,7 +163,7 @@ void DebugLogger::Log(DebugStream stream, const char* fmt, ...)
fflush(file);
}
void DebugLogger::Log(const plugin::Plugin& plugin, const char* fmt, ...)
void DebugLogger::Log(const zeek::plugin::Plugin& plugin, const char* fmt, ...)
{
std::string tok = std::string("plugin-") + plugin.Name();
tok = strreplace(tok, "::", "-");

4
src/DebugLogger.h
View file

@ -45,7 +45,7 @@ enum DebugStream {
#define PLUGIN_DBG_LOG(plugin, args...) debug_logger.Log(plugin, args)
namespace plugin { class Plugin; }
namespace zeek::plugin { class Plugin; }
class DebugLogger {
public:
@ -56,7 +56,7 @@ public:
void OpenDebugLog(const char* filename = 0);
void Log(DebugStream stream, const char* fmt, ...) __attribute__((format(printf, 3, 4)));
void Log(const plugin::Plugin& plugin, const char* fmt, ...) __attribute__((format(printf, 3, 4)));
void Log(const zeek::plugin::Plugin& plugin, const char* fmt, ...) __attribute__((format(printf, 3, 4)));
void PushIndent(DebugStream stream)
{ ++streams[int(stream)].indent; }

6
src/Desc.cc
View file

@ -403,19 +403,19 @@ void ODesc::Clear()
}
}
bool ODesc::PushType(const BroType* type)
bool ODesc::PushType(const zeek::Type* type)
{
auto res = encountered_types.insert(type);
return std::get<1>(res);
}
bool ODesc::PopType(const BroType* type)
bool ODesc::PopType(const zeek::Type* type)
{
size_t res = encountered_types.erase(type);
return (res == 1);
}
bool ODesc::FindType(const BroType* type)
bool ODesc::FindType(const zeek::Type* type)
{
auto res = encountered_types.find(type);

12
src/Desc.h
View file

@ -25,7 +25,9 @@ typedef enum {
class BroFile;
class IPAddr;
class IPPrefix;
class BroType;
namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
class ODesc {
public:
@ -146,9 +148,9 @@ public:
// Used to determine recursive types. Records push their types on here;
// if the same type (by address) is re-encountered, processing aborts.
bool PushType(const BroType* type);
bool PopType(const BroType* type);
bool FindType(const BroType* type);
bool PushType(const zeek::Type* type);
bool PopType(const zeek::Type* type);
bool FindType(const zeek::Type* type);
protected:
void Indent();
@ -204,5 +206,5 @@ protected:
bool do_flush;
bool include_stats;
std::set<const BroType*> encountered_types;
std::set<const zeek::Type*> encountered_types;
};

2
src/Event.h
View file

@ -145,7 +145,7 @@ protected:
analyzer::ID current_aid;
RecordVal* src_val;
bool draining;
bro::Flare queue_flare;
zeek::detail::Flare queue_flare;
};
extern EventMgr mgr;

21
src/EventHandler.cc
View file

@ -26,7 +26,7 @@ EventHandler::operator bool() const
|| ! auto_publish.empty());
}
const IntrusivePtr<FuncType>& EventHandler::GetType(bool check_export)
const IntrusivePtr<zeek::FuncType>& EventHandler::GetType(bool check_export)
{
if ( type )
return type;
@ -35,15 +35,21 @@ const IntrusivePtr<FuncType>& EventHandler::GetType(bool check_export)
check_export);
if ( ! id )
return FuncType::nil;
return zeek::FuncType::nil;
if ( id->GetType()->Tag() != TYPE_FUNC )
return FuncType::nil;
if ( id->GetType()->Tag() != zeek::TYPE_FUNC )
return zeek::FuncType::nil;
type = id->GetType<FuncType>();
type = id->GetType<zeek::FuncType>();
return type;
}
void EventHandler::SetFunc(IntrusivePtr<Func> f)
{ local = std::move(f); }
void EventHandler::SetLocalHandler(Func* f)
{ SetFunc({NewRef{}, f}); }
void EventHandler::Call(zeek::Args* vl, bool no_remote)
{
#ifdef PROFILE_BRO_FUNCTIONS
@ -111,7 +117,7 @@ void EventHandler::NewEvent(zeek::Args* vl)
return;
const auto& args = GetType()->Params();
static auto call_argument_vector = zeek::id::find_type<VectorType>("call_argument_vector");
static auto call_argument_vector = zeek::id::find_type<zeek::VectorType>("call_argument_vector");
auto vargs = make_intrusive<VectorVal>(call_argument_vector);
for ( int i = 0; i < args->NumFields(); i++ )
@ -120,7 +126,7 @@ void EventHandler::NewEvent(zeek::Args* vl)
const auto& ftype = args->GetFieldType(i);
auto fdefault = args->FieldDefault(i);
static auto call_argument = zeek::id::find_type<RecordType>("call_argument");
static auto call_argument = zeek::id::find_type<zeek::RecordType>("call_argument");
auto rec = make_intrusive<RecordVal>(call_argument);
rec->Assign(0, make_intrusive<StringVal>(fname));
@ -144,4 +150,3 @@ void EventHandler::NewEvent(zeek::Args* vl)
});
mgr.Dispatch(ev);
}

15
src/EventHandler.h
View file

@ -5,11 +5,12 @@
#include "BroList.h"
#include "ZeekArgs.h"
#include "Type.h"
#include "Func.h"
#include <unordered_set>
#include <string>
class Func;
class EventHandler {
public:
explicit EventHandler(std::string name);
@ -22,18 +23,16 @@ public:
[[deprecated("Remove in v4.1. Use GetFunc().")]]
Func* LocalHandler() { return local.get(); }
const IntrusivePtr<FuncType>& GetType(bool check_export = true);
const IntrusivePtr<zeek::FuncType>& GetType(bool check_export = true);
[[deprecated("Remove in v4.1. Use GetType().")]]
FuncType* FType(bool check_export = true)
zeek::FuncType* FType(bool check_export = true)
{ return GetType().get(); }
void SetFunc(IntrusivePtr<Func> f)
{ local = std::move(f); }
void SetFunc(IntrusivePtr<Func> f);
[[deprecated("Remove in v4.1. Use SetFunc().")]]
void SetLocalHandler(Func* f)
{ SetFunc({NewRef{}, f}); }
void SetLocalHandler(Func* f);
void AutoPublish(std::string topic)
{
@ -70,7 +69,7 @@ private:
std::string name;
IntrusivePtr<Func> local;
IntrusivePtr<FuncType> type;
IntrusivePtr<zeek::FuncType> type;
bool used; // this handler is indeed used somewhere
bool enabled;
bool error_handler; // this handler reports error messages.

1
src/EventRegistry.cc
View file

@ -1,5 +1,6 @@
#include "EventRegistry.h"
#include "EventHandler.h"
#include "Func.h"
#include "RE.h"
#include "Reporter.h"

502
src/Expr.cc
View file

File diff suppressed because it is too large Load diff

123
src/Expr.h
View file

@ -17,6 +17,13 @@
#include "Val.h"
#include "ZeekArgs.h"
template <class T> class IntrusivePtr;
class Frame;
class Scope;
struct function_ingredients;
namespace zeek::detail {
enum BroExprTag : int {
EXPR_ANY = -1,
EXPR_NAME, EXPR_CONST,
@ -58,26 +65,20 @@ enum BroExprTag : int {
extern const char* expr_name(BroExprTag t);
template <class T> class IntrusivePtr;
class Stmt;
class Frame;
class Scope;
class ListExpr;
class NameExpr;
class IndexExpr;
class AssignExpr;
class CallExpr;
class EventExpr;
struct function_ingredients;
class Stmt;
class Expr : public BroObj {
public:
[[deprecated("Remove in v4.1. Use GetType().")]]
BroType* Type() const { return type.get(); }
zeek::Type* Type() const { return type.get(); }
const IntrusivePtr<BroType>& GetType() const
const IntrusivePtr<zeek::Type>& GetType() const
{ return type; }
template <class T>
@ -96,7 +97,7 @@ public:
// into the given aggregate of the given type. Note that
// return type is void since it's updating an existing
// value, rather than creating a new one.
virtual void EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f)
virtual void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f)
const;
// Assign to the given value, if appropriate.
@ -104,7 +105,7 @@ public:
// Returns the type corresponding to this expression interpreted
// as an initialization. Returns nil if the initialization is illegal.
virtual IntrusivePtr<BroType> InitType() const;
virtual IntrusivePtr<zeek::Type> InitType() const;
// Returns true if this expression, interpreted as an initialization,
// constitutes a record element, false otherwise. If the TypeDecl*
@ -117,7 +118,7 @@ public:
// with the given type. If "aggr" is non-nil, then this expression
// is an element of the given aggregate, and it is added to it
// accordingly.
virtual IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const;
virtual IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const;
// True if the expression has no side effects, false otherwise.
virtual bool IsPure() const;
@ -222,7 +223,7 @@ protected:
// Puts the expression in canonical form.
virtual void Canonicize();
void SetType(IntrusivePtr<BroType> t);
void SetType(IntrusivePtr<zeek::Type> t);
// Reports the given error and sets the expression's type to
// TYPE_ERROR.
@ -234,7 +235,7 @@ protected:
[[noreturn]] void RuntimeErrorWithCallStack(const std::string& msg) const;
BroExprTag tag;
IntrusivePtr<BroType> type;
IntrusivePtr<zeek::Type> type;
bool paren;
};
@ -523,10 +524,10 @@ public:
const IntrusivePtr<Attributes>& attrs = nullptr);
IntrusivePtr<Val> Eval(Frame* f) const override;
void EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) const override;
IntrusivePtr<BroType> InitType() const override;
void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const override;
IntrusivePtr<zeek::Type> InitType() const override;
bool IsRecordElement(TypeDecl* td) const override;
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
bool IsPure() const override;
protected:
@ -623,7 +624,7 @@ public:
~RecordConstructorExpr() override;
protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> Fold(Val* v) const override;
void ExprDescribe(ODesc* d) const override;
@ -633,7 +634,7 @@ class TableConstructorExpr final : public UnaryExpr {
public:
TableConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs,
IntrusivePtr<BroType> arg_type = nullptr);
IntrusivePtr<zeek::Type> arg_type = nullptr);
[[deprecated("Remove in v4.1. Use GetAttrs().")]]
Attributes* Attrs() { return attrs.get(); }
@ -644,7 +645,7 @@ public:
IntrusivePtr<Val> Eval(Frame* f) const override;
protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
void ExprDescribe(ODesc* d) const override;
@ -655,7 +656,7 @@ class SetConstructorExpr final : public UnaryExpr {
public:
SetConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs,
IntrusivePtr<BroType> arg_type = nullptr);
IntrusivePtr<zeek::Type> arg_type = nullptr);
[[deprecated("Remove in v4.1. Use GetAttrs().")]]
Attributes* Attrs() { return attrs.get(); }
@ -666,7 +667,7 @@ public:
IntrusivePtr<Val> Eval(Frame* f) const override;
protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
void ExprDescribe(ODesc* d) const override;
@ -676,12 +677,12 @@ protected:
class VectorConstructorExpr final : public UnaryExpr {
public:
explicit VectorConstructorExpr(IntrusivePtr<ListExpr> constructor_list,
IntrusivePtr<BroType> arg_type = nullptr);
IntrusivePtr<zeek::Type> arg_type = nullptr);
IntrusivePtr<Val> Eval(Frame* f) const override;
protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
void ExprDescribe(ODesc* d) const override;
};
@ -692,7 +693,7 @@ public:
const char* FieldName() const { return field_name.c_str(); }
void EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) const override;
void EvalIntoAggregate(const zeek::Type* t, Val* aggr, Frame* f) const override;
bool IsRecordElement(TypeDecl* td) const override;
protected:
@ -703,7 +704,7 @@ protected:
class ArithCoerceExpr final : public UnaryExpr {
public:
ArithCoerceExpr(IntrusivePtr<Expr> op, TypeTag t);
ArithCoerceExpr(IntrusivePtr<Expr> op, zeek::TypeTag t);
protected:
IntrusivePtr<Val> FoldSingleVal(Val* v, InternalTypeTag t) const;
@ -716,7 +717,7 @@ public:
~RecordCoerceExpr() override;
protected:
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Val> Fold(Val* v) const override;
// For each super-record slot, gives subrecord slot with which to
@ -867,15 +868,15 @@ public:
IntrusivePtr<Val> Eval(Frame* f) const override;
IntrusivePtr<BroType> InitType() const override;
IntrusivePtr<Val> InitVal(const BroType* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<zeek::Type> InitType() const override;
IntrusivePtr<Val> InitVal(const zeek::Type* t, IntrusivePtr<Val> aggr) const override;
IntrusivePtr<Expr> MakeLvalue() override;
void Assign(Frame* f, IntrusivePtr<Val> v) override;
TraversalCode Traverse(TraversalCallback* cb) const override;
protected:
IntrusivePtr<Val> AddSetInit(const BroType* t, IntrusivePtr<Val> aggr) const;
IntrusivePtr<Val> AddSetInit(const zeek::Type* t, IntrusivePtr<Val> aggr) const;
void ExprDescribe(ODesc* d) const override;
@ -890,7 +891,7 @@ public:
class CastExpr final : public UnaryExpr {
public:
CastExpr(IntrusivePtr<Expr> op, IntrusivePtr<BroType> t);
CastExpr(IntrusivePtr<Expr> op, IntrusivePtr<zeek::Type> t);
protected:
IntrusivePtr<Val> Eval(Frame* f) const override;
@ -899,14 +900,14 @@ protected:
class IsExpr final : public UnaryExpr {
public:
IsExpr(IntrusivePtr<Expr> op, IntrusivePtr<BroType> t);
IsExpr(IntrusivePtr<Expr> op, IntrusivePtr<zeek::Type> t);
protected:
IntrusivePtr<Val> Fold(Val* v) const override;
void ExprDescribe(ODesc* d) const override;
private:
IntrusivePtr<BroType> t;
IntrusivePtr<zeek::Type> t;
};
inline Val* Expr::ExprVal() const
@ -935,11 +936,11 @@ IntrusivePtr<Expr> get_assign_expr(IntrusivePtr<Expr> op1,
* Returns nullptr if the expression cannot match or a promoted
* expression.
*/
extern IntrusivePtr<Expr> check_and_promote_expr(Expr* e, BroType* t);
extern IntrusivePtr<Expr> check_and_promote_expr(Expr* e, Type* t);
extern bool check_and_promote_exprs(ListExpr* elements, TypeList* types);
extern bool check_and_promote_args(ListExpr* args, RecordType* types);
extern bool check_and_promote_exprs_to_type(ListExpr* elements, BroType* type);
extern bool check_and_promote_exprs_to_type(ListExpr* elements, Type* type);
// Returns a ListExpr simplified down to a list a values, or nil
// if they couldn't all be reduced.
@ -953,3 +954,55 @@ extern bool expr_greater(const Expr* e1, const Expr* e2);
// True if the given Expr* has a vector type
inline bool is_vector(Expr* e) { return e->GetType()->Tag() == TYPE_VECTOR; }
inline bool is_vector(const IntrusivePtr<Expr>& e) { return is_vector(e.get()); }
}
using Expr [[deprecated("Remove in v4.1. Use zeek::detail::Expr instead.")]] = zeek::detail::Expr;
using NameExpr [[deprecated("Remove in v4.1. Use zeek::detail::NameExpr instead.")]] = zeek::detail::NameExpr;
using ConstExpr [[deprecated("Remove in v4.1. Use zeek::detail::ConstExpr instead.")]] = zeek::detail::ConstExpr;
using UnaryExpr [[deprecated("Remove in v4.1. Use zeek::detail::UnaryExpr instead.")]] = zeek::detail::UnaryExpr;
using BinaryExpr [[deprecated("Remove in v4.1. Use zeek::detail::BinaryExpr instead.")]] = zeek::detail::BinaryExpr;
using CloneExpr [[deprecated("Remove in v4.1. Use zeek::detail::CloneExpr instead.")]] = zeek::detail::CloneExpr;
using IncrExpr [[deprecated("Remove in v4.1. Use zeek::detail::IncrExpr instead.")]] = zeek::detail::IncrExpr;
using ComplementExpr [[deprecated("Remove in v4.1. Use zeek::detail::ComplementExpr instead.")]] = zeek::detail::ComplementExpr;
using NotExpr [[deprecated("Remove in v4.1. Use zeek::detail::NotExpr instead.")]] = zeek::detail::NotExpr;
using PosExpr [[deprecated("Remove in v4.1. Use zeek::detail::PosExpr instead.")]] = zeek::detail::PosExpr;
using NegExpr [[deprecated("Remove in v4.1. Use zeek::detail::NegExpr instead.")]] = zeek::detail::NegExpr;
using SizeExpr [[deprecated("Remove in v4.1. Use zeek::detail::SizeExpr instead.")]] = zeek::detail::SizeExpr;
using AddExpr [[deprecated("Remove in v4.1. Use zeek::detail::AddExpr instead.")]] = zeek::detail::AddExpr;
using AddToExpr [[deprecated("Remove in v4.1. Use zeek::detail::AddToExpr instead.")]] = zeek::detail::AddToExpr;
using RemoveFromExpr [[deprecated("Remove in v4.1. Use zeek::detail::RemoveFromExpr instead.")]] = zeek::detail::RemoveFromExpr;
using SubExpr [[deprecated("Remove in v4.1. Use zeek::detail::SubExpr instead.")]] = zeek::detail::SubExpr;
using TimesExpr [[deprecated("Remove in v4.1. Use zeek::detail::TimesExpr instead.")]] = zeek::detail::TimesExpr;
using DivideExpr [[deprecated("Remove in v4.1. Use zeek::detail::DivideExpr instead.")]] = zeek::detail::DivideExpr;
using ModExpr [[deprecated("Remove in v4.1. Use zeek::detail::ModExpr instead.")]] = zeek::detail::ModExpr;
using BoolExpr [[deprecated("Remove in v4.1. Use zeek::detail::BoolExpr instead.")]] = zeek::detail::BoolExpr;
using BitExpr [[deprecated("Remove in v4.1. Use zeek::detail::BitExpr instead.")]] = zeek::detail::BitExpr;
using EqExpr [[deprecated("Remove in v4.1. Use zeek::detail::EqExpr instead.")]] = zeek::detail::EqExpr;
using RelExpr [[deprecated("Remove in v4.1. Use zeek::detail::RelExpr instead.")]] = zeek::detail::RelExpr;
using CondExpr [[deprecated("Remove in v4.1. Use zeek::detail::CondExpr instead.")]] = zeek::detail::CondExpr;
using RefExpr [[deprecated("Remove in v4.1. Use zeek::detail::RefExpr instead.")]] = zeek::detail::RefExpr;
using AssignExpr [[deprecated("Remove in v4.1. Use zeek::detail::AssignExpr instead.")]] = zeek::detail::AssignExpr;
using IndexSliceAssignExpr [[deprecated("Remove in v4.1. Use zeek::detail::IndexSliceAssignExpr instead.")]] = zeek::detail::IndexSliceAssignExpr;
using IndexExpr [[deprecated("Remove in v4.1. Use zeek::detail::IndexExpr instead.")]] = zeek::detail::IndexExpr;
using FieldExpr [[deprecated("Remove in v4.1. Use zeek::detail::FieldExpr instead.")]] = zeek::detail::FieldExpr;
using HasFieldExpr [[deprecated("Remove in v4.1. Use zeek::detail::HasFieldExpr instead.")]] = zeek::detail::HasFieldExpr;
using RecordConstructorExpr [[deprecated("Remove in v4.1. Use zeek::detail::RecordConstructorExpr instead.")]] = zeek::detail::RecordConstructorExpr;
using TableConstructorExpr [[deprecated("Remove in v4.1. Use zeek::detail::TableConstructorExpr instead.")]] = zeek::detail::TableConstructorExpr;
using SetConstructorExpr [[deprecated("Remove in v4.1. Use zeek::detail::SetConstructorExpr instead.")]] = zeek::detail::SetConstructorExpr;
using VectorConstructorExpr [[deprecated("Remove in v4.1. Use zeek::detail::VectorConstructorExpr instead.")]] = zeek::detail::VectorConstructorExpr;
using FieldAssignExpr [[deprecated("Remove in v4.1. Use zeek::detail::FieldAssignExpr instead.")]] = zeek::detail::FieldAssignExpr;
using ArithCoerceExpr [[deprecated("Remove in v4.1. Use zeek::detail::ArithCoerceExpr instead.")]] = zeek::detail::ArithCoerceExpr;
using RecordCoerceExpr [[deprecated("Remove in v4.1. Use zeek::detail::RecordCoerceExpr instead.")]] = zeek::detail::RecordCoerceExpr;
using TableCoerceExpr [[deprecated("Remove in v4.1. Use zeek::detail::TableCoerceExpr instead.")]] = zeek::detail::TableCoerceExpr;
using VectorCoerceExpr [[deprecated("Remove in v4.1. Use zeek::detail::VectorCoerceExpr instead.")]] = zeek::detail::VectorCoerceExpr;
using ScheduleTimer [[deprecated("Remove in v4.1. Use zeek::detail::ScheduleTimer instead.")]] = zeek::detail::ScheduleTimer;
using ScheduleExpr [[deprecated("Remove in v4.1. Use zeek::detail::ScheduleExpr instead.")]] = zeek::detail::ScheduleExpr;
using InExpr [[deprecated("Remove in v4.1. Use zeek::detail::InExpr instead.")]] = zeek::detail::InExpr;
using CallExpr [[deprecated("Remove in v4.1. Use zeek::detail::CallExpr instead.")]] = zeek::detail::CallExpr;
using LambdaExpr [[deprecated("Remove in v4.1. Use zeek::detail::LambdaExpr instead.")]] = zeek::detail::LambdaExpr;
using EventExpr [[deprecated("Remove in v4.1. Use zeek::detail::EventExpr instead.")]] = zeek::detail::EventExpr;
using ListExpr [[deprecated("Remove in v4.1. Use zeek::detail::ListExpr instead.")]] = zeek::detail::ListExpr;
using RecordAssignExpr [[deprecated("Remove in v4.1. Use zeek::detail::RecordAssignExpr instead.")]] = zeek::detail::RecordAssignExpr;
using CastExpr [[deprecated("Remove in v4.1. Use zeek::detail::CastExpr instead.")]] = zeek::detail::CastExpr;
using IsExpr [[deprecated("Remove in v4.1. Use zeek::detail::IsExpr instead.")]] = zeek::detail::IsExpr;

12
src/File.cc
View file

@ -58,7 +58,7 @@ BroFile::BroFile(FILE* arg_f)
Init();
f = arg_f;
name = access = nullptr;
t = base_type(TYPE_STRING);
t = zeek::base_type(zeek::TYPE_STRING);
is_open = (f != nullptr);
}
@ -68,7 +68,7 @@ BroFile::BroFile(FILE* arg_f, const char* arg_name, const char* arg_access)
f = arg_f;
name = copy_string(arg_name);
access = copy_string(arg_access);
t = base_type(TYPE_STRING);
t = zeek::base_type(zeek::TYPE_STRING);
is_open = (f != nullptr);
}
@ -78,7 +78,7 @@ BroFile::BroFile(const char* arg_name, const char* arg_access)
f = nullptr;
name = copy_string(arg_name);
access = copy_string(arg_access);
t = base_type(TYPE_STRING);
t = zeek::base_type(zeek::TYPE_STRING);
if ( streq(name, "/dev/stdin") )
f = stdin;
@ -257,7 +257,7 @@ void BroFile::Describe(ODesc* d) const
d->Add("(no type)");
}
void BroFile::SetAttrs(Attributes* arg_attrs)
void BroFile::SetAttrs(zeek::detail::Attributes* arg_attrs)
{
if ( ! arg_attrs )
return;
@ -265,7 +265,7 @@ void BroFile::SetAttrs(Attributes* arg_attrs)
attrs = arg_attrs;
Ref(attrs);
if ( attrs->Find(ATTR_RAW_OUTPUT) )
if ( attrs->Find(zeek::detail::ATTR_RAW_OUTPUT) )
EnableRawOutput();
}
@ -278,7 +278,7 @@ RecordVal* BroFile::Rotate()
if ( f == stdin || f == stdout || f == stderr )
return nullptr;
static auto rotate_info = zeek::id::find_type<RecordType>("rotate_info");
static auto rotate_info = zeek::id::find_type<zeek::RecordType>("rotate_info");
RecordVal* info = new RecordVal(rotate_info);
FILE* newf = rotate_file(name, info);

33
src/File.h
View file

@ -2,23 +2,28 @@
#pragma once
#include "Obj.h"
#include "IntrusivePtr.h"
#include <list>
#include <string>
#include <utility>
#include <fcntl.h>
# ifdef NEED_KRB5_H
# include <krb5.h>
# endif // NEED_KRB5_H
#ifdef NEED_KRB5_H
#include <krb5.h>
#endif // NEED_KRB5_H
#include "Obj.h"
#include "IntrusivePtr.h"
#include "util.h"
class Attributes;
class BroType;
class RecordVal;
namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
ZEEK_FORWARD_DECLARE_NAMESPACED(PrintStmt, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(Attributes, zeek::detail);
class BroFile final : public BroObj {
public:
explicit BroFile(FILE* arg_f);
@ -38,9 +43,9 @@ public:
void SetBuf(bool buffered); // false=line buffered, true=fully buffered
[[deprecated("Remove in v4.1. Use GetType().")]]
BroType* FType() const { return t.get(); }
zeek::Type* FType() const { return t.get(); }
const IntrusivePtr<BroType>& GetType() const
const IntrusivePtr<zeek::Type>& GetType() const
{ return t; }
// Whether the file is open in a general sense; it might
@ -58,7 +63,7 @@ public:
RecordVal* Rotate();
// Set &raw_output attribute.
void SetAttrs(Attributes* attrs);
void SetAttrs(zeek::detail::Attributes* attrs);
// Returns the current size of the file, after fresh stat'ing.
double Size();
@ -77,7 +82,7 @@ public:
protected:
friend class PrintStmt;
friend class zeek::detail::PrintStmt;
BroFile() { Init(); }
void Init();
@ -101,10 +106,10 @@ protected:
void RaiseOpenEvent();
FILE* f;
IntrusivePtr<BroType> t;
IntrusivePtr<zeek::Type> t;
char* name;
char* access;
Attributes* attrs;
zeek::detail::Attributes* attrs;
double open_time;
bool is_open; // whether the file is open in a general sense
bool buffered;

2
src/Flare.cc
View file

@ -6,7 +6,7 @@
#include <fcntl.h>
#include <errno.h>
using namespace bro;
using namespace zeek::detail;
Flare::Flare()
: pipe(FD_CLOEXEC, FD_CLOEXEC, O_NONBLOCK, O_NONBLOCK)

7
src/Flare.h
View file

@ -4,7 +4,7 @@
#include "Pipe.h"
namespace bro {
namespace zeek::detail {
class Flare {
public:
@ -21,8 +21,7 @@ public:
* @return a file descriptor that will become ready if the flare has been
* Fire()'d and not yet Extinguished()'d.
*/
int FD() const
{ return pipe.ReadFD(); }
int FD() const { return pipe.ReadFD(); }
/**
* Put the object in the "ready" state.
@ -44,4 +43,4 @@ private:
Pipe pipe;
};
} // namespace bro
} // namespace zeek::detail

20
src/Frame.cc
View file

@ -77,7 +77,7 @@ void Frame::SetElementWeak(int n, Val* v)
frame[n] = {{AdoptRef{}, v}, true};
}
void Frame::SetElement(const ID* id, IntrusivePtr<Val> v)
void Frame::SetElement(const zeek::detail::ID* id, IntrusivePtr<Val> v)
{
if ( closure )
{
@ -106,7 +106,7 @@ void Frame::SetElement(const ID* id, IntrusivePtr<Val> v)
SetElement(id->Offset(), std::move(v));
}
const IntrusivePtr<Val>& Frame::GetElementByID(const ID* id) const
const IntrusivePtr<Val>& Frame::GetElementByID(const zeek::detail::ID* id) const
{
if ( closure )
{
@ -175,7 +175,7 @@ Frame* Frame::Clone() const
static bool val_is_func(const IntrusivePtr<Val>& v, BroFunc* func)
{
if ( v->GetType()->Tag() != TYPE_FUNC )
if ( v->GetType()->Tag() != zeek::TYPE_FUNC )
return false;
return v->AsFunc() == func;
@ -333,7 +333,7 @@ broker::expected<broker::data> Frame::Serialize(const Frame* target, const id_li
const auto& val = target->frame[location].val;
TypeTag tag = val->GetType()->Tag();
zeek::TypeTag tag = val->GetType()->Tag();
auto expected = bro_broker::val_to_data(val.get());
if ( ! expected )
@ -460,7 +460,7 @@ std::pair<bool, IntrusivePtr<Frame>> Frame::Unserialize(const broker::vector& da
return std::make_pair(false, nullptr);
broker::integer g = *has_type;
BroType t( static_cast<TypeTag>(g) );
zeek::Type t( static_cast<zeek::TypeTag>(g) );
auto val = bro_broker::data_to_val(std::move(val_tuple[0]), &t);
if ( ! val )
@ -478,7 +478,7 @@ void Frame::AddKnownOffsets(const id_list& ids)
offset_map = std::make_unique<OffsetMap>();
std::transform(ids.begin(), ids.end(), std::inserter(*offset_map, offset_map->end()),
[] (const ID* id) -> std::pair<std::string, int>
[] (const zeek::detail::ID* id) -> std::pair<std::string, int>
{
return std::make_pair(std::string(id->Name()), id->Offset());
});
@ -505,7 +505,7 @@ void Frame::CaptureClosure(Frame* c, id_list arg_outer_ids)
// if (c) closure = c->SelectiveClone(outer_ids);
}
void Frame::SetTrigger(IntrusivePtr<trigger::Trigger> arg_trigger)
void Frame::SetTrigger(IntrusivePtr<zeek::detail::trigger::Trigger> arg_trigger)
{
trigger = std::move(arg_trigger);
}
@ -523,10 +523,10 @@ void Frame::ClearElement(int n)
frame[n] = {nullptr, false};
}
bool Frame::IsOuterID(const ID* in) const
bool Frame::IsOuterID(const zeek::detail::ID* in) const
{
return std::any_of(outer_ids.begin(), outer_ids.end(),
[&in](ID* id)-> bool { return strcmp(id->Name(), in->Name()) == 0; });
[&in](zeek::detail::ID* id)-> bool { return strcmp(id->Name(), in->Name()) == 0; });
}
broker::expected<broker::data> Frame::SerializeIDList(const id_list& in)
@ -588,7 +588,7 @@ Frame::UnserializeIDList(const broker::vector& data)
return std::make_pair(false, std::move(rval));
}
ID* id = new ID(has_name->c_str(), SCOPE_FUNCTION, false);
auto* id = new zeek::detail::ID(has_name->c_str(), zeek::detail::SCOPE_FUNCTION, false);
id->SetOffset(*has_offset);
rval.push_back(id);
std::advance(where, 1);

35
src/Frame.h
View file

@ -16,10 +16,11 @@
#include <broker/data.hh>
#include <broker/expected.hh>
namespace trigger { class Trigger; }
class CallExpr;
class BroFunc;
ZEEK_FORWARD_DECLARE_NAMESPACED(CallExpr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(Trigger, zeek::detail::trigger);
class Frame : public BroObj {
public:
/**
@ -65,8 +66,8 @@ public:
* @param id the ID to associate
* @param v the value to associate it with
*/
void SetElement(const ID* id, IntrusivePtr<Val> v);
void SetElement(const IntrusivePtr<ID>& id, IntrusivePtr<Val> v)
void SetElement(const zeek::detail::ID* id, IntrusivePtr<Val> v);
void SetElement(const IntrusivePtr<zeek::detail::ID>& id, IntrusivePtr<Val> v)
{ SetElement(id.get(), std::move(v)); }
/**
@ -76,11 +77,11 @@ public:
* @param id the id who's value to retreive
* @return the value associated with *id*
*/
const IntrusivePtr<Val>& GetElementByID(const IntrusivePtr<ID>& id) const
const IntrusivePtr<Val>& GetElementByID(const IntrusivePtr<zeek::detail::ID>& id) const
{ return GetElementByID(id.get()); }
[[deprecated("Remove in v4.1. Use GetElementByID().")]]
Val* GetElement(const ID* id) const
Val* GetElement(const zeek::detail::ID* id) const
{ return GetElementByID(id).get(); }
/**
@ -118,12 +119,12 @@ public:
*
* @param stmt the statement to set it to.
*/
void SetNextStmt(Stmt* stmt) { next_stmt = stmt; }
void SetNextStmt(zeek::detail::Stmt* stmt) { next_stmt = stmt; }
/**
* @return the next statement to be executed in the context of the frame.
*/
Stmt* GetNextStmt() const { return next_stmt; }
zeek::detail::Stmt* GetNextStmt() const { return next_stmt; }
/** Used to implement "next" command in debugger. */
void BreakBeforeNextStmt(bool should_break)
@ -215,13 +216,13 @@ public:
// If the frame is run in the context of a trigger condition evaluation,
// the trigger needs to be registered.
void SetTrigger(IntrusivePtr<trigger::Trigger> arg_trigger);
void SetTrigger(IntrusivePtr<zeek::detail::trigger::Trigger> arg_trigger);
void ClearTrigger();
trigger::Trigger* GetTrigger() const { return trigger.get(); }
zeek::detail::trigger::Trigger* GetTrigger() const { return trigger.get(); }
void SetCall(const CallExpr* arg_call) { call = arg_call; }
void SetCall(const zeek::detail::CallExpr* arg_call) { call = arg_call; }
void ClearCall() { call = nullptr; }
const CallExpr* GetCall() const { return call; }
const zeek::detail::CallExpr* GetCall() const { return call; }
void SetDelayed() { delayed = true; }
bool HasDelayed() const { return delayed; }
@ -246,7 +247,7 @@ private:
bool weak_ref;
};
const IntrusivePtr<Val>& GetElementByID(const ID* id) const;
const IntrusivePtr<Val>& GetElementByID(const zeek::detail::ID* id) const;
/**
* Sets the element at index *n* of the underlying array to *v*, but does
@ -272,7 +273,7 @@ private:
void ClearElement(int n);
/** Have we captured this id? */
bool IsOuterID(const ID* in) const;
bool IsOuterID(const zeek::detail::ID* in) const;
/** Serializes an offset_map */
static broker::expected<broker::data>
@ -319,10 +320,10 @@ private:
const zeek::Args* func_args;
/** The next statement to be evaluted in the context of this frame. */
Stmt* next_stmt;
zeek::detail::Stmt* next_stmt;
IntrusivePtr<trigger::Trigger> trigger;
const CallExpr* call;
IntrusivePtr<zeek::detail::trigger::Trigger> trigger;
const zeek::detail::CallExpr* call;
std::unique_ptr<std::vector<BroFunc*>> functions_with_closure_frame_reference;
};

109
src/Func.cc
View file

@ -121,8 +121,8 @@ Func::Func(Kind arg_kind) : kind(arg_kind)
Func::~Func() = default;
void Func::AddBody(IntrusivePtr<Stmt> /* new_body */,
const std::vector<IntrusivePtr<ID>>& /* new_inits */,
void Func::AddBody(IntrusivePtr<zeek::detail::Stmt> /* new_body */,
const std::vector<IntrusivePtr<zeek::detail::ID>>& /* new_inits */,
size_t /* new_frame_size */, int /* priority */)
{
Internal("Func::AddBody called");
@ -216,7 +216,7 @@ void Func::CopyStateInto(Func* other) const
}
void Func::CheckPluginResult(bool handled, const IntrusivePtr<Val>& hook_result,
function_flavor flavor) const
zeek::FunctionFlavor flavor) const
{
// Helper function factoring out this code from BroFunc:Call() for
// better readability.
@ -232,32 +232,32 @@ void Func::CheckPluginResult(bool handled, const IntrusivePtr<Val>& hook_result,
}
switch ( flavor ) {
case FUNC_FLAVOR_EVENT:
case zeek::FUNC_FLAVOR_EVENT:
if ( hook_result )
reporter->InternalError("plugin returned non-void result for event %s",
this->Name());
break;
case FUNC_FLAVOR_HOOK:
if ( hook_result->GetType()->Tag() != TYPE_BOOL )
case zeek::FUNC_FLAVOR_HOOK:
if ( hook_result->GetType()->Tag() != zeek::TYPE_BOOL )
reporter->InternalError("plugin returned non-bool for hook %s",
this->Name());
break;
case FUNC_FLAVOR_FUNCTION:
case zeek::FUNC_FLAVOR_FUNCTION:
{
const auto& yt = GetType()->Yield();
if ( (! yt) || yt->Tag() == TYPE_VOID )
if ( (! yt) || yt->Tag() == zeek::TYPE_VOID )
{
if ( hook_result )
reporter->InternalError("plugin returned non-void result for void method %s",
this->Name());
}
else if ( hook_result && hook_result->GetType()->Tag() != yt->Tag() && yt->Tag() != TYPE_ANY )
else if ( hook_result && hook_result->GetType()->Tag() != yt->Tag() && yt->Tag() != zeek::TYPE_ANY )
{
reporter->InternalError("plugin returned wrong type (got %d, expecting %d) for %s",
hook_result->GetType()->Tag(), yt->Tag(), this->Name());
@ -268,13 +268,13 @@ void Func::CheckPluginResult(bool handled, const IntrusivePtr<Val>& hook_result,
}
}
BroFunc::BroFunc(const IntrusivePtr<ID>& arg_id, IntrusivePtr<Stmt> arg_body,
const std::vector<IntrusivePtr<ID>>& aggr_inits,
BroFunc::BroFunc(const IntrusivePtr<zeek::detail::ID>& arg_id, IntrusivePtr<zeek::detail::Stmt> arg_body,
const std::vector<IntrusivePtr<zeek::detail::ID>>& aggr_inits,
size_t arg_frame_size, int priority)
: Func(BRO_FUNC)
{
name = arg_id->Name();
type = arg_id->GetType<FuncType>();
type = arg_id->GetType<zeek::FuncType>();
frame_size = arg_frame_size;
if ( arg_body )
@ -326,8 +326,8 @@ IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
if ( bodies.empty() )
{
// Can only happen for events and hooks.
assert(Flavor() == FUNC_FLAVOR_EVENT || Flavor() == FUNC_FLAVOR_HOOK);
return Flavor() == FUNC_FLAVOR_HOOK ? val_mgr->True() : nullptr;
assert(Flavor() == zeek::FUNC_FLAVOR_EVENT || Flavor() == zeek::FUNC_FLAVOR_HOOK);
return Flavor() == zeek::FUNC_FLAVOR_HOOK ? val_mgr->True() : nullptr;
}
auto f = make_intrusive<Frame>(frame_size, this, args);
@ -343,7 +343,7 @@ IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
}
g_frame_stack.push_back(f.get()); // used for backtracing
const CallExpr* call_expr = parent ? parent->GetCall() : nullptr;
const zeek::detail::CallExpr* call_expr = parent ? parent->GetCall() : nullptr;
call_stack.emplace_back(CallInfo{call_expr, this, *args});
if ( g_trace_state.DoTrace() )
@ -384,7 +384,7 @@ IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
catch ( InterpreterException& e )
{
// Already reported, but now determine whether to unwind further.
if ( Flavor() == FUNC_FLAVOR_FUNCTION )
if ( Flavor() == zeek::FUNC_FLAVOR_FUNCTION )
{
g_frame_stack.pop_back();
call_stack.pop_back();
@ -404,7 +404,7 @@ IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
break;
}
if ( Flavor() == FUNC_FLAVOR_HOOK )
if ( Flavor() == zeek::FUNC_FLAVOR_HOOK )
{
// Ignore any return values of hook bodies, final return value
// depends on whether a body returns as a result of break statement.
@ -421,7 +421,7 @@ IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
call_stack.pop_back();
if ( Flavor() == FUNC_FLAVOR_HOOK )
if ( Flavor() == zeek::FUNC_FLAVOR_HOOK )
{
if ( ! result )
result = val_mgr->True();
@ -429,7 +429,7 @@ IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
// Warn if the function returns something, but we returned from
// the function without an explicit return, or without a value.
else if ( GetType()->Yield() && GetType()->Yield()->Tag() != TYPE_VOID &&
else if ( GetType()->Yield() && GetType()->Yield()->Tag() != zeek::TYPE_VOID &&
(flow != FLOW_RETURN /* we fell off the end */ ||
! result /* explicit return with no result */) &&
! f->HasDelayed() )
@ -449,8 +449,8 @@ IntrusivePtr<Val> BroFunc::Invoke(zeek::Args* args, Frame* parent) const
return result;
}
void BroFunc::AddBody(IntrusivePtr<Stmt> new_body,
const std::vector<IntrusivePtr<ID>>& new_inits,
void BroFunc::AddBody(IntrusivePtr<zeek::detail::Stmt> new_body,
const std::vector<IntrusivePtr<zeek::detail::ID>>& new_inits,
size_t new_frame_size, int priority)
{
if ( new_frame_size > frame_size )
@ -463,7 +463,7 @@ void BroFunc::AddBody(IntrusivePtr<Stmt> new_body,
new_body = AddInits(std::move(new_body), new_inits);
if ( Flavor() == FUNC_FLAVOR_FUNCTION )
if ( Flavor() == zeek::FUNC_FLAVOR_FUNCTION )
{
// For functions, we replace the old body with the new one.
assert(bodies.size() <= 1);
@ -574,14 +574,14 @@ void BroFunc::Describe(ODesc* d) const
}
}
IntrusivePtr<Stmt> BroFunc::AddInits(IntrusivePtr<Stmt> body,
const std::vector<IntrusivePtr<ID>>& inits)
IntrusivePtr<zeek::detail::Stmt> BroFunc::AddInits(IntrusivePtr<zeek::detail::Stmt> body,
const std::vector<IntrusivePtr<zeek::detail::ID>>& inits)
{
if ( inits.empty() )
return body;
auto stmt_series = make_intrusive<StmtList>();
stmt_series->Stmts().push_back(new InitStmt(inits));
auto stmt_series = make_intrusive<zeek::detail::StmtList>();
stmt_series->Stmts().push_back(new zeek::detail::InitStmt(inits));
stmt_series->Stmts().push_back(body.release());
return stmt_series;
@ -601,7 +601,7 @@ BuiltinFunc::BuiltinFunc(built_in_func arg_func, const char* arg_name,
if ( id->HasVal() )
reporter->InternalError("built-in function %s multiply defined", Name());
type = id->GetType<FuncType>();
type = id->GetType<zeek::FuncType>();
id->SetVal(make_intrusive<Val>(IntrusivePtr{NewRef{}, this}));
}
@ -628,7 +628,7 @@ IntrusivePtr<Val> BuiltinFunc::Invoke(zeek::Args* args, Frame* parent) const
HookCallFunction(this, parent, args),
empty_hook_result);
CheckPluginResult(handled, hook_result, FUNC_FLAVOR_FUNCTION);
CheckPluginResult(handled, hook_result, zeek::FUNC_FLAVOR_FUNCTION);
if ( handled )
return hook_result;
@ -641,7 +641,7 @@ IntrusivePtr<Val> BuiltinFunc::Invoke(zeek::Args* args, Frame* parent) const
g_trace_state.LogTrace("\tBuiltin Function called: %s\n", d.Description());
}
const CallExpr* call_expr = parent ? parent->GetCall() : nullptr;
const zeek::detail::CallExpr* call_expr = parent ? parent->GetCall() : nullptr;
call_stack.emplace_back(CallInfo{call_expr, this, *args});
auto result = std::move(func(parent, args).rval);
call_stack.pop_back();
@ -675,7 +675,7 @@ void builtin_error(const char* msg, IntrusivePtr<Val> arg)
void builtin_error(const char* msg, BroObj* arg)
{
auto emit = [=](const CallExpr* ce)
auto emit = [=](const zeek::detail::CallExpr* ce)
{
if ( ce )
ce->Error(msg, arg);
@ -758,19 +758,19 @@ void builtin_error(const char* msg, BroObj* arg)
void init_builtin_funcs()
{
ProcStats = zeek::id::find_type<RecordType>("ProcStats");
NetStats = zeek::id::find_type<RecordType>("NetStats");
MatcherStats = zeek::id::find_type<RecordType>("MatcherStats");
ConnStats = zeek::id::find_type<RecordType>("ConnStats");
ReassemblerStats = zeek::id::find_type<RecordType>("ReassemblerStats");
DNSStats = zeek::id::find_type<RecordType>("DNSStats");
GapStats = zeek::id::find_type<RecordType>("GapStats");
EventStats = zeek::id::find_type<RecordType>("EventStats");
TimerStats = zeek::id::find_type<RecordType>("TimerStats");
FileAnalysisStats = zeek::id::find_type<RecordType>("FileAnalysisStats");
ThreadStats = zeek::id::find_type<RecordType>("ThreadStats");
BrokerStats = zeek::id::find_type<RecordType>("BrokerStats");
ReporterStats = zeek::id::find_type<RecordType>("ReporterStats");
ProcStats = zeek::id::find_type<zeek::RecordType>("ProcStats");
NetStats = zeek::id::find_type<zeek::RecordType>("NetStats");
MatcherStats = zeek::id::find_type<zeek::RecordType>("MatcherStats");
ConnStats = zeek::id::find_type<zeek::RecordType>("ConnStats");
ReassemblerStats = zeek::id::find_type<zeek::RecordType>("ReassemblerStats");
DNSStats = zeek::id::find_type<zeek::RecordType>("DNSStats");
GapStats = zeek::id::find_type<zeek::RecordType>("GapStats");
EventStats = zeek::id::find_type<zeek::RecordType>("EventStats");
TimerStats = zeek::id::find_type<zeek::RecordType>("TimerStats");
FileAnalysisStats = zeek::id::find_type<zeek::RecordType>("FileAnalysisStats");
ThreadStats = zeek::id::find_type<zeek::RecordType>("ThreadStats");
BrokerStats = zeek::id::find_type<zeek::RecordType>("BrokerStats");
ReporterStats = zeek::id::find_type<zeek::RecordType>("ReporterStats");
var_sizes = zeek::id::find_type("var_sizes")->AsTableType();
@ -789,7 +789,7 @@ void init_builtin_funcs_subdirs()
#include "__all__.bif.init.cc" // Autogenerated for compiling in the bif_target() code.
}
bool check_built_in_call(BuiltinFunc* f, CallExpr* call)
bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call)
{
if ( f->TheFunc() != zeek::BifFunc::fmt_bif)
return true;
@ -802,8 +802,8 @@ bool check_built_in_call(BuiltinFunc* f, CallExpr* call)
return true;
}
const Expr* fmt_str_arg = args[0];
if ( fmt_str_arg->GetType()->Tag() != TYPE_STRING )
const zeek::detail::Expr* fmt_str_arg = args[0];
if ( fmt_str_arg->GetType()->Tag() != zeek::TYPE_STRING )
{
call->Error("first argument to fmt() needs to be a format string");
return false;
@ -844,16 +844,16 @@ bool check_built_in_call(BuiltinFunc* f, CallExpr* call)
// Gets a function's priority from its Scope's attributes. Errors if it sees any
// problems.
static int get_func_priority(const std::vector<IntrusivePtr<Attr>>& attrs)
static int get_func_priority(const std::vector<IntrusivePtr<zeek::detail::Attr>>& attrs)
{
int priority = 0;
for ( const auto& a : attrs )
{
if ( a->Tag() == ATTR_DEPRECATED )
if ( a->Tag() == zeek::detail::ATTR_DEPRECATED )
continue;
if ( a->Tag() != ATTR_PRIORITY )
if ( a->Tag() != zeek::detail::ATTR_PRIORITY )
{
a->Error("illegal attribute for function body");
continue;
@ -867,7 +867,7 @@ static int get_func_priority(const std::vector<IntrusivePtr<Attr>>& attrs)
continue;
}
if ( ! IsIntegral(v->GetType()->Tag()) )
if ( ! zeek::IsIntegral(v->GetType()->Tag()) )
{
a->Error("expression is not of integral type");
continue;
@ -879,7 +879,7 @@ static int get_func_priority(const std::vector<IntrusivePtr<Attr>>& attrs)
return priority;
}
function_ingredients::function_ingredients(IntrusivePtr<Scope> scope, IntrusivePtr<Stmt> body)
function_ingredients::function_ingredients(IntrusivePtr<Scope> scope, IntrusivePtr<zeek::detail::Stmt> body)
{
frame_size = scope->Length();
inits = scope->GetInits();
@ -892,10 +892,3 @@ function_ingredients::function_ingredients(IntrusivePtr<Scope> scope, IntrusiveP
priority = (attrs ? get_func_priority(*attrs) : 0);
this->body = std::move(body);
}
BifReturnVal::BifReturnVal(std::nullptr_t) noexcept
{ }
BifReturnVal::BifReturnVal(Val* v) noexcept
: rval(AdoptRef{}, v)
{ }

86
src/Func.h
View file

@ -9,25 +9,33 @@
#include <tuple>
#include <type_traits>
#include <broker/data.hh>
#include <broker/expected.hh>
#include "BroList.h"
#include "Obj.h"
#include "IntrusivePtr.h"
#include "Type.h" /* for function_flavor */
#include "TraverseTypes.h"
#include "ZeekArgs.h"
#include "BifReturnVal.h"
class Val;
class ListExpr;
class FuncType;
class Stmt;
class Frame;
class ID;
class CallExpr;
class Scope;
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(CallExpr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(FuncType, zeek);
namespace caf {
template <class> class expected;
}
namespace broker {
class data;
using vector = std::vector<data>;
using caf::expected;
}
class Func : public BroObj {
public:
static inline const IntrusivePtr<Func> nil;
@ -39,10 +47,10 @@ public:
~Func() override;
virtual bool IsPure() const = 0;
function_flavor Flavor() const { return GetType()->Flavor(); }
zeek::FunctionFlavor Flavor() const { return GetType()->Flavor(); }
struct Body {
IntrusivePtr<Stmt> stmts;
IntrusivePtr<zeek::detail::Stmt> stmts;
int priority;
bool operator<(const Body& other) const
{ return priority > other.priority; } // reverse sort
@ -78,17 +86,17 @@ public:
}
// Add a new event handler to an existing function (event).
virtual void AddBody(IntrusivePtr<Stmt> new_body,
const std::vector<IntrusivePtr<ID>>& new_inits,
virtual void AddBody(IntrusivePtr<zeek::detail::Stmt> new_body,
const std::vector<IntrusivePtr<zeek::detail::ID>>& new_inits,
size_t new_frame_size, int priority = 0);
virtual void SetScope(IntrusivePtr<Scope> newscope);
virtual Scope* GetScope() const { return scope.get(); }
[[deprecated("Remove in v4.1. Use GetType().")]]
virtual FuncType* FType() const { return type.get(); }
virtual zeek::FuncType* FType() const { return type.get(); }
const IntrusivePtr<FuncType>& GetType() const
const IntrusivePtr<zeek::FuncType>& GetType() const
{ return type; }
Kind GetKind() const { return kind; }
@ -115,13 +123,13 @@ protected:
// Helper function for checking result of plugin hook.
void CheckPluginResult(bool handled, const IntrusivePtr<Val>& hook_result,
function_flavor flavor) const;
zeek::FunctionFlavor flavor) const;
std::vector<Body> bodies;
IntrusivePtr<Scope> scope;
Kind kind;
uint32_t unique_id;
IntrusivePtr<FuncType> type;
IntrusivePtr<zeek::FuncType> type;
std::string name;
static inline std::vector<IntrusivePtr<Func>> unique_ids;
};
@ -129,8 +137,8 @@ protected:
class BroFunc final : public Func {
public:
BroFunc(const IntrusivePtr<ID>& id, IntrusivePtr<Stmt> body,
const std::vector<IntrusivePtr<ID>>& inits,
BroFunc(const IntrusivePtr<zeek::detail::ID>& id, IntrusivePtr<zeek::detail::Stmt> body,
const std::vector<IntrusivePtr<zeek::detail::ID>>& inits,
size_t frame_size, int priority);
~BroFunc() override;
@ -167,8 +175,8 @@ public:
*/
broker::expected<broker::data> SerializeClosure() const;
void AddBody(IntrusivePtr<Stmt> new_body,
const std::vector<IntrusivePtr<ID>>& new_inits,
void AddBody(IntrusivePtr<zeek::detail::Stmt> new_body,
const std::vector<IntrusivePtr<zeek::detail::ID>>& new_inits,
size_t new_frame_size, int priority) override;
/** Sets this function's outer_id list. */
@ -179,8 +187,9 @@ public:
protected:
BroFunc() : Func(BRO_FUNC) {}
IntrusivePtr<Stmt> AddInits(IntrusivePtr<Stmt> body,
const std::vector<IntrusivePtr<ID>>& inits);
IntrusivePtr<zeek::detail::Stmt> AddInits(
IntrusivePtr<zeek::detail::Stmt> body,
const std::vector<IntrusivePtr<zeek::detail::ID>>& inits);
/**
* Clones this function along with its closures.
@ -205,27 +214,6 @@ private:
bool weak_closure_ref = false;
};
/**
* A simple wrapper class to use for the return value of BIFs so that
* they may return either a Val* or IntrusivePtr<Val> (the former could
* potentially be deprecated).
*/
class BifReturnVal {
public:
template <typename T>
BifReturnVal(IntrusivePtr<T> v) noexcept
: rval(AdoptRef{}, v.release())
{ }
BifReturnVal(std::nullptr_t) noexcept;
[[deprecated("Remove in v4.1. Return an IntrusivePtr instead.")]]
BifReturnVal(Val* v) noexcept;
IntrusivePtr<Val> rval;
};
using built_in_func = BifReturnVal (*)(Frame* frame, const zeek::Args* args);
class BuiltinFunc final : public Func {
@ -253,10 +241,10 @@ extern void builtin_error(const char* msg, BroObj* arg);
extern void init_builtin_funcs();
extern void init_builtin_funcs_subdirs();
extern bool check_built_in_call(BuiltinFunc* f, CallExpr* call);
extern bool check_built_in_call(BuiltinFunc* f, zeek::detail::CallExpr* call);
struct CallInfo {
const CallExpr* call;
const zeek::detail::CallExpr* call;
const Func* func;
const zeek::Args& args;
};
@ -267,11 +255,11 @@ struct function_ingredients {
// Gathers all of the information from a scope and a function body needed
// to build a function.
function_ingredients(IntrusivePtr<Scope> scope, IntrusivePtr<Stmt> body);
function_ingredients(IntrusivePtr<Scope> scope, IntrusivePtr<zeek::detail::Stmt> body);
IntrusivePtr<ID> id;
IntrusivePtr<Stmt> body;
std::vector<IntrusivePtr<ID>> inits;
IntrusivePtr<zeek::detail::ID> id;
IntrusivePtr<zeek::detail::Stmt> body;
std::vector<IntrusivePtr<zeek::detail::ID>> inits;
int frame_size;
int priority;
IntrusivePtr<Scope> scope;

4
src/Hash.cc
View file

@ -13,6 +13,10 @@
#include "highwayhash/highwayhash_target.h"
#include "highwayhash/instruction_sets.h"
alignas(32) uint64_t KeyedHash::shared_highwayhash_key[4];
alignas(32) uint64_t KeyedHash::cluster_highwayhash_key[4];
alignas(16) unsigned long long KeyedHash::shared_siphash_key[2];
// we use the following lines to not pull in the highwayhash headers in Hash.h - but to check the types did not change underneath us.
static_assert(std::is_same<hash64_t, highwayhash::HHResult64>::value, "Highwayhash return values must match hash_x_t");
static_assert(std::is_same<hash128_t, highwayhash::HHResult128>::value, "Highwayhash return values must match hash_x_t");

6
src/Hash.h
View file

@ -186,11 +186,11 @@ public:
private:
// actually HHKey. This key changes each start (unless a seed is specified)
alignas(32) inline static uint64_t shared_highwayhash_key[4];
alignas(32) static uint64_t shared_highwayhash_key[4];
// actually HHKey. This key is installation specific and sourced from the digest_salt script-level const.
alignas(32) inline static uint64_t cluster_highwayhash_key[4];
alignas(32) static uint64_t cluster_highwayhash_key[4];
// actually HH_U64, which has the same type. This key changes each start (unless a seed is specified)
alignas(16) inline static unsigned long long shared_siphash_key[2];
alignas(16) static unsigned long long shared_siphash_key[2];
// This key changes each start (unless a seed is specified)
inline static uint8_t shared_hmac_md5_key[16];
inline static bool seeds_initialized = false;

89
src/ID.cc
View file

@ -19,24 +19,24 @@
#include "zeekygen/ScriptInfo.h"
#include "module_util.h"
IntrusivePtr<RecordType> zeek::id::conn_id;
IntrusivePtr<RecordType> zeek::id::endpoint;
IntrusivePtr<RecordType> zeek::id::connection;
IntrusivePtr<RecordType> zeek::id::fa_file;
IntrusivePtr<RecordType> zeek::id::fa_metadata;
IntrusivePtr<EnumType> zeek::id::transport_proto;
IntrusivePtr<TableType> zeek::id::string_set;
IntrusivePtr<TableType> zeek::id::string_array;
IntrusivePtr<TableType> zeek::id::count_set;
IntrusivePtr<VectorType> zeek::id::string_vec;
IntrusivePtr<VectorType> zeek::id::index_vec;
IntrusivePtr<zeek::RecordType> zeek::id::conn_id;
IntrusivePtr<zeek::RecordType> zeek::id::endpoint;
IntrusivePtr<zeek::RecordType> zeek::id::connection;
IntrusivePtr<zeek::RecordType> zeek::id::fa_file;
IntrusivePtr<zeek::RecordType> zeek::id::fa_metadata;
IntrusivePtr<zeek::EnumType> zeek::id::transport_proto;
IntrusivePtr<zeek::TableType> zeek::id::string_set;
IntrusivePtr<zeek::TableType> zeek::id::string_array;
IntrusivePtr<zeek::TableType> zeek::id::count_set;
IntrusivePtr<zeek::VectorType> zeek::id::string_vec;
IntrusivePtr<zeek::VectorType> zeek::id::index_vec;
const IntrusivePtr<ID>& zeek::id::find(std::string_view name)
const IntrusivePtr<zeek::detail::ID>& zeek::id::find(std::string_view name)
{
return global_scope()->Find(name);
}
const IntrusivePtr<BroType>& zeek::id::find_type(std::string_view name)
const IntrusivePtr<zeek::Type>& zeek::id::find_type(std::string_view name)
{
auto id = global_scope()->Find(name);
@ -89,19 +89,21 @@ IntrusivePtr<Func> zeek::id::find_func(std::string_view name)
void zeek::id::detail::init()
{
conn_id = zeek::id::find_type<RecordType>("conn_id");
endpoint = zeek::id::find_type<RecordType>("endpoint");
connection = zeek::id::find_type<RecordType>("connection");
fa_file = zeek::id::find_type<RecordType>("fa_file");
fa_metadata = zeek::id::find_type<RecordType>("fa_metadata");
transport_proto = zeek::id::find_type<EnumType>("transport_proto");
string_set = zeek::id::find_type<TableType>("string_set");
string_array = zeek::id::find_type<TableType>("string_array");
count_set = zeek::id::find_type<TableType>("count_set");
string_vec = zeek::id::find_type<VectorType>("string_vec");
index_vec = zeek::id::find_type<VectorType>("index_vec");
conn_id = zeek::id::find_type<zeek::RecordType>("conn_id");
endpoint = zeek::id::find_type<zeek::RecordType>("endpoint");
connection = zeek::id::find_type<zeek::RecordType>("connection");
fa_file = zeek::id::find_type<zeek::RecordType>("fa_file");
fa_metadata = zeek::id::find_type<zeek::RecordType>("fa_metadata");
transport_proto = zeek::id::find_type<zeek::EnumType>("transport_proto");
string_set = zeek::id::find_type<zeek::TableType>("string_set");
string_array = zeek::id::find_type<zeek::TableType>("string_array");
count_set = zeek::id::find_type<zeek::TableType>("count_set");
string_vec = zeek::id::find_type<zeek::VectorType>("string_vec");
index_vec = zeek::id::find_type<zeek::VectorType>("index_vec");
}
namespace zeek::detail {
ID::ID(const char* arg_name, IDScope arg_scope, bool arg_is_export)
{
name = copy_string(arg_name);
@ -118,6 +120,12 @@ ID::ID(const char* arg_name, IDScope arg_scope, bool arg_is_export)
SetLocationInfo(&start_location, &end_location);
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
ID::ID(const char* arg_name, ::IDScope arg_scope, bool arg_is_export) :
ID(arg_name, static_cast<IDScope>(arg_scope), arg_is_export) {}
#pragma GCC diagnostic pop
ID::~ID()
{
delete [] name;
@ -128,7 +136,7 @@ std::string ID::ModuleName() const
return extract_module_name(name);
}
void ID::SetType(IntrusivePtr<BroType> t)
void ID::SetType(IntrusivePtr<zeek::Type> t)
{
type = std::move(t);
}
@ -215,6 +223,19 @@ void ID::SetVal(IntrusivePtr<Expr> ev, init_class c)
EvalFunc(a->GetExpr(), std::move(ev));
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
void ID::SetVal(IntrusivePtr<Val> v, ::init_class c)
{
SetVal(v, static_cast<init_class>(c));
}
void ID::SetVal(IntrusivePtr<Expr> ev, ::init_class c)
{
SetVal(ev, static_cast<init_class>(c));
}
#pragma GCC diagnostic pop
bool ID::IsRedefinable() const
{
return GetAttr(ATTR_REDEF) != nullptr;
@ -252,7 +273,7 @@ void ID::UpdateValAttrs()
if ( attr )
{
// Apply &log to all record fields.
RecordType* rt = GetType()->AsRecordType();
zeek::RecordType* rt = GetType()->AsRecordType();
for ( int i = 0; i < rt->NumFields(); ++i )
{
TypeDecl* fd = rt->FieldDecl(i);
@ -292,7 +313,7 @@ std::string ID::GetDeprecationWarning() const
if ( depr_attr )
{
auto expr = static_cast<ConstExpr*>(depr_attr->GetExpr().get());
auto expr = static_cast<zeek::detail::ConstExpr*>(depr_attr->GetExpr().get());
if ( expr )
{
StringVal* text = expr->Value()->AsStringVal();
@ -322,6 +343,14 @@ void ID::RemoveAttr(attr_tag a)
attrs->RemoveAttr(a);
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
void ID::RemoveAttr(::attr_tag a)
{
RemoveAttr(static_cast<attr_tag>(a));
}
#pragma GCC diagnostic pop
void ID::SetOption()
{
if ( is_option )
@ -339,8 +368,8 @@ void ID::SetOption()
void ID::EvalFunc(IntrusivePtr<Expr> ef, IntrusivePtr<Expr> ev)
{
auto arg1 = make_intrusive<ConstExpr>(val);
auto args = make_intrusive<ListExpr>();
auto arg1 = make_intrusive<zeek::detail::ConstExpr>(val);
auto args = make_intrusive<zeek::detail::ListExpr>();
args->Append(std::move(arg1));
args->Append(std::move(ev));
auto ce = make_intrusive<CallExpr>(std::move(ef), std::move(args));
@ -655,3 +684,5 @@ std::vector<Func*> ID::GetOptionHandlers() const
v.push_back(element.second.get());
return v;
}
}

100
src/ID.h
View file

@ -14,23 +14,39 @@
#include <vector>
class Val;
class Expr;
class Func;
class BroType;
class RecordType;
class TableType;
class VectorType;
class EnumType;
class Attributes;
typedef enum { INIT_NONE, INIT_FULL, INIT_EXTRA, INIT_REMOVE, } init_class;
typedef enum { SCOPE_FUNCTION, SCOPE_MODULE, SCOPE_GLOBAL } IDScope;
namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
ZEEK_FORWARD_DECLARE_NAMESPACED(RecordType, zeek);
ZEEK_FORWARD_DECLARE_NAMESPACED(TableType, zeek);
ZEEK_FORWARD_DECLARE_NAMESPACED(VectorType, zeek);
ZEEK_FORWARD_DECLARE_NAMESPACED(EnumType, zeek);
enum [[deprecated("Remove in v4.1. Use zeek::detail::init_class instead.")]] init_class { INIT_NONE, INIT_FULL, INIT_EXTRA, INIT_REMOVE, };
enum [[deprecated("Remove in v4.1. Use zeek::detail::IDScope instead.")]] IDScope { SCOPE_FUNCTION, SCOPE_MODULE, SCOPE_GLOBAL };
namespace zeek::detail {
class Attributes;
class Expr;
enum init_class { INIT_NONE, INIT_FULL, INIT_EXTRA, INIT_REMOVE, };
enum IDScope { SCOPE_FUNCTION, SCOPE_MODULE, SCOPE_GLOBAL };
class ID final : public BroObj, public notifier::Modifiable {
public:
static inline const IntrusivePtr<ID> nil;
ID(const char* name, IDScope arg_scope, bool arg_is_export);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
[[deprecated("Remove in v4.1. Use version that takes zeek::detail::IDScope")]]
ID(const char* name, ::IDScope arg_scope, bool arg_is_export);
#pragma GCC diagnostic pop
~ID() override;
const char* Name() const { return name; }
@ -43,14 +59,14 @@ public:
std::string ModuleName() const;
void SetType(IntrusivePtr<BroType> t);
void SetType(IntrusivePtr<Type> t);
[[deprecated("Remove in v4.1. Use GetType().")]]
BroType* Type() { return type.get(); }
zeek::Type* Type() { return type.get(); }
[[deprecated("Remove in v4.1. Use GetType().")]]
const BroType* Type() const { return type.get(); }
const zeek::Type* Type() const { return type.get(); }
const IntrusivePtr<BroType>& GetType() const
const IntrusivePtr<zeek::Type>& GetType() const
{ return type; }
template <class T>
@ -58,9 +74,9 @@ public:
{ return cast_intrusive<T>(type); }
[[deprecated("Remove in v4.1. Use IsType() and GetType().")]]
BroType* AsType() { return is_type ? GetType().get() : nullptr; }
zeek::Type* AsType() { return is_type ? GetType().get() : nullptr; }
[[deprecated("Remove in v4.1. Use IsType() and GetType().")]]
const BroType* AsType() const { return is_type ? GetType().get() : nullptr; }
const zeek::Type* AsType() const { return is_type ? GetType().get() : nullptr; }
bool IsType() const
{ return is_type; }
@ -72,6 +88,14 @@ public:
void SetVal(IntrusivePtr<Val> v, init_class c);
void SetVal(IntrusivePtr<Expr> ev, init_class c);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
[[deprecated("Remove in v4.1. Use version that takes zeek::detail::init_class")]]
void SetVal(IntrusivePtr<Val> v, ::init_class c);
[[deprecated("Remove in v4.1. Use version that takes zeek::detail::init_class")]]
void SetVal(IntrusivePtr<Expr> ev, ::init_class c);
#pragma GCC diagnostic pop
bool HasVal() const { return val != nullptr; }
[[deprecated("Remove in v4.1. Use GetVal().")]]
@ -101,6 +125,11 @@ public:
void SetAttrs(IntrusivePtr<Attributes> attr);
void AddAttrs(IntrusivePtr<Attributes> attr);
void RemoveAttr(attr_tag a);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
[[deprecated("Remove in v4.1. Use version that takes zeek::detail::attr_tag")]]
void RemoveAttr(::attr_tag a);
#pragma GCC diagnostic pop
void UpdateValAttrs();
const IntrusivePtr<Attributes>& GetAttrs() const
@ -109,11 +138,14 @@ public:
[[deprecated("Remove in 4.1. Use GetAttrs().")]]
Attributes* Attrs() const { return attrs.get(); }
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
[[deprecated("Remove in 4.1. Use GetAttr().")]]
Attr* FindAttr(attr_tag t) const
{ return GetAttr(t).get(); }
Attr* FindAttr(::attr_tag t) const
{ return GetAttr(static_cast<zeek::detail::attr_tag>(t)).get(); }
#pragma GCC diagnostic pop
const IntrusivePtr<Attr>& GetAttr(attr_tag t) const;
const IntrusivePtr<zeek::detail::Attr>& GetAttr(zeek::detail::attr_tag t) const;
bool IsDeprecated() const;
@ -154,7 +186,7 @@ protected:
IDScope scope;
bool is_export;
bool infer_return_type;
IntrusivePtr<BroType> type;
IntrusivePtr<zeek::Type> type;
bool is_const, is_enum_const, is_type, is_option;
int offset;
IntrusivePtr<Val> val;
@ -164,6 +196,10 @@ protected:
};
}
using ID [[deprecated("Remove in v4.1. Use zeek::detail::ID instead.")]] = zeek::detail::ID;
namespace zeek::id {
/**
@ -172,7 +208,7 @@ namespace zeek::id {
* @return The identifier, which may reference a nil object if no such
* name exists.
*/
const IntrusivePtr<ID>& find(std::string_view name);
const IntrusivePtr<zeek::detail::ID>& find(std::string_view name);
/**
* Lookup an ID by its name and return its type. A fatal occurs if the ID
@ -180,7 +216,7 @@ const IntrusivePtr<ID>& find(std::string_view name);
* @param name The identifier name to lookup
* @return The type of the identifier.
*/
const IntrusivePtr<BroType>& find_type(std::string_view name);
const IntrusivePtr<zeek::Type>& find_type(std::string_view name);
/**
* Lookup an ID by its name and return its type (as cast to @c T).
@ -236,17 +272,17 @@ IntrusivePtr<T> find_const(std::string_view name)
*/
IntrusivePtr<Func> find_func(std::string_view name);
extern IntrusivePtr<RecordType> conn_id;
extern IntrusivePtr<RecordType> endpoint;
extern IntrusivePtr<RecordType> connection;
extern IntrusivePtr<RecordType> fa_file;
extern IntrusivePtr<RecordType> fa_metadata;
extern IntrusivePtr<EnumType> transport_proto;
extern IntrusivePtr<TableType> string_set;
extern IntrusivePtr<TableType> string_array;
extern IntrusivePtr<TableType> count_set;
extern IntrusivePtr<VectorType> string_vec;
extern IntrusivePtr<VectorType> index_vec;
extern IntrusivePtr<zeek::RecordType> conn_id;
extern IntrusivePtr<zeek::RecordType> endpoint;
extern IntrusivePtr<zeek::RecordType> connection;
extern IntrusivePtr<zeek::RecordType> fa_file;
extern IntrusivePtr<zeek::RecordType> fa_metadata;
extern IntrusivePtr<zeek::EnumType> transport_proto;
extern IntrusivePtr<zeek::TableType> string_set;
extern IntrusivePtr<zeek::TableType> string_array;
extern IntrusivePtr<zeek::TableType> count_set;
extern IntrusivePtr<zeek::VectorType> string_vec;
extern IntrusivePtr<zeek::VectorType> index_vec;
namespace detail {

66
src/IP.cc
View file

@ -15,11 +15,11 @@
static IntrusivePtr<VectorVal> BuildOptionsVal(const u_char* data, int len)
{
auto vv = make_intrusive<VectorVal>(zeek::id::find_type<VectorType>("ip6_options"));
auto vv = make_intrusive<VectorVal>(zeek::id::find_type<zeek::VectorType>("ip6_options"));
while ( len > 0 )
{
static auto ip6_option_type = zeek::id::find_type<RecordType>("ip6_option");
static auto ip6_option_type = zeek::id::find_type<zeek::RecordType>("ip6_option");
const struct ip6_opt* opt = (const struct ip6_opt*) data;
auto rv = make_intrusive<RecordVal>(ip6_option_type);
rv->Assign(0, val_mgr->Count(opt->ip6o_type));
@ -56,7 +56,7 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
switch ( type ) {
case IPPROTO_IPV6:
{
static auto ip6_hdr_type = zeek::id::find_type<RecordType>("ip6_hdr");
static auto ip6_hdr_type = zeek::id::find_type<zeek::RecordType>("ip6_hdr");
rv = make_intrusive<RecordVal>(ip6_hdr_type);
const struct ip6_hdr* ip6 = (const struct ip6_hdr*)data;
rv->Assign(0, val_mgr->Count((ntohl(ip6->ip6_flow) & 0x0ff00000)>>20));
@ -68,14 +68,14 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
rv->Assign(6, make_intrusive<AddrVal>(IPAddr(ip6->ip6_dst)));
if ( ! chain )
chain = make_intrusive<VectorVal>(
zeek::id::find_type<VectorType>("ip6_ext_hdr_chain"));
zeek::id::find_type<zeek::VectorType>("ip6_ext_hdr_chain"));
rv->Assign(7, std::move(chain));
}
break;
case IPPROTO_HOPOPTS:
{
static auto ip6_hopopts_type = zeek::id::find_type<RecordType>("ip6_hopopts");
static auto ip6_hopopts_type = zeek::id::find_type<zeek::RecordType>("ip6_hopopts");
rv = make_intrusive<RecordVal>(ip6_hopopts_type);
const struct ip6_hbh* hbh = (const struct ip6_hbh*)data;
rv->Assign(0, val_mgr->Count(hbh->ip6h_nxt));
@ -88,7 +88,7 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
case IPPROTO_DSTOPTS:
{
static auto ip6_dstopts_type = zeek::id::find_type<RecordType>("ip6_dstopts");
static auto ip6_dstopts_type = zeek::id::find_type<zeek::RecordType>("ip6_dstopts");
rv = make_intrusive<RecordVal>(ip6_dstopts_type);
const struct ip6_dest* dst = (const struct ip6_dest*)data;
rv->Assign(0, val_mgr->Count(dst->ip6d_nxt));
@ -100,7 +100,7 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
case IPPROTO_ROUTING:
{
static auto ip6_routing_type = zeek::id::find_type<RecordType>("ip6_routing");
static auto ip6_routing_type = zeek::id::find_type<zeek::RecordType>("ip6_routing");
rv = make_intrusive<RecordVal>(ip6_routing_type);
const struct ip6_rthdr* rt = (const struct ip6_rthdr*)data;
rv->Assign(0, val_mgr->Count(rt->ip6r_nxt));
@ -114,7 +114,7 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
case IPPROTO_FRAGMENT:
{
static auto ip6_fragment_type = zeek::id::find_type<RecordType>("ip6_fragment");
static auto ip6_fragment_type = zeek::id::find_type<zeek::RecordType>("ip6_fragment");
rv = make_intrusive<RecordVal>(ip6_fragment_type);
const struct ip6_frag* frag = (const struct ip6_frag*)data;
rv->Assign(0, val_mgr->Count(frag->ip6f_nxt));
@ -128,7 +128,7 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
case IPPROTO_AH:
{
static auto ip6_ah_type = zeek::id::find_type<RecordType>("ip6_ah");
static auto ip6_ah_type = zeek::id::find_type<zeek::RecordType>("ip6_ah");
rv = make_intrusive<RecordVal>(ip6_ah_type);
rv->Assign(0, val_mgr->Count(((ip6_ext*)data)->ip6e_nxt));
rv->Assign(1, val_mgr->Count(((ip6_ext*)data)->ip6e_len));
@ -148,7 +148,7 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
case IPPROTO_ESP:
{
static auto ip6_esp_type = zeek::id::find_type<RecordType>("ip6_esp");
static auto ip6_esp_type = zeek::id::find_type<zeek::RecordType>("ip6_esp");
rv = make_intrusive<RecordVal>(ip6_esp_type);
const uint32_t* esp = (const uint32_t*)data;
rv->Assign(0, val_mgr->Count(ntohl(esp[0])));
@ -159,7 +159,7 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
#ifdef ENABLE_MOBILE_IPV6
case IPPROTO_MOBILITY:
{
static auto ip6_mob_type = zeek::id::find_type<RecordType>("ip6_mobility_hdr");
static auto ip6_mob_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_hdr");
rv = make_intrusive<RecordVal>(ip6_mob_type);
const struct ip6_mobility* mob = (const struct ip6_mobility*) data;
rv->Assign(0, val_mgr->Count(mob->ip6mob_payload));
@ -168,21 +168,21 @@ IntrusivePtr<RecordVal> IPv6_Hdr::ToVal(IntrusivePtr<VectorVal> chain) const
rv->Assign(3, val_mgr->Count(mob->ip6mob_rsv));
rv->Assign(4, val_mgr->Count(ntohs(mob->ip6mob_chksum)));
static auto ip6_mob_msg_type = zeek::id::find_type<RecordType>("ip6_mobility_msg");
static auto ip6_mob_msg_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_msg");
auto msg = make_intrusive<RecordVal>(ip6_mob_msg_type);
msg->Assign(0, val_mgr->Count(mob->ip6mob_type));
uint16_t off = sizeof(ip6_mobility);
const u_char* msg_data = data + off;
static auto ip6_mob_brr_type = zeek::id::find_type<RecordType>("ip6_mobility_brr");
static auto ip6_mob_hoti_type = zeek::id::find_type<RecordType>("ip6_mobility_hoti");
static auto ip6_mob_coti_type = zeek::id::find_type<RecordType>("ip6_mobility_coti");
static auto ip6_mob_hot_type = zeek::id::find_type<RecordType>("ip6_mobility_hot");
static auto ip6_mob_cot_type = zeek::id::find_type<RecordType>("ip6_mobility_cot");
static auto ip6_mob_bu_type = zeek::id::find_type<RecordType>("ip6_mobility_bu");
static auto ip6_mob_back_type = zeek::id::find_type<RecordType>("ip6_mobility_back");
static auto ip6_mob_be_type = zeek::id::find_type<RecordType>("ip6_mobility_be");
static auto ip6_mob_brr_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_brr");
static auto ip6_mob_hoti_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_hoti");
static auto ip6_mob_coti_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_coti");
static auto ip6_mob_hot_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_hot");
static auto ip6_mob_cot_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_cot");
static auto ip6_mob_bu_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_bu");
static auto ip6_mob_back_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_back");
static auto ip6_mob_be_type = zeek::id::find_type<zeek::RecordType>("ip6_mobility_be");
switch ( mob->ip6mob_type ) {
case 0:
@ -332,7 +332,7 @@ IntrusivePtr<RecordVal> IP_Hdr::ToIPHdrVal() const
if ( ip4 )
{
static auto ip4_hdr_type = zeek::id::find_type<RecordType>("ip4_hdr");
static auto ip4_hdr_type = zeek::id::find_type<zeek::RecordType>("ip4_hdr");
rval = make_intrusive<RecordVal>(ip4_hdr_type);
rval->Assign(0, val_mgr->Count(ip4->ip_hl * 4));
rval->Assign(1, val_mgr->Count(ip4->ip_tos));
@ -358,7 +358,7 @@ RecordVal* IP_Hdr::BuildIPHdrVal() const
IntrusivePtr<RecordVal> IP_Hdr::ToPktHdrVal() const
{
static auto pkt_hdr_type = zeek::id::find_type<RecordType>("pkt_hdr");
static auto pkt_hdr_type = zeek::id::find_type<zeek::RecordType>("pkt_hdr");
return ToPktHdrVal(make_intrusive<RecordVal>(pkt_hdr_type), 0);
}
@ -369,9 +369,9 @@ RecordVal* IP_Hdr::BuildPktHdrVal() const
IntrusivePtr<RecordVal> IP_Hdr::ToPktHdrVal(IntrusivePtr<RecordVal> pkt_hdr, int sindex) const
{
static auto tcp_hdr_type = zeek::id::find_type<RecordType>("tcp_hdr");
static auto udp_hdr_type = zeek::id::find_type<RecordType>("udp_hdr");
static auto icmp_hdr_type = zeek::id::find_type<RecordType>("icmp_hdr");
static auto tcp_hdr_type = zeek::id::find_type<zeek::RecordType>("tcp_hdr");
static auto udp_hdr_type = zeek::id::find_type<zeek::RecordType>("udp_hdr");
static auto icmp_hdr_type = zeek::id::find_type<zeek::RecordType>("icmp_hdr");
if ( ip4 )
pkt_hdr->Assign(sindex + 0, ToIPHdrVal());
@ -678,14 +678,14 @@ void IPv6_Hdr_Chain::ProcessDstOpts(const struct ip6_dest* d, uint16_t len)
IntrusivePtr<VectorVal> IPv6_Hdr_Chain::ToVal() const
{
static auto ip6_ext_hdr_type = zeek::id::find_type<RecordType>("ip6_ext_hdr");
static auto ip6_hopopts_type = zeek::id::find_type<RecordType>("ip6_hopopts");
static auto ip6_dstopts_type = zeek::id::find_type<RecordType>("ip6_dstopts");
static auto ip6_routing_type = zeek::id::find_type<RecordType>("ip6_routing");
static auto ip6_fragment_type = zeek::id::find_type<RecordType>("ip6_fragment");
static auto ip6_ah_type = zeek::id::find_type<RecordType>("ip6_ah");
static auto ip6_esp_type = zeek::id::find_type<RecordType>("ip6_esp");
static auto ip6_ext_hdr_chain_type = zeek::id::find_type<VectorType>("ip6_ext_hdr_chain");
static auto ip6_ext_hdr_type = zeek::id::find_type<zeek::RecordType>("ip6_ext_hdr");
static auto ip6_hopopts_type = zeek::id::find_type<zeek::RecordType>("ip6_hopopts");
static auto ip6_dstopts_type = zeek::id::find_type<zeek::RecordType>("ip6_dstopts");
static auto ip6_routing_type = zeek::id::find_type<zeek::RecordType>("ip6_routing");
static auto ip6_fragment_type = zeek::id::find_type<zeek::RecordType>("ip6_fragment");
static auto ip6_ah_type = zeek::id::find_type<zeek::RecordType>("ip6_ah");
static auto ip6_esp_type = zeek::id::find_type<zeek::RecordType>("ip6_esp");
static auto ip6_ext_hdr_chain_type = zeek::id::find_type<zeek::VectorType>("ip6_ext_hdr_chain");
auto rval = make_intrusive<VectorVal>(ip6_ext_hdr_chain_type);
for ( size_t i = 1; i < chain.size(); ++i )

6
src/Net.cc
View file

@ -199,7 +199,7 @@ void net_init(const std::optional<std::string>& interface,
reporter->Error("trace_output_file not defined in bro.init");
}
init_ip_addr_anonymizers();
zeek::detail::init_ip_addr_anonymizers();
sessions = new NetSessions();
@ -409,8 +409,8 @@ void net_delete()
delete sessions;
for ( int i = 0; i < NUM_ADDR_ANONYMIZATION_METHODS; ++i )
delete ip_anonymizer[i];
for ( int i = 0; i < zeek::detail::NUM_ADDR_ANONYMIZATION_METHODS; ++i )
delete zeek::detail::ip_anonymizer[i];
}
int _processing_suspended = 0;

100
src/NetVar.cc
View file

@ -8,27 +8,27 @@
#include "Val.h"
#include "ID.h"
RecordType* conn_id;
RecordType* endpoint;
RecordType* endpoint_stats;
RecordType* connection_type;
RecordType* fa_file_type;
RecordType* fa_metadata_type;
RecordType* icmp_conn;
RecordType* icmp_context;
RecordType* SYN_packet;
RecordType* pcap_packet;
RecordType* raw_pkt_hdr_type;
RecordType* l2_hdr_type;
RecordType* signature_state;
EnumType* transport_proto;
TableType* string_set;
TableType* string_array;
TableType* count_set;
VectorType* string_vec;
VectorType* index_vec;
VectorType* mime_matches;
RecordType* mime_match;
zeek::RecordType* conn_id;
zeek::RecordType* endpoint;
zeek::RecordType* endpoint_stats;
zeek::RecordType* connection_type;
zeek::RecordType* fa_file_type;
zeek::RecordType* fa_metadata_type;
zeek::RecordType* icmp_conn;
zeek::RecordType* icmp_context;
zeek::RecordType* SYN_packet;
zeek::RecordType* pcap_packet;
zeek::RecordType* raw_pkt_hdr_type;
zeek::RecordType* l2_hdr_type;
zeek::RecordType* signature_state;
zeek::EnumType* transport_proto;
zeek::TableType* string_set;
zeek::TableType* string_array;
zeek::TableType* count_set;
zeek::VectorType* string_vec;
zeek::VectorType* index_vec;
zeek::VectorType* mime_matches;
zeek::RecordType* mime_match;
int watchdog_interval;
@ -56,7 +56,7 @@ int tcp_max_above_hole_without_any_acks;
int tcp_excessive_data_without_further_acks;
int tcp_max_old_segments;
RecordType* socks_address;
zeek::RecordType* socks_address;
double non_analyzed_lifetime;
double tcp_inactivity_timeout;
@ -86,32 +86,32 @@ double rpc_timeout;
int mime_segment_length;
int mime_segment_overlap_length;
RecordType* mime_header_rec;
TableType* mime_header_list;
zeek::RecordType* mime_header_rec;
zeek::TableType* mime_header_list;
int http_entity_data_delivery_size;
RecordType* http_stats_rec;
RecordType* http_message_stat;
zeek::RecordType* http_stats_rec;
zeek::RecordType* http_message_stat;
int truncate_http_URI;
RecordType* pm_mapping;
TableType* pm_mappings;
RecordType* pm_port_request;
RecordType* pm_callit_request;
zeek::RecordType* pm_mapping;
zeek::TableType* pm_mappings;
zeek::RecordType* pm_port_request;
zeek::RecordType* pm_callit_request;
RecordType* geo_location;
zeek::RecordType* geo_location;
RecordType* entropy_test_result;
zeek::RecordType* entropy_test_result;
RecordType* dns_msg;
RecordType* dns_answer;
RecordType* dns_soa;
RecordType* dns_edns_additional;
RecordType* dns_tsig_additional;
RecordType* dns_rrsig_rr;
RecordType* dns_dnskey_rr;
RecordType* dns_nsec3_rr;
RecordType* dns_ds_rr;
zeek::RecordType* dns_msg;
zeek::RecordType* dns_answer;
zeek::RecordType* dns_soa;
zeek::RecordType* dns_edns_additional;
zeek::RecordType* dns_tsig_additional;
zeek::RecordType* dns_rrsig_rr;
zeek::RecordType* dns_dnskey_rr;
zeek::RecordType* dns_nsec3_rr;
zeek::RecordType* dns_ds_rr;
TableVal* dns_skip_auth;
TableVal* dns_skip_addl;
int dns_skip_all_auth;
@ -134,7 +134,7 @@ TableVal* preserve_orig_addr;
TableVal* preserve_resp_addr;
TableVal* preserve_other_addr;
RecordType* rotate_info;
zeek::RecordType* rotate_info;
StringVal* log_rotate_base_time;
StringVal* peer_description;
@ -153,8 +153,8 @@ int packet_filter_default;
int sig_max_group_size;
TableType* irc_join_list;
RecordType* irc_join_info;
zeek::TableType* irc_join_list;
zeek::RecordType* irc_join_info;
int dpd_reassemble_first_packets;
int dpd_buffer_size;
@ -172,12 +172,12 @@ StringVal* trace_output_file;
int record_all_packets;
RecordType* script_id;
TableType* id_table;
RecordType* record_field;
TableType* record_field_table;
RecordType* call_argument;
VectorType* call_argument_vector;
zeek::RecordType* script_id;
zeek::TableType* id_table;
zeek::RecordType* record_field;
zeek::TableType* record_field_table;
zeek::RecordType* call_argument;
zeek::VectorType* call_argument_vector;
StringVal* cmd_line_bpf_filter;

100
src/NetVar.h
View file

@ -7,47 +7,47 @@
#include "Stats.h"
[[deprecated("Remove in v4.1. Use zeek::id::conn_id.")]]
extern RecordType* conn_id;
extern zeek::RecordType* conn_id;
[[deprecated("Remove in v4.1. Use zeek::id::endpoint.")]]
extern RecordType* endpoint;
extern zeek::RecordType* endpoint;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* endpoint_stats;
extern zeek::RecordType* endpoint_stats;
[[deprecated("Remove in v4.1. Use zeek::id::connection.")]]
extern RecordType* connection_type;
extern zeek::RecordType* connection_type;
[[deprecated("Remove in v4.1. Use zeek::id::fa_file.")]]
extern RecordType* fa_file_type;
extern zeek::RecordType* fa_file_type;
[[deprecated("Remove in v4.1. Use zeek::id::fa_metadata.")]]
extern RecordType* fa_metadata_type;
extern zeek::RecordType* fa_metadata_type;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* icmp_conn;
extern zeek::RecordType* icmp_conn;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* icmp_context;
extern zeek::RecordType* icmp_context;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* signature_state;
extern zeek::RecordType* signature_state;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* SYN_packet;
extern zeek::RecordType* SYN_packet;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* pcap_packet;
extern zeek::RecordType* pcap_packet;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* raw_pkt_hdr_type;
extern zeek::RecordType* raw_pkt_hdr_type;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* l2_hdr_type;
extern zeek::RecordType* l2_hdr_type;
[[deprecated("Remove in v4.1. Use zeek::id::transport_proto.")]]
extern EnumType* transport_proto;
extern zeek::EnumType* transport_proto;
[[deprecated("Remove in v4.1. Use zeek::id::string_set.")]]
extern TableType* string_set;
extern zeek::TableType* string_set;
[[deprecated("Remove in v4.1. Use zeek::id::string_array.")]]
extern TableType* string_array;
extern zeek::TableType* string_array;
[[deprecated("Remove in v4.1. Use zeek::id::count_set.")]]
extern TableType* count_set;
extern zeek::TableType* count_set;
[[deprecated("Remove in v4.1. Use zeek::id::string_vec.")]]
extern VectorType* string_vec;
extern zeek::VectorType* string_vec;
[[deprecated("Remove in v4.1. Use zeek::id::index_vec.")]]
extern VectorType* index_vec;
extern zeek::VectorType* index_vec;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern VectorType* mime_matches;
extern zeek::VectorType* mime_matches;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* mime_match;
extern zeek::RecordType* mime_match;
extern int watchdog_interval;
@ -76,7 +76,7 @@ extern int tcp_excessive_data_without_further_acks;
extern int tcp_max_old_segments;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* socks_address;
extern zeek::RecordType* socks_address;
extern double non_analyzed_lifetime;
extern double tcp_inactivity_timeout;
@ -114,50 +114,50 @@ extern double rpc_timeout;
extern int mime_segment_length;
extern int mime_segment_overlap_length;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* mime_header_rec;
extern zeek::RecordType* mime_header_rec;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern TableType* mime_header_list;
extern zeek::TableType* mime_header_list;
extern int http_entity_data_delivery_size;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* http_stats_rec;
extern zeek::RecordType* http_stats_rec;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* http_message_stat;
extern zeek::RecordType* http_message_stat;
extern int truncate_http_URI;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* pm_mapping;
extern zeek::RecordType* pm_mapping;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern TableType* pm_mappings;
extern zeek::TableType* pm_mappings;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* pm_port_request;
extern zeek::RecordType* pm_port_request;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* pm_callit_request;
extern zeek::RecordType* pm_callit_request;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* geo_location;
extern zeek::RecordType* geo_location;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* entropy_test_result;
extern zeek::RecordType* entropy_test_result;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_msg;
extern zeek::RecordType* dns_msg;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_answer;
extern zeek::RecordType* dns_answer;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_soa;
extern zeek::RecordType* dns_soa;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_edns_additional;
extern zeek::RecordType* dns_edns_additional;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_tsig_additional;
extern zeek::RecordType* dns_tsig_additional;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_rrsig_rr;
extern zeek::RecordType* dns_rrsig_rr;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_dnskey_rr;
extern zeek::RecordType* dns_dnskey_rr;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_nsec3_rr;
extern zeek::RecordType* dns_nsec3_rr;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* dns_ds_rr;
extern zeek::RecordType* dns_ds_rr;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern TableVal* dns_skip_auth;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
@ -187,7 +187,7 @@ extern TableVal* preserve_other_addr;
extern double connection_status_update_interval;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* rotate_info;
extern zeek::RecordType* rotate_info;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern StringVal* log_rotate_base_time;
@ -212,9 +212,9 @@ extern int packet_filter_default;
extern int sig_max_group_size;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern TableType* irc_join_list;
extern zeek::TableType* irc_join_list;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* irc_join_info;
extern zeek::RecordType* irc_join_info;
extern int dpd_reassemble_first_packets;
extern int dpd_buffer_size;
@ -235,17 +235,17 @@ extern StringVal* trace_output_file;
extern int record_all_packets;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* script_id;
extern zeek::RecordType* script_id;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern TableType* id_table;
extern zeek::TableType* id_table;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* record_field;
extern zeek::RecordType* record_field;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern TableType* record_field_table;
extern zeek::TableType* record_field_table;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern RecordType* call_argument;
extern zeek::RecordType* call_argument;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern VectorType* call_argument_vector;
extern zeek::VectorType* call_argument_vector;
[[deprecated("Remove in v4.1. Perform your own lookup.")]]
extern StringVal* cmd_line_bpf_filter;

28
src/OpaqueVal.cc
View file

@ -37,10 +37,10 @@ OpaqueMgr* OpaqueMgr::mgr()
return &mgr;
}
OpaqueVal::OpaqueVal(OpaqueType* t) : OpaqueVal({NewRef{}, t})
OpaqueVal::OpaqueVal(zeek::OpaqueType* t) : OpaqueVal({NewRef{}, t})
{}
OpaqueVal::OpaqueVal(IntrusivePtr<OpaqueType> t) : Val(std::move(t))
OpaqueVal::OpaqueVal(IntrusivePtr<zeek::OpaqueType> t) : Val(std::move(t))
{}
OpaqueVal::~OpaqueVal()
@ -96,12 +96,12 @@ IntrusivePtr<OpaqueVal> OpaqueVal::Unserialize(const broker::data& data)
return val;
}
broker::expected<broker::data> OpaqueVal::SerializeType(const IntrusivePtr<BroType>& t)
broker::expected<broker::data> OpaqueVal::SerializeType(const IntrusivePtr<zeek::Type>& t)
{
if ( t->InternalType() == TYPE_INTERNAL_ERROR )
if ( t->InternalType() == zeek::TYPE_INTERNAL_ERROR )
return broker::ec::invalid_data;
if ( t->InternalType() == TYPE_INTERNAL_OTHER )
if ( t->InternalType() == zeek::TYPE_INTERNAL_OTHER )
{
// Serialize by name.
assert(t->GetName().size());
@ -112,7 +112,7 @@ broker::expected<broker::data> OpaqueVal::SerializeType(const IntrusivePtr<BroTy
return {broker::vector{false, static_cast<uint64_t>(t->Tag())}};
}
IntrusivePtr<BroType> OpaqueVal::UnserializeType(const broker::data& data)
IntrusivePtr<zeek::Type> OpaqueVal::UnserializeType(const broker::data& data)
{
auto v = caf::get_if<broker::vector>(&data);
if ( ! (v && v->size() == 2) )
@ -142,7 +142,7 @@ IntrusivePtr<BroType> OpaqueVal::UnserializeType(const broker::data& data)
if ( ! tag )
return nullptr;
return base_type(static_cast<TypeTag>(*tag));
return zeek::base_type(static_cast<zeek::TypeTag>(*tag));
}
IntrusivePtr<Val> OpaqueVal::DoClone(CloneState* state)
@ -206,12 +206,12 @@ IntrusivePtr<StringVal> HashVal::DoGet()
return val_mgr->EmptyString();
}
HashVal::HashVal(IntrusivePtr<OpaqueType> t) : OpaqueVal(std::move(t))
HashVal::HashVal(IntrusivePtr<zeek::OpaqueType> t) : OpaqueVal(std::move(t))
{
valid = false;
}
HashVal::HashVal(OpaqueType* t) : HashVal({NewRef{}, t})
HashVal::HashVal(zeek::OpaqueType* t) : HashVal({NewRef{}, t})
{}
MD5Val::MD5Val() : HashVal(md5_type)
@ -226,7 +226,7 @@ MD5Val::~MD5Val()
void HashVal::digest_one(EVP_MD_CTX* h, const Val* v)
{
if ( v->GetType()->Tag() == TYPE_STRING )
if ( v->GetType()->Tag() == zeek::TYPE_STRING )
{
const BroString* str = v->AsString();
hash_update(h, str->Bytes(), str->Len());
@ -723,14 +723,14 @@ IntrusivePtr<Val> BloomFilterVal::DoClone(CloneState* state)
return state->NewClone(this, make_intrusive<BloomFilterVal>());
}
bool BloomFilterVal::Typify(IntrusivePtr<BroType> arg_type)
bool BloomFilterVal::Typify(IntrusivePtr<zeek::Type> arg_type)
{
if ( type )
return false;
type = std::move(arg_type);
auto tl = make_intrusive<TypeList>(type);
auto tl = make_intrusive<zeek::TypeList>(type);
tl->Append(type);
hash = new CompositeHash(std::move(tl));
@ -882,14 +882,14 @@ IntrusivePtr<Val> CardinalityVal::DoClone(CloneState* state)
make_intrusive<CardinalityVal>(new probabilistic::CardinalityCounter(*c)));
}
bool CardinalityVal::Typify(IntrusivePtr<BroType> arg_type)
bool CardinalityVal::Typify(IntrusivePtr<zeek::Type> arg_type)
{
if ( type )
return false;
type = std::move(arg_type);
auto tl = make_intrusive<TypeList>(type);
auto tl = make_intrusive<zeek::TypeList>(type);
tl->Append(type);
hash = new CompositeHash(std::move(tl));

24
src/OpaqueVal.h
View file

@ -88,8 +88,8 @@ private:
class OpaqueVal : public Val {
public:
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
explicit OpaqueVal(OpaqueType* t);
explicit OpaqueVal(IntrusivePtr<OpaqueType> t);
explicit OpaqueVal(zeek::OpaqueType* t);
explicit OpaqueVal(IntrusivePtr<zeek::OpaqueType> t);
~OpaqueVal() override;
/**
@ -148,13 +148,13 @@ protected:
* Helper function for derived class that need to record a type
* during serialization.
*/
static broker::expected<broker::data> SerializeType(const IntrusivePtr<BroType>& t);
static broker::expected<broker::data> SerializeType(const IntrusivePtr<zeek::Type>& t);
/**
* Helper function for derived class that need to restore a type
* during unserialization. Returns the type at reference count +1.
*/
static IntrusivePtr<BroType> UnserializeType(const broker::data& data);
static IntrusivePtr<zeek::Type> UnserializeType(const broker::data& data);
};
namespace probabilistic {
@ -187,8 +187,8 @@ protected:
HashVal() { valid = false; }
[[deprecated("Remove in v4.1. Construct from IntrusivePtr instead.")]]
explicit HashVal(OpaqueType* t);
explicit HashVal(IntrusivePtr<OpaqueType> t);
explicit HashVal(zeek::OpaqueType* t);
explicit HashVal(IntrusivePtr<zeek::OpaqueType> t);
virtual bool DoInit();
virtual bool DoFeed(const void* data, size_t size);
@ -304,10 +304,10 @@ public:
IntrusivePtr<Val> DoClone(CloneState* state) override;
const IntrusivePtr<BroType>& Type() const
const IntrusivePtr<zeek::Type>& Type() const
{ return type; }
bool Typify(IntrusivePtr<BroType> type);
bool Typify(IntrusivePtr<zeek::Type> type);
void Add(const Val* val);
size_t Count(const Val* val) const;
@ -328,7 +328,7 @@ private:
BloomFilterVal(const BloomFilterVal&);
BloomFilterVal& operator=(const BloomFilterVal&);
IntrusivePtr<BroType> type;
IntrusivePtr<zeek::Type> type;
CompositeHash* hash;
probabilistic::BloomFilter* bloom_filter;
};
@ -343,10 +343,10 @@ public:
void Add(const Val* val);
const IntrusivePtr<BroType>& Type() const
const IntrusivePtr<zeek::Type>& Type() const
{ return type; }
bool Typify(IntrusivePtr<BroType> type);
bool Typify(IntrusivePtr<zeek::Type> type);
probabilistic::CardinalityCounter* Get() { return c; };
@ -355,7 +355,7 @@ protected:
DECLARE_OPAQUE_VALUE(CardinalityVal)
private:
IntrusivePtr<BroType> type;
IntrusivePtr<zeek::Type> type;
CompositeHash* hash;
probabilistic::CardinalityCounter* c;
};

2
src/Pipe.cc
View file

@ -7,7 +7,7 @@
#include <errno.h>
#include <cstdio>
using namespace bro;
using namespace zeek::detail;
static void pipe_fail(int eno)
{

4
src/Pipe.h
View file

@ -2,7 +2,7 @@
#pragma once
namespace bro {
namespace zeek::detail {
class Pipe {
public:
@ -136,4 +136,4 @@ private:
bool swapped = false;
};
} // namespace bro
} // namespace zeek::detail

18
src/PrefixTable.cc
View file

@ -43,16 +43,16 @@ void* PrefixTable::Insert(const IPAddr& addr, int width, void* data)
void* PrefixTable::Insert(const Val* value, void* data)
{
// [elem] -> elem
if ( value->GetType()->Tag() == TYPE_LIST &&
if ( value->GetType()->Tag() == zeek::TYPE_LIST &&
value->AsListVal()->Length() == 1 )
value = value->AsListVal()->Idx(0).get();
switch ( value->GetType()->Tag() ) {
case TYPE_ADDR:
case zeek::TYPE_ADDR:
return Insert(value->AsAddr(), 128, data);
break;
case TYPE_SUBNET:
case zeek::TYPE_SUBNET:
return Insert(value->AsSubNet().Prefix(),
value->AsSubNet().LengthIPv6(), data);
break;
@ -103,16 +103,16 @@ void* PrefixTable::Lookup(const IPAddr& addr, int width, bool exact) const
void* PrefixTable::Lookup(const Val* value, bool exact) const
{
// [elem] -> elem
if ( value->GetType()->Tag() == TYPE_LIST &&
if ( value->GetType()->Tag() == zeek::TYPE_LIST &&
value->AsListVal()->Length() == 1 )
value = value->AsListVal()->Idx(0).get();
switch ( value->GetType()->Tag() ) {
case TYPE_ADDR:
case zeek::TYPE_ADDR:
return Lookup(value->AsAddr(), 128, exact);
break;
case TYPE_SUBNET:
case zeek::TYPE_SUBNET:
return Lookup(value->AsSubNet().Prefix(),
value->AsSubNet().LengthIPv6(), exact);
break;
@ -142,16 +142,16 @@ void* PrefixTable::Remove(const IPAddr& addr, int width)
void* PrefixTable::Remove(const Val* value)
{
// [elem] -> elem
if ( value->GetType()->Tag() == TYPE_LIST &&
if ( value->GetType()->Tag() == zeek::TYPE_LIST &&
value->AsListVal()->Length() == 1 )
value = value->AsListVal()->Idx(0).get();
switch ( value->GetType()->Tag() ) {
case TYPE_ADDR:
case zeek::TYPE_ADDR:
return Remove(value->AsAddr(), 128);
break;
case TYPE_SUBNET:
case zeek::TYPE_SUBNET:
return Remove(value->AsSubNet().Prefix(),
value->AsSubNet().LengthIPv6());
break;

2
src/Reporter.cc
View file

@ -143,7 +143,7 @@ void Reporter::FatalErrorWithCore(const char* fmt, ...)
abort();
}
void Reporter::ExprRuntimeError(const Expr* expr, const char* fmt, ...)
void Reporter::ExprRuntimeError(const zeek::detail::Expr* expr, const char* fmt, ...)
{
++errors;

5
src/Reporter.h
View file

@ -36,7 +36,8 @@ protected:
};
class IPAddr;
class Expr;
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
#define FMT_ATTR __attribute__((format(printf, 2, 3))) // sic! 1st is "this" I guess.
@ -77,7 +78,7 @@ public:
// Report a runtime error in evaluating a Bro script expression. This
// function will not return but raise an InterpreterException.
[[noreturn]] void ExprRuntimeError(const Expr* expr, const char* fmt, ...) __attribute__((format(printf, 3, 4)));
[[noreturn]] void ExprRuntimeError(const zeek::detail::Expr* expr, const char* fmt, ...) __attribute__((format(printf, 3, 4)));
// Report a runtime error in evaluating a Bro script expression. This
// function will not return but raise an InterpreterException.

14
src/RuleCondition.cc
View file

@ -136,18 +136,18 @@ RuleConditionEval::RuleConditionEval(const char* func)
return;
}
if ( id->GetType()->Tag() == TYPE_FUNC )
if ( id->GetType()->Tag() == zeek::TYPE_FUNC )
{
// Validate argument quantity and type.
FuncType* f = id->GetType()->AsFuncType();
zeek::FuncType* f = id->GetType()->AsFuncType();
if ( f->Yield()->Tag() != TYPE_BOOL )
if ( f->Yield()->Tag() != zeek::TYPE_BOOL )
rules_error("eval function type must yield a 'bool'", func);
static auto signature_state = zeek::id::find_type<RecordType>("signature_state");
TypeList tl;
static auto signature_state = zeek::id::find_type<zeek::RecordType>("signature_state");
zeek::TypeList tl;
tl.Append(signature_state);
tl.Append(base_type(TYPE_STRING));
tl.Append(zeek::base_type(zeek::TYPE_STRING));
if ( ! f->CheckArgs(tl.Types()) )
rules_error("eval function parameters must be a 'signature_state' "
@ -164,7 +164,7 @@ bool RuleConditionEval::DoMatch(Rule* rule, RuleEndpointState* state,
return false;
}
if ( id->GetType()->Tag() != TYPE_FUNC )
if ( id->GetType()->Tag() != zeek::TYPE_FUNC )
return id->GetVal()->AsBool();
// Call function with a signature_state value as argument.

8
src/RuleCondition.h
View file

@ -2,11 +2,13 @@
#include <stdint.h> // for u_char
#include <sys/types.h> // for u_char
#include "util.h"
class ID;
class Rule;
class RuleEndpointState;
ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
// Base class for all rule conditions except patterns and "header".
class RuleCondition {
public:
@ -111,7 +113,5 @@ public:
void PrintDebug() override;
private:
ID* id;
zeek::detail::ID* id;
};

24
src/RuleMatcher.cc
View file

@ -81,7 +81,7 @@ RuleHdrTest::RuleHdrTest(Prot arg_prot, Comp arg_comp, vector<IPPrefix> arg_v)
Val* RuleMatcher::BuildRuleStateValue(const Rule* rule,
const RuleEndpointState* state) const
{
static auto signature_state = zeek::id::find_type<RecordType>("signature_state");
static auto signature_state = zeek::id::find_type<zeek::RecordType>("signature_state");
RecordVal* val = new RecordVal(signature_state);
val->Assign(0, make_intrusive<StringVal>(rule->ID()));
val->Assign(1, state->GetAnalyzer()->ConnVal());
@ -1294,20 +1294,20 @@ static bool val_to_maskedval(Val* v, maskedvalue_list* append_to,
MaskedValue* mval = new MaskedValue;
switch ( v->GetType()->Tag() ) {
case TYPE_PORT:
case zeek::TYPE_PORT:
mval->val = v->AsPortVal()->Port();
mval->mask = 0xffffffff;
break;
case TYPE_BOOL:
case TYPE_COUNT:
case TYPE_ENUM:
case TYPE_INT:
case zeek::TYPE_BOOL:
case zeek::TYPE_COUNT:
case zeek::TYPE_ENUM:
case zeek::TYPE_INT:
mval->val = v->CoerceToUnsigned();
mval->mask = 0xffffffff;
break;
case TYPE_SUBNET:
case zeek::TYPE_SUBNET:
{
if ( prefix_vector )
{
@ -1362,7 +1362,7 @@ void id_to_maskedvallist(const char* id, maskedvalue_list* append_to,
if ( ! v )
return;
if ( v->GetType()->Tag() == TYPE_TABLE )
if ( v->GetType()->Tag() == zeek::TYPE_TABLE )
{
auto lv = v->AsTableVal()->ToPureListVal();
@ -1384,7 +1384,7 @@ char* id_to_str(const char* id)
if ( ! v )
goto error;
if ( v->GetType()->Tag() != TYPE_STRING )
if ( v->GetType()->Tag() != zeek::TYPE_STRING )
{
rules_error("Identifier must refer to string");
goto error;
@ -1407,10 +1407,10 @@ uint32_t id_to_uint(const char* id)
if ( ! v )
return 0;
TypeTag t = v->GetType()->Tag();
zeek::TypeTag t = v->GetType()->Tag();
if ( t == TYPE_BOOL || t == TYPE_COUNT || t == TYPE_ENUM ||
t == TYPE_INT || t == TYPE_PORT )
if ( t == zeek::TYPE_BOOL || t == zeek::TYPE_COUNT || t == zeek::TYPE_ENUM ||
t == zeek::TYPE_INT || t == zeek::TYPE_PORT )
return v->CoerceToUnsigned();
rules_error("Identifier must refer to integer");

52
src/Scope.cc
View file

@ -15,8 +15,8 @@ typedef PList<Scope> scope_list;
static scope_list scopes;
static Scope* top_scope;
Scope::Scope(IntrusivePtr<ID> id,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> al)
Scope::Scope(IntrusivePtr<zeek::detail::ID> id,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> al)
: scope_id(std::move(id)), attrs(std::move(al))
{
return_type = nullptr;
@ -25,27 +25,27 @@ Scope::Scope(IntrusivePtr<ID> id,
{
const auto& id_type = scope_id->GetType();
if ( id_type->Tag() == TYPE_ERROR )
if ( id_type->Tag() == zeek::TYPE_ERROR )
return;
else if ( id_type->Tag() != TYPE_FUNC )
else if ( id_type->Tag() != zeek::TYPE_FUNC )
reporter->InternalError("bad scope id");
FuncType* ft = id->GetType()->AsFuncType();
zeek::FuncType* ft = id->GetType()->AsFuncType();
return_type = ft->Yield();
}
}
const IntrusivePtr<ID>& Scope::Find(std::string_view name) const
const IntrusivePtr<zeek::detail::ID>& Scope::Find(std::string_view name) const
{
auto entry = local.find(name);
if ( entry != local.end() )
return entry->second;
return ID::nil;
return zeek::detail::ID::nil;
}
IntrusivePtr<ID> Scope::Remove(std::string_view name)
IntrusivePtr<zeek::detail::ID> Scope::Remove(std::string_view name)
{
auto entry = local.find(name);
@ -59,12 +59,12 @@ IntrusivePtr<ID> Scope::Remove(std::string_view name)
return nullptr;
}
IntrusivePtr<ID> Scope::GenerateTemporary(const char* name)
IntrusivePtr<zeek::detail::ID> Scope::GenerateTemporary(const char* name)
{
return make_intrusive<ID>(name, SCOPE_FUNCTION, false);
return make_intrusive<zeek::detail::ID>(name, zeek::detail::SCOPE_FUNCTION, false);
}
std::vector<IntrusivePtr<ID>> Scope::GetInits()
std::vector<IntrusivePtr<zeek::detail::ID>> Scope::GetInits()
{
auto rval = std::move(inits);
inits = {};
@ -100,7 +100,7 @@ void Scope::Describe(ODesc* d) const
for ( const auto& entry : local )
{
ID* id = entry.second.get();
zeek::detail::ID* id = entry.second.get();
id->Describe(d);
d->NL();
}
@ -110,7 +110,7 @@ TraversalCode Scope::Traverse(TraversalCallback* cb) const
{
for ( const auto& entry : local )
{
ID* id = entry.second.get();
zeek::detail::ID* id = entry.second.get();
TraversalCode tc = id->Traverse(cb);
HANDLE_TC_STMT_PRE(tc);
}
@ -119,9 +119,9 @@ TraversalCode Scope::Traverse(TraversalCallback* cb) const
}
const IntrusivePtr<ID>& lookup_ID(const char* name, const char* curr_module,
bool no_global, bool same_module_only,
bool check_export)
const IntrusivePtr<zeek::detail::ID>& lookup_ID(const char* name, const char* curr_module,
bool no_global, bool same_module_only,
bool check_export)
{
std::string fullname = make_full_var_name(curr_module, name);
@ -150,30 +150,30 @@ const IntrusivePtr<ID>& lookup_ID(const char* name, const char* curr_module,
return global_scope()->Find(globalname);
}
return ID::nil;
return zeek::detail::ID::nil;
}
IntrusivePtr<ID> install_ID(const char* name, const char* module_name,
IntrusivePtr<zeek::detail::ID> install_ID(const char* name, const char* module_name,
bool is_global, bool is_export)
{
if ( scopes.empty() && ! is_global )
reporter->InternalError("local identifier in global scope");
IDScope scope;
zeek::detail::IDScope scope;
if ( is_export || ! module_name ||
(is_global &&
normalized_module_name(module_name) == GLOBAL_MODULE_NAME) )
scope = SCOPE_GLOBAL;
scope = zeek::detail::SCOPE_GLOBAL;
else if ( is_global )
scope = SCOPE_MODULE;
scope = zeek::detail::SCOPE_MODULE;
else
scope = SCOPE_FUNCTION;
scope = zeek::detail::SCOPE_FUNCTION;
std::string full_name = make_full_var_name(module_name, name);
auto id = make_intrusive<ID>(full_name.data(), scope, is_export);
auto id = make_intrusive<zeek::detail::ID>(full_name.data(), scope, is_export);
if ( SCOPE_FUNCTION != scope )
if ( zeek::detail::SCOPE_FUNCTION != scope )
global_scope()->Insert(std::move(full_name), id);
else
{
@ -189,8 +189,8 @@ void push_existing_scope(Scope* scope)
scopes.push_back(scope);
}
void push_scope(IntrusivePtr<ID> id,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs)
void push_scope(IntrusivePtr<zeek::detail::ID> id,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attrs)
{
top_scope = new Scope(std::move(id), std::move(attrs));
scopes.push_back(top_scope);

58
src/Scope.h
View file

@ -13,53 +13,55 @@
#include "TraverseTypes.h"
template <class T> class IntrusivePtr;
class ID;
class BroType;
class ListVal;
namespace zeek { class Type; }
using BroType [[deprecated("Remove in v4.1. Use zeek::Type instead.")]] = zeek::Type;
ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
class Scope : public BroObj {
public:
explicit Scope(IntrusivePtr<ID> id,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> al);
explicit Scope(IntrusivePtr<zeek::detail::ID> id,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> al);
const IntrusivePtr<ID>& Find(std::string_view name) const;
const IntrusivePtr<zeek::detail::ID>& Find(std::string_view name) const;
template<typename N>
[[deprecated("Remove in v4.1. Use Find().")]]
ID* Lookup(N&& name) const
zeek::detail::ID* Lookup(N&& name) const
{ return Find(name).get(); }
template<typename N, typename I>
void Insert(N&& name, I&& id) { local[std::forward<N>(name)] = std::forward<I>(id); }
IntrusivePtr<ID> Remove(std::string_view name);
IntrusivePtr<zeek::detail::ID> Remove(std::string_view name);
[[deprecated("Remove in v4.1. Use GetID().")]]
ID* ScopeID() const { return scope_id.get(); }
zeek::detail::ID* ScopeID() const { return scope_id.get(); }
const IntrusivePtr<ID>& GetID() const
const IntrusivePtr<zeek::detail::ID>& GetID() const
{ return scope_id; }
const std::unique_ptr<std::vector<IntrusivePtr<Attr>>>& Attrs() const
const std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>>& Attrs() const
{ return attrs; }
[[deprecated("Remove in v4.1. Use GetReturnTrype().")]]
BroType* ReturnType() const { return return_type.get(); }
zeek::Type* ReturnType() const { return return_type.get(); }
const IntrusivePtr<BroType>& GetReturnType() const
const IntrusivePtr<zeek::Type>& GetReturnType() const
{ return return_type; }
size_t Length() const { return local.size(); }
const auto& Vars() { return local; }
IntrusivePtr<ID> GenerateTemporary(const char* name);
IntrusivePtr<zeek::detail::ID> GenerateTemporary(const char* name);
// Returns the list of variables needing initialization, and
// removes it from this Scope.
std::vector<IntrusivePtr<ID>> GetInits();
std::vector<IntrusivePtr<zeek::detail::ID>> GetInits();
// Adds a variable to the list.
void AddInit(IntrusivePtr<ID> id)
void AddInit(IntrusivePtr<zeek::detail::ID> id)
{ inits.emplace_back(std::move(id)); }
void Describe(ODesc* d) const override;
@ -67,27 +69,27 @@ public:
TraversalCode Traverse(TraversalCallback* cb) const;
protected:
IntrusivePtr<ID> scope_id;
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs;
IntrusivePtr<BroType> return_type;
std::map<std::string, IntrusivePtr<ID>, std::less<>> local;
std::vector<IntrusivePtr<ID>> inits;
IntrusivePtr<zeek::detail::ID> scope_id;
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attrs;
IntrusivePtr<zeek::Type> return_type;
std::map<std::string, IntrusivePtr<zeek::detail::ID>, std::less<>> local;
std::vector<IntrusivePtr<zeek::detail::ID>> inits;
};
extern bool in_debug;
// If no_global is true, don't search in the default "global" namespace.
extern const IntrusivePtr<ID>& lookup_ID(const char* name, const char* module,
bool no_global = false,
bool same_module_only = false,
bool check_export = true);
extern const IntrusivePtr<zeek::detail::ID>& lookup_ID(const char* name, const char* module,
bool no_global = false,
bool same_module_only = false,
bool check_export = true);
extern IntrusivePtr<ID> install_ID(const char* name, const char* module_name,
bool is_global, bool is_export);
extern IntrusivePtr<zeek::detail::ID> install_ID(const char* name, const char* module_name,
bool is_global, bool is_export);
extern void push_scope(IntrusivePtr<ID> id,
std::unique_ptr<std::vector<IntrusivePtr<Attr>>> attrs);
extern void push_scope(IntrusivePtr<zeek::detail::ID> id,
std::unique_ptr<std::vector<IntrusivePtr<zeek::detail::Attr>>> attrs);
extern void push_existing_scope(Scope* scope);
// Returns the one popped off.

21
src/Sessions.cc
View file

@ -248,6 +248,23 @@ void NetSessions::DoNextPacket(double t, const Packet* pkt, const IP_Hdr* ip_hdr
return;
}
if ( ip_hdr->IP4_Hdr() )
{
if ( ip_hdr_len < sizeof(struct ip) )
{
Weird("IPv4_min_header_size", pkt);
return;
}
}
else
{
if ( ip_hdr_len < sizeof(struct ip6_hdr) )
{
Weird("IPv6_min_header_size", pkt);
return;
}
}
// Ignore if packet matches packet filter.
if ( packet_filter && packet_filter->Match(ip_hdr, len, caplen) )
return;
@ -906,10 +923,10 @@ FragReassembler* NetSessions::NextFragment(double t, const IP_Hdr* ip,
Connection* NetSessions::FindConnection(Val* v)
{
const auto& vt = v->GetType();
if ( ! IsRecord(vt->Tag()) )
if ( ! zeek::IsRecord(vt->Tag()) )
return nullptr;
RecordType* vr = vt->AsRecordType();
zeek::RecordType* vr = vt->AsRecordType();
auto vl = v->AsRecord();
int orig_h, orig_p; // indices into record's value list

8
src/SmithWaterman.cc
View file

@ -58,10 +58,10 @@ bool BroSubstring::DoesCover(const BroSubstring* bst) const
VectorVal* BroSubstring::VecToPolicy(Vec* vec)
{
static auto sw_substring_type = zeek::id::find_type<RecordType>("sw_substring");
static auto sw_align_type = zeek::id::find_type<RecordType>("sw_align");
static auto sw_align_vec_type = zeek::id::find_type<VectorType>("sw_align_vec");
static auto sw_substring_vec_type = zeek::id::find_type<VectorType>("sw_substring_vec");
static auto sw_substring_type = zeek::id::find_type<zeek::RecordType>("sw_substring");
static auto sw_align_type = zeek::id::find_type<zeek::RecordType>("sw_align");
static auto sw_align_vec_type = zeek::id::find_type<zeek::VectorType>("sw_align_vec");
static auto sw_substring_vec_type = zeek::id::find_type<zeek::VectorType>("sw_substring_vec");
auto result = make_intrusive<VectorVal>(sw_substring_vec_type);

8
src/Stats.cc
View file

@ -191,7 +191,7 @@ void ProfileLogger::Log()
dstats.requests, dstats.successful, dstats.failed, dstats.pending,
dstats.cached_hosts, dstats.cached_addresses));
trigger::Manager::Stats tstats;
zeek::detail::trigger::Manager::Stats tstats;
trigger_mgr->GetStats(&tstats);
file->Write(fmt("%.06f Triggers: total=%lu pending=%lu\n", network_time, tstats.total, tstats.pending));
@ -252,7 +252,7 @@ void ProfileLogger::Log()
for ( const auto& global : globals )
{
ID* id = global.second.get();
auto& id = global.second;
// We don't show/count internal globals as they are always
// contained in some other global user-visible container.
@ -270,7 +270,7 @@ void ProfileLogger::Log()
if ( size > 100 * 1024 )
print = true;
if ( v->GetType()->Tag() == TYPE_TABLE )
if ( v->GetType()->Tag() == zeek::TYPE_TABLE )
{
entries = v->AsTable()->Length();
total_table_entries += entries;
@ -339,7 +339,7 @@ void ProfileLogger::SegmentProfile(const char* name, const Location* loc,
SampleLogger::SampleLogger()
{
static TableType* load_sample_info = nullptr;
static zeek::TableType* load_sample_info = nullptr;
if ( ! load_sample_info )
load_sample_info = zeek::id::find_type("load_sample_info")->AsTableType();

7
src/Stmt.cc
View file

@ -2,6 +2,8 @@
#include "zeek-config.h"
#include "Stmt.h"
#include "CompHash.h"
#include "Expr.h"
#include "Event.h"
@ -9,7 +11,6 @@
#include "File.h"
#include "Reporter.h"
#include "NetVar.h"
#include "Stmt.h"
#include "Scope.h"
#include "Var.h"
#include "Desc.h"
@ -34,6 +35,8 @@ const char* stmt_name(BroStmtTag t)
return stmt_names[int(t)];
}
namespace zeek::detail {
Stmt::Stmt(BroStmtTag arg_tag)
{
tag = arg_tag;
@ -1833,3 +1836,5 @@ TraversalCode WhenStmt::Traverse(TraversalCallback* cb) const
tc = cb->PostStmt(this);
HANDLE_TC_STMT_POST(tc);
}
}

33
src/Stmt.h
View file

@ -13,12 +13,15 @@
#include "TraverseTypes.h"
class StmtList;
class CompositeHash;
class Frame;
namespace zeek::detail {
class StmtList;
class ForStmt;
class EventExpr;
class ListExpr;
class ForStmt;
class Frame;
class Stmt : public BroObj {
public:
@ -447,3 +450,27 @@ protected:
IntrusivePtr<Expr> timeout;
bool is_return;
};
}
using Stmt [[deprecated("Remove in v4.1. Use zeek::detail::Stmt instead.")]] = zeek::detail::Stmt;
using ExprListStmt [[deprecated("Remove in v4.1. Use zeek::detail::ExprListStmt instead.")]] = zeek::detail::ExprListStmt;
using PrintStmt [[deprecated("Remove in v4.1. Use zeek::detail::PrintStmt instead.")]] = zeek::detail::PrintStmt;
using ExprStmt [[deprecated("Remove in v4.1. Use zeek::detail::ExprStmt instead.")]] = zeek::detail::ExprStmt;
using IfStmt [[deprecated("Remove in v4.1. Use zeek::detail::IfStmt instead.")]] = zeek::detail::IfStmt;
using Case [[deprecated("Remove in v4.1. Use zeek::detail::Case instead.")]] = zeek::detail::Case;
using SwitchStmt [[deprecated("Remove in v4.1. Use zeek::detail::SwitchStmt instead.")]] = zeek::detail::SwitchStmt;
using AddStmt [[deprecated("Remove in v4.1. Use zeek::detail::AddStmt instead.")]] = zeek::detail::AddStmt;
using DelStmt [[deprecated("Remove in v4.1. Use zeek::detail::DelStmt instead.")]] = zeek::detail::DelStmt;
using EventStmt [[deprecated("Remove in v4.1. Use zeek::detail::EventStmt instead.")]] = zeek::detail::EventStmt;
using WhileStmt [[deprecated("Remove in v4.1. Use zeek::detail::WhileStmt instead.")]] = zeek::detail::WhileStmt;
using ForStmt [[deprecated("Remove in v4.1. Use zeek::detail::ForStmt instead.")]] = zeek::detail::ForStmt;
using NextStmt [[deprecated("Remove in v4.1. Use zeek::detail::NextStmt instead.")]] = zeek::detail::NextStmt;
using BreakStmt [[deprecated("Remove in v4.1. Use zeek::detail::BreakStmt instead.")]] = zeek::detail::BreakStmt;
using FallthroughStmt [[deprecated("Remove in v4.1. Use zeek::detail::FallthroughStmt instead.")]] = zeek::detail::FallthroughStmt;
using ReturnStmt [[deprecated("Remove in v4.1. Use zeek::detail::ReturnStmt instead.")]] = zeek::detail::ReturnStmt;
using StmtList [[deprecated("Remove in v4.1. Use zeek::detail::StmtList instead.")]] = zeek::detail::StmtList;
using EventBodyList [[deprecated("Remove in v4.1. Use zeek::detail::EventBodyList instead.")]] = zeek::detail::EventBodyList;
using InitStmt [[deprecated("Remove in v4.1. Use zeek::detail::InitStmt instead.")]] = zeek::detail::InitStmt;
using NullStmt [[deprecated("Remove in v4.1. Use zeek::detail::NullStmt instead.")]] = zeek::detail::NullStmt;
using WhenStmt [[deprecated("Remove in v4.1. Use zeek::detail::WhenStmt instead.")]] = zeek::detail::WhenStmt;

8
src/Tag.cc
View file

@ -4,7 +4,7 @@
#include "Val.h"
#include "IntrusivePtr.h"
Tag::Tag(const IntrusivePtr<EnumType>& etype, type_t arg_type, subtype_t arg_subtype)
Tag::Tag(const IntrusivePtr<zeek::EnumType>& etype, type_t arg_type, subtype_t arg_subtype)
{
assert(arg_type > 0);
@ -14,7 +14,7 @@ Tag::Tag(const IntrusivePtr<EnumType>& etype, type_t arg_type, subtype_t arg_sub
val = etype->GetVal(i);
}
Tag::Tag(EnumType* etype, type_t arg_type, subtype_t arg_subtype)
Tag::Tag(zeek::EnumType* etype, type_t arg_type, subtype_t arg_subtype)
: Tag({NewRef{}, etype}, arg_type, arg_subtype)
{ }
@ -73,7 +73,7 @@ Tag& Tag::operator=(const Tag&& other) noexcept
return *this;
}
const IntrusivePtr<EnumVal>& Tag::AsVal(const IntrusivePtr<EnumType>& etype) const
const IntrusivePtr<EnumVal>& Tag::AsVal(const IntrusivePtr<zeek::EnumType>& etype) const
{
if ( ! val )
{
@ -84,7 +84,7 @@ const IntrusivePtr<EnumVal>& Tag::AsVal(const IntrusivePtr<EnumType>& etype) con
return val;
}
EnumVal* Tag::AsEnumVal(EnumType* etype) const
EnumVal* Tag::AsEnumVal(zeek::EnumType* etype) const
{
return AsVal({NewRef{}, etype}).get();
}

17
src/Tag.h
View file

@ -3,14 +3,15 @@
#pragma once
#include "zeek-config.h"
#include "IntrusivePtr.h"
#include <string>
#include <stdint.h>
#include <string>
#include "IntrusivePtr.h"
#include "util.h"
class EnumVal;
class EnumType;
ZEEK_FORWARD_DECLARE_NAMESPACED(EnumType, zeek);
/**
* Class to identify an analyzer type.
@ -115,10 +116,10 @@ protected:
*
* @param etype the script-layer enum type associated with the tag.
*/
const IntrusivePtr<EnumVal>& AsVal(const IntrusivePtr<EnumType>& etype) const;
const IntrusivePtr<EnumVal>& AsVal(const IntrusivePtr<zeek::EnumType>& etype) const;
[[deprecated("Remove in v4.1. Use AsVal() instead.")]]
EnumVal* AsEnumVal(EnumType* etype) const;
EnumVal* AsEnumVal(zeek::EnumType* etype) const;
/**
* Constructor.
@ -131,10 +132,10 @@ protected:
* @param subtype The sub type, which is left to an analyzer for
* interpretation. By default it's set to zero.
*/
Tag(const IntrusivePtr<EnumType>& etype, type_t type, subtype_t subtype = 0);
Tag(const IntrusivePtr<zeek::EnumType>& etype, type_t type, subtype_t subtype = 0);
[[deprecated("Remove in v4.1. Construct from IntrusivePtr& instead.")]]
Tag(EnumType* etype, type_t type, subtype_t subtype = 0);
Tag(zeek::EnumType* etype, type_t type, subtype_t subtype = 0);
/**
* Constructor.

27
src/Traverse.h
View file

@ -6,9 +6,10 @@
class Func;
class Scope;
class Stmt;
class Expr;
class ID;
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
class TraversalCallback {
public:
@ -18,20 +19,20 @@ public:
virtual TraversalCode PreFunction(const Func*) { return TC_CONTINUE; }
virtual TraversalCode PostFunction(const Func*) { return TC_CONTINUE; }
virtual TraversalCode PreStmt(const Stmt*) { return TC_CONTINUE; }
virtual TraversalCode PostStmt(const Stmt*) { return TC_CONTINUE; }
virtual TraversalCode PreStmt(const zeek::detail::Stmt*) { return TC_CONTINUE; }
virtual TraversalCode PostStmt(const zeek::detail::Stmt*) { return TC_CONTINUE; }
virtual TraversalCode PreExpr(const Expr*) { return TC_CONTINUE; }
virtual TraversalCode PostExpr(const Expr*) { return TC_CONTINUE; }
virtual TraversalCode PreExpr(const zeek::detail::Expr*) { return TC_CONTINUE; }
virtual TraversalCode PostExpr(const zeek::detail::Expr*) { return TC_CONTINUE; }
virtual TraversalCode PreID(const ID*) { return TC_CONTINUE; }
virtual TraversalCode PostID(const ID*) { return TC_CONTINUE; }
virtual TraversalCode PreID(const zeek::detail::ID*) { return TC_CONTINUE; }
virtual TraversalCode PostID(const zeek::detail::ID*) { return TC_CONTINUE; }
virtual TraversalCode PreTypedef(const ID*) { return TC_CONTINUE; }
virtual TraversalCode PostTypedef(const ID*) { return TC_CONTINUE; }
virtual TraversalCode PreTypedef(const zeek::detail::ID*) { return TC_CONTINUE; }
virtual TraversalCode PostTypedef(const zeek::detail::ID*) { return TC_CONTINUE; }
virtual TraversalCode PreDecl(const ID*) { return TC_CONTINUE; }
virtual TraversalCode PostDecl(const ID*) { return TC_CONTINUE; }
virtual TraversalCode PreDecl(const zeek::detail::ID*) { return TC_CONTINUE; }
virtual TraversalCode PostDecl(const zeek::detail::ID*) { return TC_CONTINUE; }
Scope* current_scope;
};

32
src/Trigger.cc
View file

@ -15,12 +15,13 @@
#include "DebugLogger.h"
#include "iosource/Manager.h"
using namespace trigger;
using namespace zeek::detail;
using namespace zeek::detail::trigger;
// Callback class to traverse an expression, registering all relevant IDs and
// Vals for change notifications.
namespace trigger {
namespace zeek::detail::trigger {
class TriggerTraversalCallback : public TraversalCallback {
public:
@ -30,15 +31,13 @@ public:
~TriggerTraversalCallback()
{ Unref(trigger); }
virtual TraversalCode PreExpr(const Expr*);
virtual TraversalCode PreExpr(const zeek::detail::Expr*) override;
private:
Trigger* trigger;
};
}
TraversalCode TriggerTraversalCallback::PreExpr(const Expr* expr)
TraversalCode zeek::detail::trigger::TriggerTraversalCallback::PreExpr(const zeek::detail::Expr* expr)
{
// We catch all expressions here which in some way reference global
// state.
@ -46,7 +45,7 @@ TraversalCode TriggerTraversalCallback::PreExpr(const Expr* expr)
switch ( expr->Tag() ) {
case EXPR_NAME:
{
const NameExpr* e = static_cast<const NameExpr*>(expr);
const auto* e = static_cast<const zeek::detail::NameExpr*>(expr);
if ( e->Id()->IsGlobal() )
trigger->Register(e->Id());
@ -59,7 +58,7 @@ TraversalCode TriggerTraversalCallback::PreExpr(const Expr* expr)
case EXPR_INDEX:
{
const IndexExpr* e = static_cast<const IndexExpr*>(expr);
const auto* e = static_cast<const zeek::detail::IndexExpr*>(expr);
BroObj::SuppressErrors no_errors;
try
@ -83,8 +82,6 @@ TraversalCode TriggerTraversalCallback::PreExpr(const Expr* expr)
return TC_CONTINUE;
}
namespace trigger {
class TriggerTimer final : public Timer {
public:
TriggerTimer(double arg_timeout, Trigger* arg_trigger)
@ -120,10 +117,9 @@ protected:
double time;
};
}
Trigger::Trigger(Expr* arg_cond, Stmt* arg_body, Stmt* arg_timeout_stmts,
Expr* arg_timeout, Frame* arg_frame,
Trigger::Trigger(zeek::detail::Expr* arg_cond, zeek::detail::Stmt* arg_body,
zeek::detail::Stmt* arg_timeout_stmts,
zeek::detail::Expr* arg_timeout, Frame* arg_frame,
bool arg_is_return, const Location* arg_location)
{
cond = arg_cond;
@ -389,7 +385,7 @@ void Trigger::Timeout()
Unref(this);
}
void Trigger::Register(ID* id)
void Trigger::Register(zeek::detail::ID* id)
{
assert(! disabled);
notifier::registry.Register(id, this);
@ -440,7 +436,7 @@ void Trigger::Attach(Trigger *trigger)
Hold();
}
bool Trigger::Cache(const CallExpr* expr, Val* v)
bool Trigger::Cache(const zeek::detail::CallExpr* expr, Val* v)
{
if ( disabled || ! v )
return false;
@ -463,7 +459,7 @@ bool Trigger::Cache(const CallExpr* expr, Val* v)
}
Val* Trigger::Lookup(const CallExpr* expr)
Val* Trigger::Lookup(const zeek::detail::CallExpr* expr)
{
assert(! disabled);
@ -553,3 +549,5 @@ void Manager::GetStats(Stats* stats)
stats->total = total_triggers;
stats->pending = pending->size();
}
}

46
src/Trigger.h
View file

@ -1,22 +1,25 @@
#pragma once
#include "Obj.h"
#include "Notifier.h"
#include "iosource/IOSource.h"
#include <list>
#include <vector>
#include <map>
class CallExpr;
class Expr;
class Stmt;
#include "Obj.h"
#include "Notifier.h"
#include "iosource/IOSource.h"
#include "util.h"
class Frame;
class Val;
class ID;
class ODesc;
namespace trigger {
ZEEK_FORWARD_DECLARE_NAMESPACED(Stmt, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(Expr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(CallExpr, zeek::detail);
ZEEK_FORWARD_DECLARE_NAMESPACED(ID, zeek::detail);
namespace zeek::detail::trigger {
// Triggers are the heart of "when" statements: expressions that when
// they become true execute a body of statements.
@ -29,7 +32,7 @@ public:
// instantiation. Note that if the condition is already true, the
// statements are executed immediately and the object is deleted
// right away.
Trigger(Expr* cond, Stmt* body, Stmt* timeout_stmts, Expr* timeout,
Trigger(zeek::detail::Expr* cond, zeek::detail::Stmt* body, zeek::detail::Stmt* timeout_stmts, zeek::detail::Expr* timeout,
Frame* f, bool is_return, const Location* loc);
~Trigger() override;
@ -60,8 +63,8 @@ public:
// Cache for return values of delayed function calls. Returns whether
// the trigger is queued for later evaluation -- it may not be queued
// if the Val is null or it's disabled.
bool Cache(const CallExpr* expr, Val* val);
Val* Lookup(const CallExpr*);
bool Cache(const zeek::detail::CallExpr* expr, Val* val);
Val* Lookup(const zeek::detail::CallExpr*);
// Disable this trigger completely. Needed because Unref'ing the trigger
// may not immediately delete it as other references may still exist.
@ -87,14 +90,14 @@ private:
friend class TriggerTimer;
void Init();
void Register(ID* id);
void Register(zeek::detail::ID* id);
void Register(Val* val);
void UnregisterAll();
Expr* cond;
Stmt* body;
Stmt* timeout_stmts;
Expr* timeout;
zeek::detail::Expr* cond;
zeek::detail::Stmt* body;
zeek::detail::Stmt* timeout_stmts;
zeek::detail::Expr* timeout;
double timeout_value;
Frame* frame;
bool is_return;
@ -108,7 +111,7 @@ private:
std::vector<std::pair<BroObj *, notifier::Modifiable*>> objs;
using ValCache = std::map<const CallExpr*, Val*>;
using ValCache = std::map<const zeek::detail::CallExpr*, Val*>;
ValCache cache;
};
@ -140,4 +143,9 @@ private:
}
extern trigger::Manager* trigger_mgr;
namespace trigger {
using Trigger [[deprecated("Remove in v4.1. Use zeek::detail::trigger::Trigger instead")]] = zeek::detail::trigger::Trigger;
using Manager [[deprecated("Remove in v4.1. Use zeek::detail::trigger::Manager instead")]] = zeek::detail::trigger::Manager;
}
extern zeek::detail::trigger::Manager* trigger_mgr;

7
src/TunnelEncapsulation.h
View file

@ -3,14 +3,15 @@
#pragma once
#include "zeek-config.h"
#include <vector>
#include "IntrusivePtr.h"
#include "NetVar.h"
#include "IPAddr.h"
#include "ID.h"
#include "UID.h"
#include <vector>
class Connection;
/**
@ -198,7 +199,7 @@ public:
IntrusivePtr<VectorVal> ToVal() const
{
auto vv = make_intrusive<VectorVal>(
zeek::id::find_type<VectorType>("EncapsulatingConnVector"));
zeek::id::find_type<zeek::VectorType>("EncapsulatingConnVector"));
if ( conns )
{

Some files were not shown because too many files have changed in this diff Show more