broccoli-python-0.63/0000755000076500000240000000000013350260210014456 5ustar jonstaff00000000000000broccoli-python-0.63/CHANGES0000644000076500000240000001051113350247745015471 0ustar jonstaff00000000000000 0.63 | 2018-08-22 11:55:29 -0500 * Release v0.63. 0.62-11 | 2018-08-06 16:01:03 -0500 * Fix deprecation warning for swig_add_module (Jon Siwek, Corelight) 0.62-5 | 2018-05-15 15:38:58 +0000 * Updating submodule. 0.62 | 2017-05-26 08:27:17 -0500 * Release 0.62. 0.61 | 2016-10-27 14:42:24 -0700 * Release 0.61. 0.60-3 | 2016-10-13 15:58:06 -0700 * Python 3 compatibility fixes. (Daniel Thayer) 0.60 | 2016-08-12 13:14:12 -0700 * Release 0.60. * Add README.rst -> README symlink. (Johanna Amann) 0.59 | 2015-04-27 08:25:18 -0700 * Release 0.59 0.58-9 | 2015-02-13 18:01:05 -0600 * Install broccoli_intern.py (Jon Siwek) 0.58-8 | 2015-02-13 16:02:49 -0600 * In broccoli.py, import from broccoli_intern not _broccoli_intern. (Jon Siwek) 0.58-1 | 2014-07-08 09:56:42 -0700 * Fix setup.py to work with path changes. Addresses BIT-1213. (Nicholas Weaver) 0.58 | 2014-04-03 15:53:50 -0700 * Release 0.58 0.57-3 | 2014-01-23 16:59:19 -0800 * Supply connAlive() and connDelete() methods. (jpohlmann) 0.57 | 2013-11-06 00:21:37 -0800 * Installation section was missing necessary steps. (Johanna Amann) 0.56 | 2013-10-14 09:24:55 -0700 * Updating copyright notice. (Robin Sommer) 0.55-2 | 2013-10-02 10:34:29 -0700 * Fix mem leaks. (Jon Siwek) 0.55 | 2013-09-23 13:14:46 -0500 * Change submodules to fixed URL. (Jon Siwek) * Switching to relative submodule paths. (Robin Sommer) * s/bro-ids.org/bro.org/g. (Robin Sommer) 0.54 | 2012-08-01 13:56:08 -0500 * Fix configure script to exit with non-zero status on error (Jon Siwek) 0.53 | 2012-06-11 17:25:05 -0700 * Fix overflow problems in converting Python IP addresses to Broccoli. (Jon Siwek) * Update bindings to work with Broccoli's IPv4-mapped BroAddrs. (Jon Siwek) * Update IPv6 literal syntax in test scripts. (Jon Siwek) * Update broccoli-python for IPv6 addr/subnet support. Addresses #448. (Jon Siwek) * Raise minimum required CMake version to 2.6.3. (Jon Siwek) 0.52 | 2012-01-10 16:56:13 -0800 * Submodule README conformity changes (Jon Siwek) * Simplify finding of Python headers/libraries. Addresses #666 (Jon Siwek) 0.51-3 | 2011-11-03 15:17:19 -0700 * Fixing compiler warnings. Addresses #388. (Jon Siwek) 0.51 | 2011-10-27 17:41:32 -0700 * Compile SWIG bindings with no-strict-aliasing. Addresses #644. (Jon Siwek) 0.5 | 2011-10-25 20:18:20 -0700 * Make dist now cleans the copied source. (Jon Siwek) * Add configure-time check that swig can generate python wrappers. Addresses #642. (Jon Siwek) * Updates for changes to communication API. (Seth Hall) * Distribution cleanup. (Jon Siwek and Robin Sommer) * Install binaries with an RPATH (Jon Siwek) * Remove the 'net' type from Broccoli python bindings. Aaddresses #535). * Workaround for FreeBSD CMake port missing debug flags. (Jon Siwek) * Adjust how python-broccoli test script prints floats. * Allow record instances that don't initialize all fields. (Jon Siwek) * Update tests w/ example of sending a partial records. (Jon Siwek) * Fix pybroccoli record instantiation. Declaring more than one record_type could cause it to break because only the last-declared record_type was used in the instantiation. (Jon Siwek) * Change to fill in record field names. Before, it was sending records with hardcoded "" field names. (Jon Siwek) * Adating CMake's include path based on output of python-config. (Robin Sommer) * Teaching CMake to use python-config for finding libraries. (Robin Sommer) * Making python-broccoli work with 64-bit integers. (Robin Sommer) 0.4 | 2011-07-19 17:54:35 -0700 * Improvements and fixes to record implementation. (Jon Siwek) * Allow record instances that don't initialize all fields. * Update tests w/ example of sending a partial records. * Fix pybroccoli record instantiation. * Change pybroccoli to fill in record field names. * Update test bro script for new Bro policy script organization. (Jon Siwek) * Cleanup (Seth Hall, Robin Sommer) 0.3 | 2011-05-05 20:42:47 -0700 * CMake build system. (Jon Siwek). * Adapting to work with 64-bit integers, which Bro and Broccoli are now using. (Robin Sommer) 0.2 - Repository switched to git, and README converted to reSt. - License changed to BSD-style. broccoli-python-0.63/CMakeLists.txt0000644000076500000240000000531113350246015017225 0ustar jonstaff00000000000000project(PyBroccoli C) cmake_minimum_required(VERSION 2.6.3 FATAL_ERROR) include(cmake/CommonCMakeConfig.cmake) ######################################################################## ## Dependency Configuration include(FindRequiredPackage) FindRequiredPackage(Broccoli) FindRequiredPackage(SWIG) FindRequiredPackage(PythonInterp) FindRequiredPackage(PythonDev) file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/example.i "%module example %{%}") execute_process(COMMAND ${SWIG_EXECUTABLE} -python ${CMAKE_CURRENT_BINARY_DIR}/example.i ERROR_VARIABLE SWIG_PYTHON_ERR) if (SWIG_PYTHON_ERR) message(FATAL_ERROR "Swig installation doesn't support Python wrapper generation: ${SWIG_PYTHON_ERR}") endif () if (MISSING_PREREQS) foreach (prereq ${MISSING_PREREQ_DESCS}) message(SEND_ERROR ${prereq}) endforeach () message(FATAL_ERROR "Configuration aborted due to missing prerequisites") endif () include_directories(BEFORE ${PYTHON_INCLUDE_DIR}) include_directories(BEFORE ${Broccoli_INCLUDE_DIR}) ######################################################################## ## Build Python Extension include(UseSWIG) if ( CMAKE_VERSION VERSION_LESS 3.8.0 ) swig_add_module(broccoli_intern python broccoli_intern.i) else () swig_add_library(broccoli_intern LANGUAGE python SOURCES broccoli_intern.i) endif () swig_link_libraries(broccoli_intern ${Broccoli_LIBRARY} ${PYTHON_LIBRARIES}) set_source_files_properties(${swig_generated_file_fullname} PROPERTIES COMPILE_FLAGS -fno-strict-aliasing) ######################################################################## ## Install Files if (NOT PY_MOD_INSTALL_DIR) # the configure wrapper was not used, default to "home" style installation set(PY_MOD_INSTALL_DIR lib/python) endif () install(FILES broccoli.py DESTINATION ${PY_MOD_INSTALL_DIR}) install(TARGETS ${SWIG_MODULE_broccoli_intern_REAL_NAME} DESTINATION ${PY_MOD_INSTALL_DIR}) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/broccoli_intern.py DESTINATION ${PY_MOD_INSTALL_DIR}) ######################################################################## ## Build Summary if (CMAKE_BUILD_TYPE) string(TOUPPER ${CMAKE_BUILD_TYPE} BuildType) endif () message( "\n================| PyBroccoli Build Summary |==================" "\n" "\nInstall dir: ${PY_MOD_INSTALL_DIR}" "\nDebug mode: ${ENABLE_DEBUG}" "\n" "\nCC: ${CMAKE_C_COMPILER}" "\nCFLAGS: ${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${BuildType}}" "\nCPP: ${CMAKE_C_COMPILER}" "\n" "\n================================================================\n" ) include(UserChangedWarning) broccoli-python-0.63/COPYING0000644000076500000240000000345713350246015015531 0ustar jonstaff00000000000000Copyright (c) 1995-2013, The Regents of the University of California through the Lawrence Berkeley National Laboratory and the International Computer Science Institute. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory, U.S. Dept. of Energy, International Computer Science Institute, nor the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Note that some files in the distribution may carry their own copyright notices. broccoli-python-0.63/MANIFEST.in0000644000076500000240000000036213350246015016224 0ustar jonstaff00000000000000include CHANGES include CMakeLists.txt include COPYING include MANIFEST.in include Makefile include README include TODO include VERSION include broccoli.py include broccoli_intern.i include setup.py include configure graft cmake graft tests broccoli-python-0.63/Makefile0000644000076500000240000000077113350246015016132 0ustar jonstaff00000000000000# Makefile not needed to build module. Use "python setup.py install" instead. CLEAN=build broccoli_intern_wrap.c broccoli_intern.py README.html *.pyc build all : broccoli_intern_wrap.c broccoli_intern_wrap.c : broccoli_intern.i swig -python -I../../src -o broccoli_intern_wrap.c broccoli_intern.i clean: rm -rf $(CLEAN) docs: README rst2html.py README >README.html dist: rm -rf build/*.tar.gz python setup.py sdist -d build @printf "Package: "; echo build/*.tar.gz distclean: rm -rf build/ broccoli-python-0.63/PKG-INFO0000644000076500000240000000027513350260210015557 0ustar jonstaff00000000000000Metadata-Version: 1.0 Name: broccoli-python Version: 0.63 Summary: UNKNOWN Home-page: UNKNOWN Author: UNKNOWN Author-email: info@bro.org License: BSD Description: UNKNOWN Platform: UNKNOWN broccoli-python-0.63/README0000644000076500000240000001715213350247745015366 0ustar jonstaff00000000000000.. -*- mode: rst-mode -*- .. .. Version number is filled in automatically. .. |version| replace:: 0.63 ============================ Python Bindings for Broccoli ============================ .. rst-class:: opening This Python module provides bindings for Broccoli, Bro's client communication library. In general, the bindings provide the same functionality as Broccoli's C API. .. contents:: Download -------- You can find the latest Broccoli-Python release for download at http://www.bro.org/download. Broccoli-Python's git repository is located at `git://git.bro.org/broccoli-python.git `__. You can browse the repository `here `__. This document describes Broccoli-Python |version|. See the ``CHANGES`` file for version history. Installation ------------ Installation of the Python module is pretty straight-forward:: ./configure make python setup.py install Try the following to test the installation. If you do not see any error message, everything should be fine:: python -c "import broccoli" Usage ----- The following examples demonstrate how to send and receive Bro events in Python. The main challenge when using Broccoli from Python is dealing with the data types of Bro event parameters as there is no one-to-one mapping between Bro's types and Python's types. The Python modules automatically maps between those types which both systems provide (such as strings) and provides a set of wrapper classes for Bro types which do not have a direct Python equivalent (such as IP addresses). Connecting to Bro ~~~~~~~~~~~~~~~~~ The following code sets up a connection from Python to a remote Bro instance (or another Broccoli) and provides a connection handle for further communication:: from broccoli import * bc = Connection("127.0.0.1:47758") An ``IOError`` will be raised if the connection cannot be established. Sending Events ~~~~~~~~~~~~~~ Once you have a connection handle ``bc`` set up as shown above, you can start sending events:: bc.send("foo", 5, "attack!") This sends an event called ``foo`` with two parameters, ``5`` and ``attack!``. Broccoli operates asynchronously, i.e., events scheduled with ``send()`` are not always sent out immediately but might be queued for later transmission. To ensure that all events get out (and incoming events are processed, see below), you need to call ``bc.processInput()`` regularly. Data Types ~~~~~~~~~~ In the example above, the types of the event parameters are automatically derived from the corresponding Python types: the first parameter (``5``) has the Bro type ``int`` and the second one (``attack!``) has Bro type ``string``. For types which do not have a Python equivalent, the ``broccoli`` module provides wrapper classes which have the same names as the corresponding Bro types. For example, to send an event called ``bar`` with one ``addr`` argument and one ``count`` argument, you can write:: bc.send("bar", addr("192.168.1.1"), count(42)) The following table summarizes the available atomic types and their usage. ======== =========== =========================== Bro Type Python Type Example ======== =========== =========================== addr ``addr("192.168.1.1")`` bool bool ``True`` count ``count(42)`` double float ``3.14`` enum Type currently not supported int int ``5`` interval ``interval(60)`` net Type currently not supported port ``port("80/tcp")`` string string ``"attack!"`` subnet ``subnet("192.168.1.0/24")`` time ``time(1111111111.0)`` ======== =========== =========================== The ``broccoli`` module also supports sending Bro records as event parameters. To send a record, you first define a record type. For example, a Bro record type:: type my_record: record { a: int; b: addr; c: subnet; }; turns into Python as:: my_record = record_type("a", "b", "c") As the example shows, Python only needs to know the attribute names but not their types. The types are derived automatically in the same way as discussed above for atomic event parameters. Now you can instantiate a record instance of the newly defined type and send it out:: rec = record(my_record) rec.a = 5 rec.b = addr("192.168.1.1") rec.c = subnet("192.168.1.0/24") bc.send("my_event", rec) .. note:: The Python module does not support nested records at this time. Receiving Events ~~~~~~~~~~~~~~~~ To receive events, you define a callback function having the same name as the event and mark it with the ``event`` decorator:: @event def foo(arg1, arg2): print arg1, arg2 Once you start calling ``bc.processInput()`` regularly (see above), each received ``foo`` event will trigger the callback function. By default, the event's arguments are always passed in with built-in Python types. For Bro types which do not have a direct Python equivalent (see table above), a substitute built-in type is used which corresponds to the type the wrapper class' constructor expects (see the examples in the table). For example, Bro type ``addr`` is passed in as a string and Bro type ``time`` is passed in as a float. Alternatively, you can define a _typed_ prototype for the event. If you do so, arguments will first be type-checked and then passed to the call-back with the specified type (which means instances of the wrapper classes for non-Python types). Example:: @event(count, addr) def bar(arg1, arg2): print arg1, arg2 Here, ``arg1`` will be an instance of the ``count`` wrapper class and ``arg2`` will be an instance of the ``addr`` wrapper class. Protoyping works similarly with built-in Python types:: @event(int, string): def foo(arg1, arg2): print arg1, arg2 In general, the prototype specifies the types in which the callback wants to receive the arguments. This actually provides support for simple type casts as some types support conversion to into something different. If for instance the event source sends an event with a single port argument, ``@event(port)`` will pass the port as an instance of the ``port`` wrapper class; ``@event(string)`` will pass it as a string (e.g., ``"80/tcp"``); and ``@event(int)`` will pass it as an integer without protocol information (e.g., just ``80``). If an argument cannot be converted into the specified type, a ``TypeError`` will be raised. To receive an event with a record parameter, the record type first needs to be defined, as described above. Then the type can be used with the ``@event`` decorator in the same way as atomic types:: my_record = record_type("a", "b", "c") @event(my_record) def my_event(rec): print rec.a, rec.b, rec.c Helper Functions ---------------- The ``broccoli`` module provides one helper function: ``current_time()`` returns the current time as a float which, if necessary, can be wrapped into a ``time`` parameter (i.e., ``time(current_time()``) Examples -------- There are some example scripts in the ``tests/`` subdirectory of the ``broccoli-python`` repository `here `_: - ``broping.py`` is a (simplified) Python version of Broccoli's test program ``broping``. Start Bro with ``broping.bro``. - ``broping-record.py`` is a Python version of Broccoli's ``broping`` for records. Start Bro with ``broping-record.bro``. - ``test.py`` is a very ugly but comprehensive regression test and part of the communication test-suite. Start Bro with ``test.bro``. broccoli-python-0.63/TODO0000644000076500000240000000040313350246015015152 0ustar jonstaff00000000000000 - Nested records are not supported. - Type enum disabled because there seems to be some Broccoli problem with them. - Would be nice to have some more standard operations (+,-, etc.) defined for the wrapper classes. - listen() not available in Python. broccoli-python-0.63/VERSION0000644000076500000240000000000513350247745015543 0ustar jonstaff000000000000000.63 broccoli-python-0.63/broccoli.py0000644000076500000240000003011613350246015016634 0ustar jonstaff00000000000000import sys import socket import struct from types import FunctionType from broccoli_intern import * if sys.version_info[0] == 3: using_py3 = True else: using_py3 = False bro_init(None) ##### Connection class which capsulates a Broccoli connection. class Connection: # Connection to destination given as string "host:port" def __init__(self, destination, broclass="", flags=BRO_CFLAG_RECONNECT | BRO_CFLAG_ALWAYS_QUEUE, connect=True): self.bc = bro_conn_new_str(destination, flags) self.destination = destination if not self.bc: raise IOError("cannot init Broccoli connection handle") self._registerHandlers() if broclass: bro_conn_set_class(self.bc, broclass) if connect: self.connect(); # If the instance was created with connect=False, this will trigger the connect. def connect(self): if not bro_conn_connect(self.bc): raise IOError("cannot connect to %s" % self.destination) # Hand control to Broccoli's I/O loop. # Returns true if the send queue is non-empty. def processInput(self): bro_conn_process_input(self.bc); return bro_event_queue_length(self.bc) > 0 def connAlive(self): if bro_conn_alive(self.bc) == 1: return True return False def connDelete(self): return bro_conn_delete(self.bc) # Send an event of name with args. def send(self, name, *args): ev = bro_event_new(name) for arg in args: bro_event_add_val(ev, _getInternalVal(arg)) bro_event_send(self.bc, ev); bro_event_free(ev); self.processInput() # Explicit subscribe def subscribe(self, event_name, callback): ev = event(callback) bro_event_registry_add_compact(self.bc, event_name, ev); # Register all decorated event callbacks. def _registerHandlers(self): for ev in _Events: bro_event_registry_add_compact(self.bc, ev.__name__, ev); ##### Wrapped helper functions. def current_time(): return bro_util_current_time() ##### Decorator @event(val-type1, val-type2, val-type3, ...) # List of all functions declared with the @event decorator # (more precisely, list of all of their wrappers; see below). _Events = [] def event(*types): # We wrap the event callback into a function which turns the 2-tuples (type,val) # that we get from the C layer into the corresponding Python object. def make_wrapper(func): def wrapped_f(*args): new_args = [] ptypes = types if not ptypes: # Allow omitting types. ptypes = [None] *len(args) for (arg, type) in zip(args, ptypes): # Split the 2-tuples passed to us by the C layer. (btype, val) = arg # Create an instance of the corresponding Python type. new_args += [instantiate(btype, val, type)] # Finally call the callback. return func(*new_args); # Pretend the wrapper has the name of the actual callback (rather than "wrapped_f" ...) wrapped_f.__name__ = func.__name__ # Add the wrapped function to the list of events handlers. global _Events _Events += [wrapped_f] return wrapped_f # Allow @event instead of @event() if len(types) == 1 and type(types[0]) == FunctionType: func = types[0] types = () return make_wrapper(func) else: return make_wrapper ##### Data types # For those Bro types which do not direcly correspond to Python type, we create # wrapper classes. For those which do (int, float), we use the Python type directly. # Base class for our wrapper classes. # For atomic types, the classes here act as both type and instances. For non-atomic # types (i.e., records) we define separate type and instance classes below. class Val: # Type is the Bro type BRO_TYPE_*. # Val is representation of the Val in a standard Python type. def __init__(self, type, val): self.type = type self.val = val self.__class__._bro_type = type # Doing it once would be sufficient. def __str__(self): return str(self.val) # Convert value into a 2-tuple (type, val) as expected by the C layer. def internalVal(self): return (self.type, self.val) class count(Val): def __init__(self, val): Val.__init__(self, BRO_TYPE_COUNT, int(val)) @staticmethod def _factory(val, dst_type): v = count(val) if dst_type == int or not dst_type: return v.val _typeCheck(dst_type, count) return v class interval(Val): def __init__(self, val): Val.__init__(self, BRO_TYPE_INTERVAL, float(val)) @staticmethod def _factory(val, dst_type): v = interval(val) if dst_type == float or not dst_type: return v.val _typeCheck(dst_type, interval) return v class time(Val): def __init__(self, val): Val.__init__(self, BRO_TYPE_TIME, float(val)) @staticmethod def _factory(val, dst_type): v = time(val) if dst_type == float or not dst_type: return v.val _typeCheck(dst_type, time) return v class port(Val): protos_by_name = { "tcp": 6, "udp": 17, "icmp": 1 } protos_by_num = { 6: "tcp", 17: "udp", 1: "icmp" } def __init__(self, str=None, internal=None): v = internal and internal or self._parse(str) Val.__init__(self, BRO_TYPE_PORT, v) def __str__(self): (port, proto) = self.val try: return "%d/%s" % (port, self.protos_by_num[proto]) except IndexError: return "%s/unknown" % port @staticmethod def _factory(val, dst_type): v = port(internal=val) if dst_type == str or not dst_type: return str(v) if dst_type == int: return v[0] _typeCheck(dst_type, port) return v def _parse(self, str): (port, proto) = str.split("/") try: return (int(port), self.protos_by_name[proto.lower()]) except (IndexError, ValueError): return (0, 0) class addr(Val): def __init__(self, str=None, internal=None): v = internal and internal or self._parse(str) Val.__init__(self, BRO_TYPE_IPADDR, v) def __str__(self): return _addrTupleToString(self.val) @staticmethod def _factory(val, dst_type): v = addr(internal=val) if dst_type == str or not dst_type: return str(v) _typeCheck(dst_type, addr) return v def _parse(self, str): return _addrStringToTuple(str) class subnet(Val): def __init__(self, str=None, internal=None): v = internal and internal or self._parse(str) Val.__init__(self, BRO_TYPE_SUBNET, v) def __str__(self): (net, mask) = self.val return "%s/%d" % (_addrTupleToString(net), mask) @staticmethod def _factory(val, dst_type): v = subnet(internal=val) if dst_type == str or not dst_type: return str(v) _typeCheck(dst_type, subnet) return v def _parse(self, str): (net, mask) = str.split("/") return (_addrStringToTuple(net), int(mask)) # Not supported at this point since Broccoli seems to have problems with # enums. Also need to write parse functions. class enum(Val): def __init__(self, str=None, internal=None): v = internal and internal or self._parse(str) Val.__init__(self, BRO_TYPE_ENUM, v) def __str__(self): return "XXXX" # FIXME @staticmethod def _factory(val, dst_type): v = enum(internal=val) _typeCheck(dst_type, enum) return v def _parse(self, str): return 0 # FIXME # Helper class for unset values. class unknown(Val): def __init__(self): Val.__init__(self, BRO_TYPE_UNKNOWN, None) # Type class for records, which maps field names to indices. # E.g., conn_id = record_type("orig_h", "orig_p", "resp_h", "resp_p") class record_type: def __init__(self, *fields): self.fields = fields @classmethod def _factory(self, vals, dst_type): # FIXME: Add _typeCheck(), # FIXME: For recursive records we'd need to pass the right record type # here instead of none, which we don't have. How to do that? # Init the field values. vals = [instantiate(btype, val, None) for (btype, val) in vals] return record(dst_type, vals) # Class for record instances. class record(Val): def __init__(self, type, vals = None): Val.__init__(self, BRO_TYPE_RECORD, {}) # Save the record's type. self._type = type if not vals: # Use Nones if we didn't get any values. vals = [None] * len(type.fields) # Initialize record fields. for (key, val) in zip(type.fields, vals): self.val[key] = val def internalVal(self): vals = [] for f in self._type.fields: v = self.val.get(f, None) if v != None: vals.append( (f, _getInternalVal(v)) ) return (BRO_TYPE_RECORD, vals) # Provide attribute access via "val.attr". def __getattr__(self, key): if "_type" in self.__dict__ and key in self._type.fields: return self.val[key] raise AttributeError def __setattr__(self, key, val): try: if key in self._type.fields: self.val[key] = val return except AttributeError: pass # FIXME: Check that key is defined in type. self.__dict__[key] = val # Helper to convert a tuple of network-byte-order IP address to a string. def _addrTupleToString(a): if len(a) == 1: return socket.inet_ntop(socket.AF_INET, struct.pack('=L', a[0])); else: return socket.inet_ntop(socket.AF_INET6, struct.pack('=4L', a[0], a[1], a[2], a[3])) # Helper to convert an IPv4/IPv6 address string into a network-byte-order tuple. def _addrStringToTuple(s): if ':' in s: return struct.unpack('=4L', socket.inet_pton(socket.AF_INET6, s)) else: return struct.unpack('=L', socket.inet_pton(socket.AF_INET, s)) # Helper to check whether two Python types match. def _typeCheck(type1, type2): def typeToBro(type): # Do the Python types manually. if type == int: return BRO_TYPE_INT; if type == bool: return BRO_TYPE_BOOL; if type == float: return BRO_TYPE_DOUBLE; if type == str: return BRO_TYPE_STRING; return type._bro_type if type1 and type2 and typeToBro(type1) != typeToBro(type2): raise TypeError # Helper to create the 2-tuple val. def _getInternalVal(arg): if arg == None: raise ValueError("uninitialized event argument") if type(arg) == int: return (BRO_TYPE_INT, arg) elif type(arg) == bool: return (BRO_TYPE_BOOL, arg) elif type(arg) == str: return(BRO_TYPE_STRING, arg) elif type(arg) == float: return(BRO_TYPE_DOUBLE, arg) else: return arg.internalVal() # Factories for Python internal types. def _long_factory(val, dst_type): if using_py3: return int(val) else: return long(val) def _bool_factory(val, dst_type): return bool(val) def _string_factory(val, dst_type): return str(val) def _float_factory(val, dst_type): return float(val) string = str double = float # Table of factories for all supported types so that we can dynamically # instantiate them. _Factories = { BRO_TYPE_INT: _long_factory, BRO_TYPE_BOOL: _bool_factory, BRO_TYPE_COUNT: count._factory, BRO_TYPE_TIME: time._factory, BRO_TYPE_INTERVAL: interval._factory, BRO_TYPE_DOUBLE: _float_factory, BRO_TYPE_STRING: _string_factory, BRO_TYPE_PORT: port._factory, BRO_TYPE_IPADDR: addr._factory, BRO_TYPE_SUBNET: subnet._factory, BRO_TYPE_ENUM: enum._factory, BRO_TYPE_RECORD: record_type._factory, } def instantiate(src_type, val, dst_type): return _Factories[src_type](val, dst_type) broccoli-python-0.63/broccoli_intern.i0000644000076500000240000003453513350246015020024 0ustar jonstaff00000000000000%module broccoli_intern %{ // Include the header in the wrapper code. #include #include #include // Broccoli internal struct. Easier to copy that here than to include a bunch // of Broccoli's internal headers. struct bro_record { void *val_list; int val_len; }; typedef BroRecord bro_record ; // Builds a 2-tuple (type, object). PyObject* makeTypeTuple(int type, PyObject *val) { PyObject *tuple = PyTuple_New(2); PyTuple_SetItem(tuple, 0, PyInt_FromLong(type)); PyTuple_SetItem(tuple, 1, val); return tuple; } // Builds a tuple representing an IP address. // Which consists of either 1-element in network-order for IPv4, or 4 // elements in network-order for IPv6. PyObject* makeAddrTuple(const BroAddr* a) { int i; PyObject* rval = 0; int len = bro_util_is_v4_addr(a) ? 1 : 4; rval = PyTuple_New(len); if ( len == 1 ) PyTuple_SetItem(rval, 0, PyLong_FromUnsignedLong(a->addr[3])); else for ( i = 0; i < 4; ++i ) PyTuple_SetItem(rval, i, PyLong_FromUnsignedLong(a->addr[i])); return rval; } // Checks that a tuple representing an IP address is either length one or four // and all elements are either int or long types, and returns 1 if true, else 0. int checkAddrTuple(PyObject* o) { if ( ! ( PyTuple_Check(o) && ( PyTuple_Size(o) == 1 || PyTuple_Size(o) == 4 ) ) ) { PyErr_SetString(PyExc_RuntimeError, "address must be a 1-tuple or 4-tuple"); return 0; } int i; for ( i = 0; i < PyTuple_Size(o); ++i ) { PyObject* it = PyTuple_GetItem(o, i); if ( ! PyLong_Check(it) && ! PyInt_Check(it) ) { PyErr_SetString(PyExc_RuntimeError, "address must contain ints or longs"); return 0; } } return 1; } // Fills in the Broccoli representation of an IP address from the Python one. void parseAddrTuple(PyObject* o, BroAddr* a) { int i; if ( PyTuple_Size(o) == 1 ) { memcpy(a->addr, BRO_IPV4_MAPPED_PREFIX, sizeof(BRO_IPV4_MAPPED_PREFIX)); PyObject* it = PyTuple_GetItem(o, 0); #if PY_MAJOR_VERSION >= 3 a->addr[3] = PyLong_AsUnsignedLongMask(it); #else a->addr[3] = PyInt_AsUnsignedLongMask(it); #endif } else for ( i = 0; i < 4; ++i ) { PyObject* it = PyTuple_GetItem(o, i); #if PY_MAJOR_VERSION >= 3 a->addr[i] = PyLong_AsUnsignedLongMask(it); #else a->addr[i] = PyInt_AsUnsignedLongMask(it); #endif } } // Parses a 2-tuple (type, object). Return 1 on success. // Borrows input's reference to object. int parseTypeTuple(PyObject* input, int *type, PyObject **val) { if ( ! (PyTuple_Check(input) && PyTuple_Size(input) == 2) ) { PyErr_SetString(PyExc_RuntimeError, "argument must be 2-tuple"); return 0; } PyObject *ptype = PyTuple_GetItem(input, 0); PyObject *pval = PyTuple_GetItem(input, 1); if ( ! PyInt_Check(ptype) ) { PyErr_SetString(PyExc_RuntimeError, "first tuple element must be integer"); return 0; } *type = PyInt_AsLong(ptype); if ( *type < 0 || *type > BRO_TYPE_MAX ) { PyErr_SetString(PyExc_RuntimeError, "unknown type in tuple"); return 0; } *val = pval; return 1; } // Release the memory associated with the Broccoli value. void freeBroccoliVal(int type, void* data) { if ( ! data ) return; switch ( type ) { case BRO_TYPE_STRING: free(((BroString *)data)->str_val); free(data); break; case BRO_TYPE_RECORD: bro_record_free((BroRecord *)data); break; default: free(data); } } // Converts a Broccoli value into a Python object. PyObject* valToPyObj(int type, void* data) { PyObject* val = 0; switch (type) { case BRO_TYPE_BOOL: val = PyBool_FromLong(*((int64_t *)data)); break; case BRO_TYPE_INT: case BRO_TYPE_COUNT: case BRO_TYPE_COUNTER: val = PyLong_FromLongLong(*((uint64_t *)data)); break; case BRO_TYPE_IPADDR: { val = makeAddrTuple((BroAddr*)data); break; } case BRO_TYPE_DOUBLE: case BRO_TYPE_TIME: case BRO_TYPE_INTERVAL: { val = PyFloat_FromDouble(*((double *)data)); break; } case BRO_TYPE_STRING: { BroString *str = (BroString*)data; #if PY_MAJOR_VERSION >= 3 val = PyUnicode_FromStringAndSize((const char*)str->str_val, str->str_len); #else val = PyString_FromStringAndSize((const char*)str->str_val, str->str_len); #endif break; } case BRO_TYPE_ENUM: { val = PyTuple_New(2); PyTuple_SetItem(val, 0, PyBool_FromLong(*((int *)data))); PyTuple_SetItem(val, 1, PyString_FromString("broccoli-doesnt-give-use-the-enum-type! :-(")); break; } case BRO_TYPE_PORT: { BroPort *port = (BroPort*)data; val = PyTuple_New(2); PyTuple_SetItem(val, 0, PyInt_FromLong(port->port_num)); PyTuple_SetItem(val, 1, PyInt_FromLong(port->port_proto)); break; } case BRO_TYPE_SUBNET: { BroSubnet *subnet = (BroSubnet*)data; PyObject *addr = makeAddrTuple(&subnet->sn_net); val = PyTuple_New(2); PyTuple_SetItem(val, 0, addr); PyTuple_SetItem(val, 1, PyInt_FromLong(subnet->sn_width)); break; } case BRO_TYPE_RECORD: { BroRecord *rec = (BroRecord*)data; PyObject *fields = PyList_New(rec->val_len); int i; for ( i = 0; i < rec->val_len; i++ ) { int type = BRO_TYPE_UNKNOWN; void *data = bro_record_get_nth_val(rec, i, &type); PyList_SetItem(fields, i, valToPyObj(type, data)); } val = fields; break; } default: PyErr_SetString(PyExc_RuntimeError, "unknown type"); return 0; } return makeTypeTuple(type, val); } // Converts a Python object into Broccoli value. int pyObjToVal(PyObject *val, int type, const char **type_name, void** data) { *type_name = 0; *data = 0; switch (type) { case BRO_TYPE_BOOL: case BRO_TYPE_INT: { int64_t* tmp = (int64_t *)malloc(sizeof(int64_t)); *tmp = PyInt_AsLong(val); *data = tmp; break; } case BRO_TYPE_COUNT: case BRO_TYPE_COUNTER: { uint64_t* tmp = (uint64_t *)malloc(sizeof(uint64_t)); *tmp = PyInt_AsLong(val); *data = tmp; break; } case BRO_TYPE_IPADDR: { if ( ! checkAddrTuple(val) ) return 0; BroAddr* addr = (BroAddr*)malloc(sizeof(BroAddr)); parseAddrTuple(val, addr); *data = addr; break; } case BRO_TYPE_DOUBLE: case BRO_TYPE_TIME: case BRO_TYPE_INTERVAL: { double* tmp = (double *)malloc(sizeof(double)); *tmp = PyFloat_AsDouble(val); *data = tmp; break; } case BRO_TYPE_STRING: { BroString* str = 0; #if PY_MAJOR_VERSION >= 3 const char* tmp = PyUnicode_AsUTF8(val); #else const char* tmp = PyString_AsString(val); #endif if ( ! tmp ) return 0; str = (BroString *)malloc(sizeof(BroString)); str->str_len = strlen(tmp); str->str_val = (uchar*)strdup(tmp); *data = str; break; } case BRO_TYPE_ENUM: { if ( ! (PyTuple_Check(val) && PyTuple_Size(val) == 2) ) { PyErr_SetString(PyExc_RuntimeError, "enum must be 2-tuple"); return 0; } int* tmp = (int *)malloc(sizeof(int)); *tmp = PyInt_AsLong(PyTuple_GetItem(val, 0)); *data = tmp; const char* enum_type = PyString_AsString(PyTuple_GetItem(val, 1)); if ( ! enum_type ) return 0; *type_name = strdup(enum_type); break; } case BRO_TYPE_PORT: { if ( ! (PyTuple_Check(val) && PyTuple_Size(val) == 2) ) { PyErr_SetString(PyExc_RuntimeError, "port must be 2-tuple"); return 0; } BroPort* port = (BroPort *)malloc(sizeof(BroPort)); port->port_num = PyInt_AsLong(PyTuple_GetItem(val, 0)); port->port_proto = PyInt_AsLong(PyTuple_GetItem(val, 1)); *data = port; break; } case BRO_TYPE_SUBNET: { if ( ! (PyTuple_Check(val) && PyTuple_Size(val) == 2) ) { PyErr_SetString(PyExc_RuntimeError, "subnet must be 2-tuple"); return 0; } PyObject* addr = PyTuple_GetItem(val, 0); if ( ! checkAddrTuple(addr) ) return 0; BroSubnet* subnet = (BroSubnet *)malloc(sizeof(BroSubnet)); parseAddrTuple(addr, &subnet->sn_net); subnet->sn_width = PyInt_AsLong(PyTuple_GetItem(val, 1)); *data = subnet; break; } case BRO_TYPE_RECORD: { BroRecord *rec = bro_record_new(); int i; for ( i = 0; i < PyList_Size(val); i++ ) { PyObject *nameAndValueTuple = PyList_GetItem(val, i); const char* fieldName = #if PY_MAJOR_VERSION >= 3 PyUnicode_AsUTF8(PyTuple_GetItem(nameAndValueTuple, 0)); #else PyString_AsString(PyTuple_GetItem(nameAndValueTuple, 0)); #endif PyObject *valueTuple = PyTuple_GetItem(nameAndValueTuple, 1); int ftype; PyObject *fval; if ( ! parseTypeTuple(valueTuple, &ftype, &fval) ) { bro_record_free(rec); return 0; } const char *ftype_name; void *fdata; if ( ! pyObjToVal(fval, ftype, &ftype_name, &fdata) ) { bro_record_free(rec); return 0; } bro_record_add_val(rec, fieldName, ftype, 0, fdata); freeBroccoliVal(ftype, fdata); } *data = rec; break; } default: PyErr_SetString(PyExc_RuntimeError, "unknown type"); return 0; } return 1; } // C-level event handler for events. We register all events with this callback, // passing the target Python function in via data. void event_callback(BroConn *bc, void *data, BroEvMeta *meta) { PyObject *func = (PyObject*)data; int i; PyObject *pyargs = PyTuple_New(meta->ev_numargs); for ( i = 0; i < meta->ev_numargs; i++ ) PyTuple_SetItem(pyargs, i, valToPyObj(meta->ev_args[i].arg_type, meta->ev_args[i].arg_data)); PyObject *result = PyObject_Call(func, pyargs, 0); Py_DECREF(pyargs); if ( result ) { Py_DECREF(result); } } %} // For bro_event_registry_add_compact(). %typemap(in) (BroCompactEventFunc func, void *user_data) { if ( ! PyFunction_Check($input) ) { PyErr_SetString(PyExc_RuntimeError, "callback must be a function"); return NULL; } $1 = event_callback; $2 = $input; Py_INCREF($input); } // For bro_event_add_val() and bro_record_add_val(). %typemap(in) (int type, const char *type_name, const void *val) { int type; const char* type_name; void *data; PyObject *val; //bro_debug_messages = 1; //bro_debug_calltrace = 1; if ( ! parseTypeTuple($input, &type, &val) ) return NULL; if ( ! pyObjToVal(val, type, &type_name, &data) ) return NULL; $1 = type; // swig ltypes are stripped of qualifiers so the following cast // is just to get rid of a compiler warning. $2 = (char*)type_name; $3 = data; } %typemap(arginit) (int type, const char *type_name, const void *val) { $1 = 0; $2 = 0; $3 = 0; } %typemap(freearg) (int type, const char *type_name, const void *val) { // Broccoli makes copies of the passed data so we need to clean up. freeBroccoliVal($1, $3); if ( $2 ) free($2); } ///// The following is a subset of broccoli.h for which we provide wrappers. #define BRO_TYPE_UNKNOWN 0 #define BRO_TYPE_BOOL 1 #define BRO_TYPE_INT 2 #define BRO_TYPE_COUNT 3 #define BRO_TYPE_COUNTER 4 #define BRO_TYPE_DOUBLE 5 #define BRO_TYPE_TIME 6 #define BRO_TYPE_INTERVAL 7 #define BRO_TYPE_STRING 8 #define BRO_TYPE_PATTERN 9 #define BRO_TYPE_ENUM 10 #define BRO_TYPE_TIMER 11 #define BRO_TYPE_PORT 12 #define BRO_TYPE_IPADDR 13 #define BRO_TYPE_SUBNET 14 #define BRO_TYPE_ANY 15 #define BRO_TYPE_TABLE 16 #define BRO_TYPE_UNION 17 #define BRO_TYPE_RECORD 18 #define BRO_TYPE_LIST 19 #define BRO_TYPE_FUNC 20 #define BRO_TYPE_FILE 21 #define BRO_TYPE_VECTOR 22 #define BRO_TYPE_ERROR 23 #define BRO_TYPE_PACKET 24 #define BRO_TYPE_SET 25 #define BRO_TYPE_MAX 26 #define BRO_CFLAG_NONE 0 #define BRO_CFLAG_RECONNECT (1 << 0) #define BRO_CFLAG_ALWAYS_QUEUE (1 << 1) #define BRO_CFLAG_SHAREABLE (1 << 2) #define BRO_CFLAG_DONTCACHE (1 << 3) #define BRO_CFLAG_YIELD (1 << 4) #define BRO_CFLAG_CACHE (1 << 5) // The exact types of these don't really matter as we're only // passing pointers around. typedef void BroCtx; typedef void BroConn; typedef void BroEvent; int bro_init(const BroCtx *ctx); BroConn *bro_conn_new_str(const char *hostname, int flags); void bro_conn_set_class(BroConn *bc, const char *classname); int bro_conn_connect(BroConn *bc); int bro_conn_process_input(BroConn *bc); int bro_event_queue_length(BroConn *bc); BroEvent *bro_event_new(const char *event_name); void bro_event_free(BroEvent *be); int bro_event_add_val(BroEvent *be, int type, const char *type_name,const void *val); int bro_event_send(BroConn *bc, BroEvent *be); void bro_event_registry_add_compact(BroConn *bc, const char *event_name, BroCompactEventFunc func, void *user_data); double bro_util_current_time(void); int bro_conn_get_fd(BroConn *bc); int bro_conn_delete(BroConn *bc); int bro_conn_alive(BroConn *bc); broccoli-python-0.63/cmake/0000755000076500000240000000000013350260210015536 5ustar jonstaff00000000000000broccoli-python-0.63/cmake/.git0000644000076500000240000000014013350246016016325 0ustar jonstaff00000000000000gitdir: ../../../../../.git/modules/aux/broccoli/modules/bindings/broccoli-python/modules/cmake broccoli-python-0.63/cmake/AddUninstallTarget.cmake0000644000076500000240000000067413350246016022310 0ustar jonstaff00000000000000if (NOT TARGET uninstall) if ( EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in" ) configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" @ONLY) add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) endif () endif () broccoli-python-0.63/cmake/BifCl.cmake0000644000076500000240000002301413350246016017527 0ustar jonstaff00000000000000 # A macro to define a command that uses the BIF compiler to produce C++ # segments and Bro language declarations from a .bif file. The outputs # are returned in BIF_OUTPUT_{CC,H,BRO}. By default, it runs bifcl in # alternative mode (-a; suitable for standalone compilation). If # an additional parameter "standard" is given, it runs it in standard mode # for inclusion in NetVar.*. If an additional parameter "plugin" is given, # it runs it in plugin mode (-p). In the latter case, one more argument # is required with the plugin's name. # # The macro also creates a target that can be used to define depencencies on # the generated files. The name of the target depends on the mode and includes # a normalized path to the input bif to make it unique. The target is added # automatically to bro_ALL_GENERATED_OUTPUTS. macro(bif_target bifInput) set(target "") get_filename_component(bifInputBasename "${bifInput}" NAME) if ( "${ARGV1}" STREQUAL "standard" ) set(bifcl_args "") set(target "bif-std-${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename}") set(bifOutputs ${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename}.func_def ${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename}.func_h ${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename}.func_init ${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename}.netvar_def ${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename}.netvar_h ${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename}.netvar_init) set(BIF_OUTPUT_CC ${bifInputBasename}.func_def ${bifInputBasename}.func_init ${bifInputBasename}.netvar_def ${bifInputBasename}.netvar_init) set(BIF_OUTPUT_H ${bifInputBasename}.func_h ${bifInputBasename}.netvar_h) set(BIF_OUTPUT_BRO ${CMAKE_BINARY_DIR}/scripts/base/bif/${bifInputBasename}.bro) set(bro_BASE_BIF_SCRIPTS ${bro_BASE_BIF_SCRIPTS} ${BIF_OUTPUT_BRO} CACHE INTERNAL "Bro script stubs for BIFs in base distribution of Bro" FORCE) # Propogate to top-level elseif ( "${ARGV1}" STREQUAL "plugin" ) set(plugin_name ${ARGV2}) set(plugin_name_canon ${ARGV3}) set(plugin_is_static ${ARGV4}) set(target "bif-plugin-${plugin_name_canon}-${bifInputBasename}") set(bifcl_args "-p;${plugin_name}") set(bifOutputs ${bifInputBasename}.h ${bifInputBasename}.cc ${bifInputBasename}.init.cc ${bifInputBasename}.register.cc) if ( plugin_is_static ) set(BIF_OUTPUT_CC ${bifInputBasename}.cc ${bifInputBasename}.init.cc) set(bro_REGISTER_BIFS ${bro_REGISTER_BIFS} ${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename} CACHE INTERNAL "BIFs for automatic registering" FORCE) # Propagate to top-level. else () set(BIF_OUTPUT_CC ${bifInputBasename}.cc ${bifInputBasename}.init.cc ${bifInputBasename}.register.cc) endif() set(BIF_OUTPUT_H ${bifInputBasename}.h) if ( NOT BRO_PLUGIN_BUILD_DYNAMIC ) set(BIF_OUTPUT_BRO ${CMAKE_BINARY_DIR}/scripts/base/bif/plugins/${plugin_name_canon}.${bifInputBasename}.bro) else () set(BIF_OUTPUT_BRO ${BRO_PLUGIN_BIF}/${bifInputBasename}.bro) endif() set(bro_PLUGIN_BIF_SCRIPTS ${bro_PLUGIN_BIF_SCRIPTS} ${BIF_OUTPUT_BRO} CACHE INTERNAL "Bro script stubs for BIFs in Bro plugins" FORCE) # Propogate to top-level else () # Alternative mode. These will get compiled in automatically. set(bifcl_args "-s") set(target "bif-alt-${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename}") set(bifOutputs ${bifInputBasename}.h ${bifInputBasename}.cc ${bifInputBasename}.init.cc) set(BIF_OUTPUT_CC ${bifInputBasename}.cc) set(BIF_OUTPUT_H ${bifInputBasename}.h) # In order be able to run bro from the build directory, the # generated bro script needs to be inside a directory tree # named the same way it will be referenced from an @load. set(BIF_OUTPUT_BRO ${CMAKE_BINARY_DIR}/scripts/base/bif/${bifInputBasename}.bro) set(bro_AUTO_BIFS ${bro_AUTO_BIFS} ${CMAKE_CURRENT_BINARY_DIR}/${bifInputBasename} CACHE INTERNAL "BIFs for automatic inclusion" FORCE) # Propagate to top-level. set(bro_BASE_BIF_SCRIPTS ${bro_BASE_BIF_SCRIPTS} ${BIF_OUTPUT_BRO} CACHE INTERNAL "Bro script stubs for BIFs in base distribution of Bro" FORCE) # Propogate to top-level endif () if ( BRO_PLUGIN_INTERNAL_BUILD ) if ( BIFCL_EXE_PATH ) set(BifCl_EXE ${BIFCL_EXE_PATH}) else () set(BifCl_EXE "bifcl") endif () else () if ( NOT BifCl_EXE ) if ( BRO_PLUGIN_BRO_BUILD ) set(BifCl_EXE "${BRO_PLUGIN_BRO_BUILD}/aux/bifcl/bifcl") else () find_program(BifCl_EXE bifcl) if ( NOT BifCl_EXE ) message(FATAL_ERROR "Failed to find 'bifcl' program") endif () endif () endif () endif () set(bifclDep ${BifCl_EXE}) add_custom_command(OUTPUT ${bifOutputs} ${BIF_OUTPUT_BRO} COMMAND ${BifCl_EXE} ARGS ${bifcl_args} ${CMAKE_CURRENT_SOURCE_DIR}/${bifInput} || (rm -f ${bifOutputs} && exit 1) COMMAND "${CMAKE_COMMAND}" ARGS -E copy ${bifInputBasename}.bro ${BIF_OUTPUT_BRO} COMMAND "${CMAKE_COMMAND}" ARGS -E remove -f ${bifInputBasename}.bro DEPENDS ${bifInput} DEPENDS ${bifclDep} COMMENT "[BIFCL] Processing ${bifInput}" ) string(REGEX REPLACE "${CMAKE_BINARY_DIR}/src/" "" target "${target}") string(REGEX REPLACE "/" "-" target "${target}") add_custom_target(${target} DEPENDS ${BIF_OUTPUT_H} ${BIF_OUTPUT_CC}) set_source_files_properties(${bifOutputs} PROPERTIES GENERATED 1) set(BIF_BUILD_TARGET ${target}) set(bro_ALL_GENERATED_OUTPUTS ${bro_ALL_GENERATED_OUTPUTS} ${target} CACHE INTERNAL "automatically generated files" FORCE) # Propagate to top-level. endmacro(bif_target) # A macro to create a __load__.bro file for all *.bif.bro files in # a given collection (which should all be in the same directory). # It creates a corresponding target to trigger the generation. function(bro_bif_create_loader target bifinputs) set(_bif_loader_dir "") foreach ( _bro_file ${bifinputs} ) get_filename_component(_bif_loader_dir_tmp ${_bro_file} PATH) get_filename_component(_bro_file_name ${_bro_file} NAME) if ( _bif_loader_dir ) if ( NOT _bif_loader_dir_tmp STREQUAL _bif_loader_dir ) message(FATAL_ERROR "Directory of Bro script BIF stub ${_bro_file} differs from expected: ${_bif_loader_dir}") endif () else () set(_bif_loader_dir ${_bif_loader_dir_tmp}) endif () set(_bif_loader_content "${_bif_loader_content} ${_bro_file_name}") endforeach () if ( NOT _bif_loader_dir ) return () endif () file(MAKE_DIRECTORY ${_bif_loader_dir}) set(_bif_loader_file ${_bif_loader_dir}/__load__.bro) add_custom_target(${target} COMMAND "sh" "-c" "rm -f ${_bif_loader_file}" COMMAND "sh" "-c" "for i in ${_bif_loader_content}; do echo @load ./$i >> ${_bif_loader_file}; done" WORKING_DIRECTORY ${_bif_loader_dir} VERBATIM ) add_dependencies(${target} generate_outputs) endfunction() # A macro to create joint include files for compiling in all the # autogenerated bif code. function(bro_bif_create_includes target dstdir bifinputs) file(MAKE_DIRECTORY ${dstdir}) add_custom_target(${target} COMMAND "sh" "-c" "rm -f ${dstdir}/__all__.bif.cc.tmp" COMMAND "sh" "-c" "rm -f ${dstdir}/__all__.bif.init.cc.tmp" COMMAND for i in ${bifinputs}\; do echo \\\#include \\"\$\$i.cc\\"\; done >> ${dstdir}/__all__.bif.cc.tmp COMMAND for i in ${bifinputs}\; do echo \\\#include \\"\$\$i.init.cc\\"\; done >> ${dstdir}/__all__.bif.init.cc.tmp COMMAND ${CMAKE_COMMAND} -E copy_if_different "${dstdir}/__all__.bif.cc.tmp" "${dstdir}/__all__.bif.cc" COMMAND ${CMAKE_COMMAND} -E copy_if_different "${dstdir}/__all__.bif.init.cc.tmp" "${dstdir}/__all__.bif.init.cc" COMMAND "sh" "-c" "rm -f ${dstdir}/__all__.bif.cc.tmp" COMMAND "sh" "-c" "rm -f ${dstdir}/__all__.bif.init.cc.tmp" WORKING_DIRECTORY ${dstdir} ) set(clean_files ${dstdir}/__all__.bif.cc ${dstdir}/__all__.bif.init.cc) set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${clean_files}") endfunction() function(bro_bif_create_register target dstdir bifinputs) file(MAKE_DIRECTORY ${dstdir}) add_custom_target(${target} COMMAND "sh" "-c" "rm -f ${dstdir}/__all__.bif.register.cc.tmp" COMMAND for i in ${bifinputs}\; do echo \\\#include \\"\$\$i.register.cc\\"\; done >> ${dstdir}/__all__.bif.register.cc.tmp COMMAND ${CMAKE_COMMAND} -E copy_if_different "${dstdir}/__all__.bif.register.cc.tmp" "${dstdir}/__all__.bif.register.cc" COMMAND "sh" "-c" "rm -f ${dstdir}/__all__.bif.register.cc.tmp" WORKING_DIRECTORY ${dstdir} ) set(clean_files ${dstdir}/__all__.bif.cc ${dstdir}/__all__.bif.register.cc) set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${clean_files}") endfunction() broccoli-python-0.63/cmake/BinPAC.cmake0000644000076500000240000000476713350246016017622 0ustar jonstaff00000000000000 # A macro to define a command that uses the BinPac compiler to # produce C++ code that implements a protocol parser/analyzer. # The outputs are returned in BINPAC_OUTPUT_{CC,H}. # Additional dependencies are pulled from BINPAC_AUXSRC. # # The macro also creates a target that can be used to define depencencies on # the generated files. The name of the target includes a normalized path to # the input pac to make it unique. The target is added automatically to # bro_ALL_GENERATED_OUTPUTS. macro(BINPAC_TARGET pacFile) if ( BRO_PLUGIN_INTERNAL_BUILD ) if ( BINPAC_EXE_PATH ) set(BinPAC_EXE ${BINPAC_EXE_PATH}) endif () set(binpacDep "${BinPAC_EXE}") else () if ( BRO_PLUGIN_BRO_BUILD ) set(BinPAC_EXE "${BRO_PLUGIN_BRO_BUILD}/aux/binpac/src/binpac") set(BinPAC_addl_args "-I;${BRO_PLUGIN_BRO_SRC}/src") else () find_package(BinPAC REQUIRED) set(BinPAC_addl_args "-I;${BRO_PLUGIN_BRO_CONFIG_INCLUDE_DIR}") endif () endif () get_filename_component(basename ${pacFile} NAME_WE) add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${basename}_pac.h ${CMAKE_CURRENT_BINARY_DIR}/${basename}_pac.cc COMMAND ${BinPAC_EXE} ARGS -q -d ${CMAKE_CURRENT_BINARY_DIR} -I ${CMAKE_CURRENT_SOURCE_DIR} -I ${CMAKE_SOURCE_DIR}/src ${BinPAC_addl_args} ${CMAKE_CURRENT_SOURCE_DIR}/${pacFile} DEPENDS ${binpacDep} ${pacFile} ${BINPAC_AUXSRC} ${ARGN} COMMENT "[BINPAC] Processing ${pacFile}" ) set(BINPAC_OUTPUT_H ${CMAKE_CURRENT_BINARY_DIR}/${basename}_pac.h) set(BINPAC_OUTPUT_CC ${CMAKE_CURRENT_BINARY_DIR}/${basename}_pac.cc) set(pacOutputs ${BINPAC_OUTPUT_H} ${BINPAC_OUTPUT_CC}) set_property(SOURCE ${BINPAC_OUTPUT_CC} APPEND_STRING PROPERTY COMPILE_FLAGS "-Wno-tautological-compare") set(target "pac-${CMAKE_CURRENT_BINARY_DIR}/${pacFile}") string(REGEX REPLACE "${CMAKE_BINARY_DIR}/src/" "" target "${target}") string(REGEX REPLACE "/" "-" target "${target}") add_custom_target(${target} DEPENDS ${pacOutputs}) set(BINPAC_BUILD_TARGET ${target}) set(bro_ALL_GENERATED_OUTPUTS ${bro_ALL_GENERATED_OUTPUTS} ${target} CACHE INTERNAL "automatically generated files" FORCE) # Propagate to top-level. endmacro(BINPAC_TARGET) broccoli-python-0.63/cmake/BroPlugin.cmake0000644000076500000240000000073313350246016020454 0ustar jonstaff00000000000000 # Wrapper include file that loads the macros for building a Bro # plugin either statically or dynamically, depending on whether # we're building as part of the main Bro source tree, or externally. if ( BRO_PLUGIN_INTERNAL_BUILD ) if ( "${BRO_PLUGIN_BUILD_DYNAMIC}" STREQUAL "" ) set(BRO_PLUGIN_BUILD_DYNAMIC FALSE) endif() else () set(BRO_PLUGIN_BUILD_DYNAMIC TRUE) endif () include(BroPluginCommon) include(BroPluginStatic) include(BroPluginDynamic) broccoli-python-0.63/cmake/BroPluginCommon.cmake0000644000076500000240000000560313350246016021626 0ustar jonstaff00000000000000## A set of functions for defining Bro plugins. ## ## This set is used by both static and dynamic plugins via ## BroPluginsStatic and BroPluginsDynamic, respectively. include(RequireCXX11) include(BifCl) include(BinPAC) # Begins a plugin definition, giving its namespace and name as the arguments. function(bro_plugin_begin ns name) _plugin_target_name(target "${ns}" "${name}") set(_plugin_lib "${target}" PARENT_SCOPE) set(_plugin_name "${ns}::${name}" PARENT_SCOPE) set(_plugin_name_canon "${ns}_${name}" PARENT_SCOPE) set(_plugin_ns "${ns}" PARENT_SCOPE) set(_plugin_objs "" PARENT_SCOPE) set(_plugin_deps "" PARENT_SCOPE) set(_plugin_dist "" PARENT_SCOPE) endfunction() # Adds *.cc files to a plugin. function(bro_plugin_cc) list(APPEND _plugin_objs ${ARGV}) set(_plugin_objs "${_plugin_objs}" PARENT_SCOPE) endfunction() # Adds a *.pac file to a plugin. Further *.pac files may given that # it depends on. function(bro_plugin_pac) binpac_target(${ARGV}) list(APPEND _plugin_objs ${BINPAC_OUTPUT_CC}) list(APPEND _plugin_deps ${BINPAC_BUILD_TARGET}) set(_plugin_objs "${_plugin_objs}" PARENT_SCOPE) set(_plugin_deps "${_plugin_deps}" PARENT_SCOPE) endfunction() # Add an additional object file to the plugin's library. function(bro_plugin_obj) foreach ( bif ${ARGV} ) list(APPEND _plugin_objs ${bif}) set(_plugin_objs "${_plugin_objs}" PARENT_SCOPE) endforeach () endfunction() # Add additional files that should be included into the binary plugin distribution. # Ignored for static plugins. macro(bro_plugin_dist_files) foreach ( file ${ARGV} ) list(APPEND _plugin_dist ${file}) # Don't need this here, and generates an error that # there is not parent scope. Not sure why it does that # here but not for other macros doing something similar. # set(_plugin_dist "${_plugin_dist}" PARENT_SCOPE) endforeach () endmacro() # Link an additional library to the plugin's library. function(bro_plugin_link_library) if ( BRO_PLUGIN_BUILD_DYNAMIC ) bro_plugin_link_library_dynamic(${ARGV}) else () bro_plugin_link_library_static(${ARGV}) endif () endfunction() # Adds *.bif files to a plugin. macro(bro_plugin_bif) if ( BRO_PLUGIN_BUILD_DYNAMIC ) bro_plugin_bif_dynamic(${ARGV}) else () bro_plugin_bif_static(${ARGV}) endif () endmacro() # Ends a plugin definition. macro(bro_plugin_end) if ( BRO_PLUGIN_BUILD_DYNAMIC ) bro_plugin_end_dynamic(${ARGV}) else () bro_plugin_end_static(${ARGV}) endif () endmacro() # Internal macro to create a unique target name for a plugin. macro(_plugin_target_name target ns name) if ( BRO_PLUGIN_BUILD_DYNAMIC ) _plugin_target_name_dynamic(${ARGV}) else () _plugin_target_name_static(${ARGV}) endif () endmacro() broccoli-python-0.63/cmake/BroPluginDynamic.cmake0000644000076500000240000003054513350246016021765 0ustar jonstaff00000000000000## A set of functions for defining Bro plugins. ## ## This set is for plugins compiled dynamically for loading at run-time. ## See BroPluginsStatic.cmake for the static version. ## ## Note: This is meant to run as a standalone CMakeLists.txt. It sets ## up all the basic infrastructure to compile a dynamic Bro plugin when ## included from its top-level CMake file. if ( NOT BRO_PLUGIN_INTERNAL_BUILD ) set(BRO_PLUGIN_BRO_PLUGIN_INSTALL_PATH "${BRO_PLUGIN_INSTALL_ROOT}" CACHE INTERNAL "" FORCE) if ( BRO_DIST ) include(${BRO_DIST}/cmake/CommonCMakeConfig.cmake) if ( NOT EXISTS "${BRO_DIST}/build/CMakeCache.txt" ) message(FATAL_ERROR "${BRO_DIST}/build/CMakeCache.txt; has Bro been built?") endif () load_cache("${BRO_DIST}/build" READ_WITH_PREFIX bro_cache_ CMAKE_INSTALL_PREFIX Bro_BINARY_DIR Bro_SOURCE_DIR ENABLE_DEBUG BRO_PLUGIN_INSTALL_PATH BRO_EXE_PATH CMAKE_CXX_FLAGS CMAKE_C_FLAGS CAF_INCLUDE_DIR_CORE CAF_INCLUDE_DIR_IO CAF_INCLUDE_DIR_OPENSSL) if ( NOT BRO_PLUGIN_BRO_PLUGIN_INSTALL_PATH ) set(BRO_PLUGIN_BRO_PLUGIN_INSTALL_PATH "${bro_cache_BRO_PLUGIN_INSTALL_PATH}" CACHE INTERNAL "" FORCE) endif () set(BRO_PLUGIN_BRO_INSTALL_PREFIX "${bro_cache_CMAKE_INSTALL_PREFIX}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_ENABLE_DEBUG "${bro_cache_ENABLE_DEBUG}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BRO_SRC "${bro_cache_Bro_SOURCE_DIR}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BRO_BUILD "${bro_cache_Bro_BINARY_DIR}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BRO_EXE_PATH "${bro_cache_BRO_EXE_PATH}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BRO_CMAKE ${BRO_PLUGIN_BRO_SRC}/cmake) set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH}) set(CMAKE_MODULE_PATH ${BRO_PLUGIN_BRO_CMAKE} ${CMAKE_MODULE_PATH}) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${bro_cache_CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${bro_cache_CMAKE_CXX_FLAGS}") include_directories(BEFORE ${BRO_PLUGIN_BRO_SRC}/src ${BRO_PLUGIN_BRO_SRC}/aux/binpac/lib ${BRO_PLUGIN_BRO_SRC}/aux/broker ${BRO_PLUGIN_BRO_BUILD} ${BRO_PLUGIN_BRO_BUILD}/src ${BRO_PLUGIN_BRO_BUILD}/aux/binpac/lib ${BRO_PLUGIN_BRO_BUILD}/aux/broker ${bro_cache_CAF_INCLUDE_DIR_CORE} ${bro_cache_CAF_INCLUDE_DIR_IO} ${bro_cache_CAF_INCLUDE_DIR_OPENSSL} ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src ) set(ENV{PATH} "${BRO_PLUGIN_BRO_BUILD}/build/src:$ENV{PATH}") else () # Independent from BRO_DIST source tree if ( NOT BRO_CONFIG_CMAKE_DIR ) message(FATAL_ERROR "CMake var. BRO_CONFIG_CMAKE_DIR must be set" " to the path where Bro installed its cmake modules") endif () include(${BRO_CONFIG_CMAKE_DIR}/CommonCMakeConfig.cmake) if ( NOT BRO_PLUGIN_BRO_PLUGIN_INSTALL_PATH ) if ( NOT BRO_CONFIG_PLUGIN_DIR ) message(FATAL_ERROR "CMake var. BRO_CONFIG_PLUGIN_DIR must be" " set to the path where Bro installs its plugins") endif () set(BRO_PLUGIN_BRO_PLUGIN_INSTALL_PATH "${BRO_CONFIG_PLUGIN_DIR}" CACHE INTERNAL "" FORCE) endif () if ( NOT BRO_CONFIG_PREFIX ) message(FATAL_ERROR "CMake var. BRO_CONFIG_PREFIX must be set" " to the root installation path of Bro") endif () if ( NOT BRO_CONFIG_INCLUDE_DIR ) message(FATAL_ERROR "CMake var. BRO_CONFIG_INCLUDE_DIR must be set" " to the installation path of Bro headers") endif () set(BRO_PLUGIN_BRO_CONFIG_INCLUDE_DIR "${BRO_CONFIG_INCLUDE_DIR}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BRO_INSTALL_PREFIX "${BRO_CONFIG_PREFIX}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BRO_EXE_PATH "${BRO_CONFIG_PREFIX}/bin/bro" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BRO_CMAKE ${BRO_CONFIG_CMAKE_DIR}) set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH}) set(CMAKE_MODULE_PATH ${BRO_PLUGIN_BRO_CMAKE} ${CMAKE_MODULE_PATH}) find_package(BinPAC REQUIRED) find_package(CAF COMPONENTS core io openssl REQUIRED) find_package(Broker REQUIRED) include_directories(BEFORE ${BRO_CONFIG_INCLUDE_DIR} ${BinPAC_INCLUDE_DIR} ${BROKER_INCLUDE_DIR} ${CAF_INCLUDE_DIR_CORE} ${CAF_INCLUDE_DIR_IO} ${CAF_INCLUDE_DIR_OPENSSL} ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/src ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src ) endif () if ( NOT BRO_PLUGIN_BASE ) set(BRO_PLUGIN_BASE "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "" FORCE) endif () set(BRO_PLUGIN_SCRIPTS "${CMAKE_CURRENT_BINARY_DIR}/scripts" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_SCRIPTS_SRC "${BRO_PLUGIN_BASE}/scripts" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BUILD "${CMAKE_CURRENT_BINARY_DIR}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_LIB "${BRO_PLUGIN_BUILD}/lib" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BIF "${BRO_PLUGIN_LIB}/bif" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_MAGIC "${BRO_PLUGIN_BUILD}/__bro_plugin__" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_README "${BRO_PLUGIN_BASE}/README" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_INTERNAL_BUILD false CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BUILD_DYNAMIC true CACHE INTERNAL "" FORCE) message(STATUS "Bro executable : ${BRO_PLUGIN_BRO_EXE_PATH}") message(STATUS "Bro source : ${BRO_PLUGIN_BRO_SRC}") message(STATUS "Bro build : ${BRO_PLUGIN_BRO_BUILD}") message(STATUS "Bro install prefix : ${BRO_PLUGIN_BRO_INSTALL_PREFIX}") message(STATUS "Bro plugin directory: ${BRO_PLUGIN_BRO_PLUGIN_INSTALL_PATH}") message(STATUS "Bro debug mode : ${BRO_PLUGIN_ENABLE_DEBUG}") if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") # By default Darwin's linker requires all symbols to be present at link time. set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -undefined dynamic_lookup -Wl,-bind_at_load") endif () set(bro_PLUGIN_LIBS CACHE INTERNAL "plugin libraries" FORCE) set(bro_PLUGIN_BIF_SCRIPTS CACHE INTERNAL "Bro script stubs for BIFs in Bro plugins" FORCE) add_definitions(-DBRO_PLUGIN_INTERNAL_BUILD=false) add_custom_target(generate_outputs) if ( BRO_PLUGIN_ENABLE_DEBUG ) set(ENABLE_DEBUG true) set(CMAKE_BUILD_TYPE Debug) endif () include(SetDefaultCompileFlags) else () set(BRO_PLUGIN_BASE "${CMAKE_CURRENT_BINARY_DIR}" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_LIB "${CMAKE_CURRENT_BINARY_DIR}/lib" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_BIF "${BRO_PLUGIN_LIB}/bif" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_MAGIC "${BRO_PLUGIN_BASE}/__bro_plugin__" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_README "${BRO_PLUGIN_BASE}/README" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_SCRIPTS "${BRO_PLUGIN_BASE}/scripts" CACHE INTERNAL "" FORCE) set(BRO_PLUGIN_SCRIPTS_SRC "${CMAKE_CURRENT_SOURCE_DIR}/scripts" CACHE INTERNAL "" FORCE) endif () include(GetArchitecture) function(bro_plugin_bif_dynamic) foreach ( bif ${ARGV} ) bif_target(${bif} "plugin" ${_plugin_name} ${_plugin_name_canon} FALSE) list(APPEND _plugin_objs ${BIF_OUTPUT_CC}) list(APPEND _plugin_deps ${BIF_BUILD_TARGET}) set(_plugin_objs "${_plugin_objs}" PARENT_SCOPE) set(_plugin_deps "${_plugin_deps}" PARENT_SCOPE) endforeach () endfunction() function(bro_plugin_link_library_dynamic) foreach ( lib ${ARGV} ) set(_plugin_libs ${_plugin_libs} ${lib} CACHE INTERNAL "dynamic plugin libraries") endforeach () endfunction() function(bro_plugin_end_dynamic) # Create the dynamic library/bundle. add_library(${_plugin_lib} MODULE ${_plugin_objs}) set_target_properties(${_plugin_lib} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${BRO_PLUGIN_LIB}") set_target_properties(${_plugin_lib} PROPERTIES PREFIX "") # set_target_properties(${_plugin_lib} PROPERTIES ENABLE_EXPORTS TRUE) add_dependencies(${_plugin_lib} generate_outputs) if ( _plugin_deps ) add_dependencies(${_plugin_lib} ${_plugin_deps}) endif() target_link_libraries(${_plugin_lib} ${_plugin_libs}) # Create bif/__init__.bro. bro_bif_create_loader(bif-init-${_plugin_name_canon} "${bro_PLUGIN_BIF_SCRIPTS}") # Copy scripts/ if it's not already at the right place inside the # plugin directory. (Actually, we create a symbolic link rather # than copy so that edits to the scripts show up immediately.) if ( NOT "${BRO_PLUGIN_SCRIPTS_SRC}" STREQUAL "${BRO_PLUGIN_SCRIPTS}" ) add_custom_target(copy-scripts-${_plugin_name_canon} # COMMAND "${CMAKE_COMMAND}" -E remove_directory ${BRO_PLUGIN_SCRIPTS} # COMMAND "${CMAKE_COMMAND}" -E copy_directory ${BRO_PLUGIN_SCRIPTS_SRC} ${BRO_PLUGIN_SCRIPTS}) COMMAND test -d ${BRO_PLUGIN_SCRIPTS_SRC} && rm -f ${BRO_PLUGIN_SCRIPTS} && ln -s ${BRO_PLUGIN_SCRIPTS_SRC} ${BRO_PLUGIN_SCRIPTS} || true) add_dependencies(${_plugin_lib} copy-scripts-${_plugin_name_canon}) endif() if ( _plugin_deps ) add_dependencies(bif-init-${_plugin_name_canon} ${_plugin_deps}) add_dependencies(${_plugin_lib} bif-init-${_plugin_name_canon}) endif() # Create __bro_plugin__ # string(REPLACE "${BRO_PLUGIN_BASE}/" "" msg "Creating ${BRO_PLUGIN_MAGIC} for ${_plugin_name}") get_filename_component(_magic_basename ${BRO_PLUGIN_MAGIC} NAME) add_custom_target(bro-plugin-${_plugin_name_canon} COMMAND echo "${_plugin_name}" ">${BRO_PLUGIN_MAGIC}" COMMENT "Creating ${_magic_basename} for ${_plugin_name}") if ( _plugin_deps ) add_dependencies(bro-plugin-${_plugin_name_canon} ${_plugin_deps}) endif() add_dependencies(${_plugin_lib} bro-plugin-${_plugin_name_canon}) set(_dist_tarball_name ${_plugin_name_canon}.tar.gz) set(_dist_output ${CMAKE_CURRENT_BINARY_DIR}/${_dist_tarball_name}) # Create binary install package. add_custom_command(OUTPUT ${_dist_output} COMMAND ${BRO_PLUGIN_BRO_CMAKE}/bro-plugin-create-package.sh ${_plugin_name_canon} ${_plugin_dist} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} DEPENDS ${_plugin_lib} COMMENT "Building binary plugin package: ${_dist_tarball_name}") add_custom_target(dist ALL DEPENDS ${_dist_output}) set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES ${BRO_PLUGIN_BIF}) set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES ${BRO_PLUGIN_LIB}) set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES ${BRO_PLUGIN_MAGIC}) ### Plugin installation. set(plugin_install "${BRO_PLUGIN_BRO_PLUGIN_INSTALL_PATH}/${_plugin_name_canon}") INSTALL(CODE "execute_process( COMMAND ${BRO_PLUGIN_BRO_CMAKE}/bro-plugin-install-package.sh ${_plugin_name_canon} \$ENV{DESTDIR}/${BRO_PLUGIN_BRO_PLUGIN_INSTALL_PATH} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} )") endfunction() macro(_plugin_target_name_dynamic target ns name) set(${target} "${ns}-${name}.${HOST_ARCHITECTURE}") endmacro() broccoli-python-0.63/cmake/BroPluginStatic.cmake0000644000076500000240000000262613350246016021627 0ustar jonstaff00000000000000## A set of functions for defining Bro plugins. ## ## This set is for plugins compiled in statically. ## See BroPluginsDynamic.cmake for the dynamic version. function(bro_plugin_bif_static) foreach ( bif ${ARGV} ) bif_target(${bif} "plugin" ${_plugin_name} ${_plugin_name_canon} TRUE) list(APPEND _plugin_objs ${BIF_OUTPUT_CC}) list(APPEND _plugin_deps ${BIF_BUILD_TARGET}) set(_plugin_objs "${_plugin_objs}" PARENT_SCOPE) set(_plugin_deps "${_plugin_deps}" PARENT_SCOPE) endforeach () endfunction() function(bro_plugin_link_library_static) foreach ( lib ${ARGV} ) set(bro_SUBDIR_LIBS ${bro_SUBDIR_LIBS} "${lib}" CACHE INTERNAL "plugin libraries") endforeach () endfunction() function(bro_plugin_end_static) if ( bro_HAVE_OBJECT_LIBRARIES ) add_library(${_plugin_lib} OBJECT ${_plugin_objs}) set(_target "$") else () add_library(${_plugin_lib} STATIC ${_plugin_objs}) set(_target "${_plugin_lib}") endif () if ( NOT "${_plugin_deps}" STREQUAL "" ) add_dependencies(${_plugin_lib} ${_plugin_deps}) endif () add_dependencies(${_plugin_lib} generate_outputs) set(bro_PLUGIN_LIBS ${bro_PLUGIN_LIBS} "${_target}" CACHE INTERNAL "plugin libraries") endfunction() macro(_plugin_target_name_static target ns name) set(${target} "plugin-${ns}-${name}") endmacro() broccoli-python-0.63/cmake/BroSubdir.cmake0000644000076500000240000000077113350246016020450 0ustar jonstaff00000000000000 # Creates a target for a library of objects file in a subdirectory, # and adds to the global bro_SUBDIR_LIBS. function(bro_add_subdir_library name) if ( bro_HAVE_OBJECT_LIBRARIES ) add_library("bro_${name}" OBJECT ${ARGN}) set(_target "$") else () add_library("bro_${name}" STATIC ${ARGN}) set(_target "bro_${name}") endif () set(bro_SUBDIR_LIBS "${_target}" ${bro_SUBDIR_LIBS} CACHE INTERNAL "subdir libraries") endfunction() broccoli-python-0.63/cmake/COPYING0000644000076500000240000000345713350246016016612 0ustar jonstaff00000000000000Copyright (c) 1995-2017, The Regents of the University of California through the Lawrence Berkeley National Laboratory and the International Computer Science Institute. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory, U.S. Dept. of Energy, International Computer Science Institute, nor the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Note that some files in the distribution may carry their own copyright notices. broccoli-python-0.63/cmake/ChangeMacInstallNames.cmake0000644000076500000240000000660213350246016022675 0ustar jonstaff00000000000000# Calling this macro with the name of a list variable will modify that # list such that any third party libraries that do not come with a # vanilla Mac OS X system will be replaced by an adjusted library that # has an install_name relative to the location of any executable that # links to it. # # Also, it will schedule the modified libraries for installation in a # 'support_libs' subdirectory of the CMAKE_INSTALL_PREFIX. # # The case of third party libraries depending on other third party # libraries is currently not handled by this macro. # # Ex. # # set(libs /usr/lib/libz.dylib # /usr/lib/libssl.dylib # /usr/local/lib/libmagic.dylib # /usr/local/lib/libGeoIP.dylib # /usr/local/lib/somestaticlib.a) # # include(ChangeMacInstallNames) # ChangeMacInstallNames(libs) # # Should result in ${libs} containing: # /usr/lib/libz.dylib # /usr/lib/libssl.dylib # ${CMAKE_BINARY_DIR}/darwin_support_libs/libmagic.dylib # ${CMAKE_BINARY_DIR}/darwin_support_libs/libGeoIP.dylib # /usr/local/lib/somestaticlib.a # # such that we can now do: # # add_executable(some_exe ${srcs}) # target_link_libraries(some_exe ${libs}) # # Any binary packages created from such a build should be self-contained # and provide working installs on vanilla OS X systems. macro(ChangeMacInstallNames libListVar) if (APPLE) find_program(INSTALL_NAME_TOOL install_name_tool) set(MAC_INSTALL_NAME_DEPS) set(SUPPORT_BIN_DIR ${CMAKE_BINARY_DIR}/darwin_support_libs) set(SUPPORT_INSTALL_DIR support_libs) file(MAKE_DIRECTORY ${SUPPORT_BIN_DIR}) foreach (_lib ${${libListVar}}) # only care about install_name for shared libraries that are # not shipped in Apple's vanilla OS X installs string(REGEX MATCH ^/usr/lib/* apple_provided_lib ${_lib}) string(REGEX MATCH dylib$ is_shared_lib ${_lib}) if (NOT apple_provided_lib AND is_shared_lib) get_filename_component(_libname ${_lib} NAME) set(_adjustedLib ${SUPPORT_BIN_DIR}/${_libname}) set(_tmpLib ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${_libname}) # make a tempory copy so we can adjust permissions configure_file(${_lib} ${_tmpLib} COPYONLY) # copy to build directory with correct write permissions file(COPY ${_tmpLib} DESTINATION ${SUPPORT_BIN_DIR} FILE_PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ) # remove the old library from the list provided as macro # argument and add the new library with modified install_name list(REMOVE_ITEM ${libListVar} ${_lib}) list(APPEND ${libListVar} ${_adjustedLib}) # update the install target to install the third party libs # with modified install_name install(FILES ${_adjustedLib} DESTINATION ${SUPPORT_INSTALL_DIR}) # perform the install_name change execute_process(COMMAND install_name_tool -id @executable_path/../${SUPPORT_INSTALL_DIR}/${_libname} ${_adjustedLib}) endif () endforeach () endif () endmacro() broccoli-python-0.63/cmake/CheckCompilers.cmake0000644000076500000240000000067013350246016021446 0ustar jonstaff00000000000000# Aborts the configuration if no C or C++ compiler is found, depending # on whether a previous call to the project() macro was supplied either # language as a requirement. if (NOT CMAKE_C_COMPILER AND DEFINED CMAKE_C_COMPILER) message(FATAL_ERROR "Could not find prerequisite C compiler") endif () if (NOT CMAKE_CXX_COMPILER AND DEFINED CMAKE_CXX_COMPILER) message(FATAL_ERROR "Could not find prerequisite C++ compiler") endif () broccoli-python-0.63/cmake/CheckFunctions.cmake0000644000076500000240000000067513350246016021466 0ustar jonstaff00000000000000include(CheckFunctionExists) check_function_exists(getopt_long HAVE_GETOPT_LONG) check_function_exists(mallinfo HAVE_MALLINFO) check_function_exists(strcasestr HAVE_STRCASESTR) check_function_exists(strerror HAVE_STRERROR) check_function_exists(strsep HAVE_STRSEP) check_function_exists(sigset HAVE_SIGSET) if (HAVE_SIGSET) set(SIG_FUNC sigset) else () set(SIG_FUNC signal) check_function_exists(sigaction HAVE_SIGACTION) endif () broccoli-python-0.63/cmake/CheckHeaders.cmake0000644000076500000240000000316313350246016021064 0ustar jonstaff00000000000000include(CheckIncludeFiles) include(CheckStructHasMember) include(CheckSymbolExists) check_include_files(getopt.h HAVE_GETOPT_H) check_include_files(memory.h HAVE_MEMORY_H) check_include_files("netinet/ether.h" HAVE_NETINET_ETHER_H) check_include_files("sys/socket.h;netinet/in.h;net/if.h;netinet/if_ether.h" HAVE_NETINET_IF_ETHER_H) check_include_files("sys/socket.h;netinet/in.h;net/if.h;netinet/ip6.h" HAVE_NETINET_IP6_H) check_include_files("sys/socket.h;net/if.h;net/ethernet.h" HAVE_NET_ETHERNET_H) check_include_files(sys/ethernet.h HAVE_SYS_ETHERNET_H) check_include_files(net/ethertypes.h HAVE_NET_ETHERTYPES_H) check_include_files(sys/time.h HAVE_SYS_TIME_H) check_include_files("time.h;sys/time.h" TIME_WITH_SYS_TIME) check_include_files(os-proto.h HAVE_OS_PROTO_H) check_struct_has_member(HISTORY_STATE entries "stdio.h;readline/readline.h" HAVE_READLINE_HISTORY_ENTRIES) check_include_files("stdio.h;readline/readline.h" HAVE_READLINE_READLINE_H) check_include_files("stdio.h;readline/history.h" HAVE_READLINE_HISTORY_H) if (HAVE_READLINE_READLINE_H AND HAVE_READLINE_HISTORY_H AND HAVE_READLINE_HISTORY_ENTRIES) set(HAVE_READLINE true) endif () check_struct_has_member("struct sockaddr_in" sin_len "netinet/in.h" SIN_LEN) macro(CheckIPProto _proto) check_symbol_exists(IPPROTO_${_proto} netinet/in.h HAVE_IPPROTO_${_proto}) endmacro(CheckIPProto _proto) CheckIPProto(HOPOPTS) CheckIPProto(IPV6) CheckIPProto(IPV4) CheckIPProto(ROUTING) CheckIPProto(FRAGMENT) CheckIPProto(ESP) CheckIPProto(AH) CheckIPProto(ICMPV6) CheckIPProto(NONE) CheckIPProto(DSTOPTS) broccoli-python-0.63/cmake/CheckNameserCompat.cmake0000644000076500000240000000136013350246016022244 0ustar jonstaff00000000000000include(CheckCSourceCompiles) # Check whether the namser compatibility header is required # This can be the case on the Darwin platform set(CMAKE_REQUIRED_INCLUDES ${BIND_INCLUDE_DIR}) check_c_source_compiles(" #include int main() { HEADER *hdr; int d = NS_IN6ADDRSZ; return 0; }" have_nameser_header) if (NOT have_nameser_header) check_c_source_compiles(" #include #include int main() { HEADER *hdr; int d = NS_IN6ADDRSZ; return 0; }" NEED_NAMESER_COMPAT_H) if (NOT NEED_NAMESER_COMPAT_H) message(FATAL_ERROR "Asynchronous DNS support compatibility check failed.") endif () endif () set(CMAKE_REQUIRED_INCLUDES) broccoli-python-0.63/cmake/CheckOptionalBuildSources.cmake0000644000076500000240000000165013350246016023621 0ustar jonstaff00000000000000# A macro that checks whether optional sources exist and if they do, they # are added to the build/install process, else a warning is issued # # _dir: the subdir of the current source dir in which the optional # sources are located # _packageName: a string that identifies the package # _varName: name of the variable indicating whether package is scheduled # to be installed macro(CheckOptionalBuildSources _dir _packageName _varName) if (${_varName}) if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${_dir}/CMakeLists.txt) add_subdirectory(${_dir}) else () message(WARNING "${_packageName} source code does not exist in " "${CMAKE_CURRENT_SOURCE_DIR}/${_dir} " "so it will not be built or installed") set(${_varName} false) endif () endif () endmacro(CheckOptionalBuildSources) broccoli-python-0.63/cmake/CheckTypes.cmake0000644000076500000240000000223013350246016020607 0ustar jonstaff00000000000000include(CheckTypeSize) check_type_size("long int" SIZEOF_LONG_INT) check_type_size("long long" SIZEOF_LONG_LONG) check_type_size("void *" SIZEOF_VOID_P) # checks existence of ${_type}, and if it does not, sets CMake variable ${_var} # to alternative type, ${_alt_type} macro(CheckType _type _alt_type _var) # don't perform check if we have a result from a previous CMake run if (NOT HAVE_${_var}) check_type_size(${_type} ${_var}) if (NOT ${_var}) set(${_var} ${_alt_type}) else () unset(${_var}) unset(${_var} CACHE) endif () endif () endmacro(CheckType _type _alt_type _var) set(CMAKE_EXTRA_INCLUDE_FILES sys/types.h) CheckType(int32_t int int32_t) CheckType(u_int32_t u_int u_int32_t) CheckType(u_int16_t u_short u_int16_t) CheckType(u_int8_t u_char u_int8_t) set(CMAKE_EXTRA_INCLUDE_FILES) set(CMAKE_EXTRA_INCLUDE_FILES sys/socket.h) CheckType(socklen_t int socklen_t) set(CMAKE_EXTRA_INCLUDE_FILES) set(CMAKE_EXTRA_INCLUDE_FILES netinet/in.h netinet/ip6.h) check_type_size("struct ip6_opt" IP6_OPT) check_type_size("struct ip6_ext" IP6_EXT) set(CMAKE_EXTRA_INCLUDE_FILES) broccoli-python-0.63/cmake/CommonCMakeConfig.cmake0000644000076500000240000000043013350246016022024 0ustar jonstaff00000000000000set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH}) set(CMAKE_EXPORT_COMPILE_COMMANDS ON) include(CheckCompilers) include(ProhibitInSourceBuild) include(AddUninstallTarget) include(SetupRPATH) include(SetDefaultCompileFlags) include(MacDependencyPaths) broccoli-python-0.63/cmake/ConfigurePackaging.cmake0000644000076500000240000002501413350246016022300 0ustar jonstaff00000000000000# A collection of macros to assist in configuring CMake/Cpack # source and binary packaging # Sets CPack version variables by splitting the first macro argument # using "." or "-" as a delimiter. If the length of the split list is # greater than 2, all remaining elements are tacked on to the patch # level version. Not that the version set by the macro is internal # to binary packaging, the file name of our package will reflect the # exact version number. macro(SetPackageVersion _version) string(REGEX REPLACE "[.-]" " " version_numbers ${_version}) separate_arguments(version_numbers) list(GET version_numbers 0 CPACK_PACKAGE_VERSION_MAJOR) list(REMOVE_AT version_numbers 0) list(GET version_numbers 0 CPACK_PACKAGE_VERSION_MINOR) list(REMOVE_AT version_numbers 0) list(LENGTH version_numbers version_length) while (version_length GREATER 0) list(GET version_numbers 0 patch_level) if (CPACK_PACKAGE_VERSION_PATCH) set(CPACK_PACKAGE_VERSION_PATCH "${CPACK_PACKAGE_VERSION_PATCH}.${patch_level}") else () set(CPACK_PACKAGE_VERSION_PATCH ${patch_level}) endif () list(REMOVE_AT version_numbers 0) list(LENGTH version_numbers version_length) endwhile () if (APPLE) # Mac PackageMaker package requires only numbers in the versioning string(REGEX REPLACE "[_a-zA-Z-]" "" CPACK_PACKAGE_VERSION_MAJOR ${CPACK_PACKAGE_VERSION_MAJOR}) string(REGEX REPLACE "[_a-zA-Z-]" "" CPACK_PACKAGE_VERSION_MINOR ${CPACK_PACKAGE_VERSION_MINOR}) if (CPACK_PACKAGE_VERSION_PATCH) string(REGEX REPLACE "[_a-zA-Z-]" "" CPACK_PACKAGE_VERSION_PATCH ${CPACK_PACKAGE_VERSION_PATCH}) endif () endif () if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") # RPM version accepts letters, but not dashes. string(REGEX REPLACE "[-]" "." CPACK_PACKAGE_VERSION_MAJOR ${CPACK_PACKAGE_VERSION_MAJOR}) string(REGEX REPLACE "[-]" "." CPACK_PACKAGE_VERSION_MINOR ${CPACK_PACKAGE_VERSION_MINOR}) if (CPACK_PACKAGE_VERSION_PATCH) string(REGEX REPLACE "[-]" "." CPACK_PACKAGE_VERSION_PATCH ${CPACK_PACKAGE_VERSION_PATCH}) endif () endif () # Minimum supported OS X version set(CPACK_OSX_PACKAGE_VERSION 10.5) endmacro(SetPackageVersion) # Sets the list of desired package types to be created by the make # package target. A .tar.gz is only made for source packages, and # binary pacakage format depends on the operating system: # # Darwin - PackageMaker # Linux - RPM if the platform has rpmbuild installed # DEB if the platform has dpkg-shlibdeps installed # # CPACK_GENERATOR is set by this macro # CPACK_SOURCE_GENERATOR is set by this macro macro(SetPackageGenerators) set(CPACK_SOURCE_GENERATOR TGZ) #set(CPACK_GENERATOR TGZ) if (APPLE) list(APPEND CPACK_GENERATOR PackageMaker) elseif (${CMAKE_SYSTEM_NAME} MATCHES "Linux") find_program(RPMBUILD_EXE rpmbuild) find_program(DPKGSHLIB_EXE dpkg-shlibdeps) if (RPMBUILD_EXE) set(CPACK_GENERATOR ${CPACK_GENERATOR} RPM) endif () if (DPKGSHLIB_EXE) set(CPACK_GENERATOR ${CPACK_GENERATOR} DEB) set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS true) endif () endif () endmacro(SetPackageGenerators) # Sets CPACK_PACKAGE_FILE_NAME in the following format: # # --- # # and CPACK_SOURCE_PACKAGE_FILE_NAME as: # # - macro(SetPackageFileName _version) if (PACKAGE_NAME_PREFIX) set(CPACK_PACKAGE_FILE_NAME "${PACKAGE_NAME_PREFIX}-${_version}") set(CPACK_SOURCE_PACKAGE_FILE_NAME "${PACKAGE_NAME_PREFIX}-${_version}") else () set(CPACK_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${_version}") set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${_version}") endif () set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-${CMAKE_SYSTEM_NAME}") if (APPLE) # Only Intel-based Macs are supported. CMAKE_SYSTEM_PROCESSOR may # return the confusing 'i386' if running a 32-bit kernel, but chances # are the binary is x86_64 (or more generally 'Intel') compatible. set(arch "Intel") else () set (arch ${CMAKE_SYSTEM_PROCESSOR}) endif () set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-${arch}") endmacro(SetPackageFileName) # Sets up binary package metadata macro(SetPackageMetadata) if ( NOT CPACK_PACKAGE_VENDOR ) set(CPACK_PACKAGE_VENDOR "International Computer Science Institute") endif () if ( NOT CPACK_PACKAGE_CONTACT ) set(CPACK_PACKAGE_CONTACT "info@bro.org") endif () if ( NOT CPACK_PACKAGE_DESCRIPTION_SUMMARY ) set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "The Bro Network Intrusion Detection System") endif () # CPack may enforce file name extensions for certain package generators configure_file(${CMAKE_CURRENT_SOURCE_DIR}/README ${CMAKE_CURRENT_BINARY_DIR}/README.txt COPYONLY) if ( EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/COPYING ) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/COPYING ${CMAKE_CURRENT_BINARY_DIR}/COPYING.txt COPYONLY) elseif ( EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/COPYING.edit-me ) # Bro plugin skeletons have a placeholder file. Just use # it even if it hasn't actually been changed. configure_file(${CMAKE_CURRENT_SOURCE_DIR}/COPYING.edit-me ${CMAKE_CURRENT_BINARY_DIR}/COPYING.txt COPYONLY) endif () if ( EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/cmake/MAC_PACKAGE_INTRO ) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/MAC_PACKAGE_INTRO ${CMAKE_CURRENT_BINARY_DIR}/MAC_PACKAGE_INTRO.txt) else () configure_file(${CMAKE_CURRENT_SOURCE_DIR}/README ${CMAKE_CURRENT_BINARY_DIR}/MAC_PACKAGE_INTRO.txt) endif () set(CPACK_PACKAGE_DESCRIPTION_FILE ${CMAKE_CURRENT_BINARY_DIR}/README.txt) set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_CURRENT_BINARY_DIR}/COPYING.txt) set(CPACK_RESOURCE_FILE_README ${CMAKE_CURRENT_BINARY_DIR}/README.txt) set(CPACK_RESOURCE_FILE_WELCOME ${CMAKE_CURRENT_BINARY_DIR}/MAC_PACKAGE_INTRO.txt) if ( NOT CPACK_RPM_PACKAGE_LICENSE ) set(CPACK_RPM_PACKAGE_LICENSE "BSD") endif () if ( NOT CPACK_RPM_PACKAGE_GROUP ) set(CPACK_RPM_PACKAGE_GROUP "Applications/System") endif () set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /opt /var /var/opt) endmacro(SetPackageMetadata) # Sets pre and post install scripts for PackageMaker packages. # The main functionality that such scripts offer is a way to make backups # of "configuration" files that a user may have modified. # Note that RPMs already have a robust mechanism for dealing with # user-modified files, so we do not need this additional functionality macro(SetPackageInstallScripts VERSION) if (INSTALLED_CONFIG_FILES) # Remove duplicates from the list of installed config files separate_arguments(INSTALLED_CONFIG_FILES) list(REMOVE_DUPLICATES INSTALLED_CONFIG_FILES) # Space delimit the list again foreach (_file ${INSTALLED_CONFIG_FILES}) set(_tmp "${_tmp} ${_file}") endforeach () set(INSTALLED_CONFIG_FILES "${_tmp}" CACHE STRING "" FORCE) endif () if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") # DEB packages can automatically handle configuration files # if provided in a "conffiles" file in the packaging set(conffiles_file ${CMAKE_CURRENT_BINARY_DIR}/conffiles) if (INSTALLED_CONFIG_FILES) string(REPLACE " " ";" conffiles ${INSTALLED_CONFIG_FILES}) endif () file(WRITE ${conffiles_file} "") foreach (_file ${conffiles}) file(APPEND ${conffiles_file} "${_file}\n") endforeach () list(APPEND CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA ${CMAKE_CURRENT_BINARY_DIR}/conffiles) # RPMs don't need any explicit direction regarding config files. # Leaving the set of installed config files empty will just # bypass the logic in the default pre/post install scripts and let # the RPMs/DEBs do their own thing (regarding backups, etc.) # when upgrading packages. set(INSTALLED_CONFIG_FILES "") endif () if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/cmake/package_preinstall.sh.in) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/package_preinstall.sh.in ${CMAKE_CURRENT_BINARY_DIR}/package_preinstall.sh @ONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/package_preinstall.sh.in ${CMAKE_CURRENT_BINARY_DIR}/preinst @ONLY) set(CPACK_PREFLIGHT_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/package_preinstall.sh) set(CPACK_RPM_PRE_INSTALL_SCRIPT_FILE ${CMAKE_CURRENT_BINARY_DIR}/package_preinstall.sh) list(APPEND CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA ${CMAKE_CURRENT_BINARY_DIR}/preinst) endif () if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/cmake/package_postupgrade.sh.in) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/package_postupgrade.sh.in ${CMAKE_CURRENT_BINARY_DIR}/package_postupgrade.sh @ONLY) configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/package_postupgrade.sh.in ${CMAKE_CURRENT_BINARY_DIR}/postinst @ONLY) set(CPACK_POSTUPGRADE_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/package_postupgrade.sh) set(CPACK_RPM_POST_INSTALL_SCRIPT_FILE ${CMAKE_CURRENT_BINARY_DIR}/package_postupgrade.sh) list(APPEND CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA ${CMAKE_CURRENT_BINARY_DIR}/postinst) endif () endmacro(SetPackageInstallScripts) # Main macro to configure all the packaging options macro(ConfigurePackaging _version) SetPackageVersion(${_version}) SetPackageGenerators() SetPackageFileName(${_version}) SetPackageMetadata() SetPackageInstallScripts(${_version}) set(CPACK_SET_DESTDIR true) set(CPACK_PACKAGING_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}) # add default files/directories to ignore for source package # user may specify others via configure script list(APPEND CPACK_SOURCE_IGNORE_FILES ${CMAKE_BINARY_DIR} ".git") include(CPack) endmacro(ConfigurePackaging) broccoli-python-0.63/cmake/FindBIND.cmake0000644000076500000240000000553113350246016020071 0ustar jonstaff00000000000000# - Try to find BIND include dirs and libraries # # Usage of this module as follows: # # find_package(BIND) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # BIND_ROOT_DIR Set this variable to the root installation of BIND # if the module has problems finding the proper # installation path. # # Variables defined by this module: # # BIND_FOUND System has BIND, include and library dirs found # BIND_INCLUDE_DIR The BIND include directories. # BIND_LIBRARY The BIND library (if any) required for # ns_inittab and res_mkquery symbols find_path(BIND_ROOT_DIR NAMES include/bind/resolv.h include/resolv.h ) find_path(BIND_INCLUDE_DIR NAMES resolv.h HINTS ${BIND_ROOT_DIR}/include/bind ${BIND_ROOT_DIR}/include ) if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") # the static resolv library is preferred because # on some systems, the ns_initparse symbol is not # exported in the shared library (strangely) # see http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=291609 set(bind_libs none libresolv.a resolv bind) else () set(bind_libs none resolv bind) endif () include(CheckCSourceCompiles) # Find which library has the res_mkquery and ns_initparse symbols set(CMAKE_REQUIRED_INCLUDES ${BIND_INCLUDE_DIR}) foreach (bindlib ${bind_libs}) if (NOT ${bindlib} MATCHES "none") find_library(BIND_LIBRARY NAMES ${bindlib} HINTS ${BIND_ROOT_DIR}/lib ${BIND_ROOT_DIR}/lib/libbind ) endif () set(CMAKE_REQUIRED_LIBRARIES ${BIND_LIBRARY}) check_c_source_compiles(" #include int main() { ns_initparse(0, 0, 0); return 0; } " ns_initparse_works_${bindlib}) check_c_source_compiles(" #include #include #include #include #include int main() { int (*p)() = res_mkquery; return 0; } " res_mkquery_works_${bindlib}) set(CMAKE_REQUIRED_LIBRARIES) if (ns_initparse_works_${bindlib} AND res_mkquery_works_${bindlib}) break () else () set(BIND_LIBRARY BIND_LIBRARY-NOTFOUND) endif () endforeach () set(CMAKE_REQUIRED_INCLUDES) include(FindPackageHandleStandardArgs) if (ns_initparse_works_none AND res_mkquery_works_none) # system does not require linking to a BIND library find_package_handle_standard_args(BIND DEFAULT_MSG BIND_INCLUDE_DIR ) else () find_package_handle_standard_args(BIND DEFAULT_MSG BIND_LIBRARY BIND_INCLUDE_DIR ) endif () mark_as_advanced( BIND_ROOT_DIR BIND_LIBRARY BIND_INCLUDE_DIR ) broccoli-python-0.63/cmake/FindBISON.cmake0000644000076500000240000002221513350246016020225 0ustar jonstaff00000000000000# - Find bison executable and provides macros to generate custom build rules # The module defines the following variables: # # BISON_EXECUTABLE - path to the bison program # BISON_VERSION - version of bison # BISON_FOUND - true if the program was found # # If bison is found, the module defines the macros: # BISON_TARGET( [VERBOSE ] # [COMPILE_FLAGS ] [HEADER ]) # which will create a custom rule to generate a parser. is # the path to a yacc file. is the name of the source file # generated by bison. A header file containing the token list is also # generated according to bison's -d option by default or if the HEADER # option is used, the argument is passed to bison's --defines option to # specify output file. If COMPILE_FLAGS option is specified, the next # parameter is added in the bison command line. if VERBOSE option is # specified, is created and contains verbose descriptions of the # grammar and parser. The macro defines a set of variables: # BISON_${Name}_DEFINED - true is the macro ran successfully # BISON_${Name}_INPUT - The input source file, an alias for # BISON_${Name}_OUTPUT_SOURCE - The source file generated by bison # BISON_${Name}_OUTPUT_HEADER - The header file generated by bison # BISON_${Name}_OUTPUTS - The sources files generated by bison # BISON_${Name}_COMPILE_FLAGS - Options used in the bison command line # # ==================================================================== # Example: # # find_package(BISON) # BISON_TARGET(MyParser parser.y ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp) # add_executable(Foo main.cpp ${BISON_MyParser_OUTPUTS}) # ==================================================================== #============================================================================= # Copyright 2009 Kitware, Inc. # Copyright 2006 Tristan Carel # Modified 2010 by Jon Siwek, adding HEADER option # # Distributed under the OSI-approved BSD License (the "License"): # CMake - Cross Platform Makefile Generator # Copyright 2000-2009 Kitware, Inc., Insight Software Consortium # All rights reserved. # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions # are met: # # * Redistributions of source code must retain the above copyright # notice, this list of conditions and the following disclaimer. # # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # * Neither the names of Kitware, Inc., the Insight Software Consortium, # nor the names of their contributors may be used to endorse or promote # products derived from this software without specific prior written # permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= FIND_PROGRAM(BISON_EXECUTABLE bison DOC "path to the bison executable") MARK_AS_ADVANCED(BISON_EXECUTABLE) IF(BISON_EXECUTABLE) EXECUTE_PROCESS(COMMAND ${BISON_EXECUTABLE} --version OUTPUT_VARIABLE BISON_version_output ERROR_VARIABLE BISON_version_error RESULT_VARIABLE BISON_version_result OUTPUT_STRIP_TRAILING_WHITESPACE) IF(NOT ${BISON_version_result} EQUAL 0) MESSAGE(SEND_ERROR "Command \"${BISON_EXECUTABLE} --version\" failed with output:\n${BISON_version_error}") ELSE() STRING(REGEX REPLACE "^bison \\(GNU Bison\\) ([^\n]+)\n.*" "\\1" BISON_VERSION "${BISON_version_output}") ENDIF() # internal macro MACRO(BISON_TARGET_option_verbose Name BisonOutput filename) LIST(APPEND BISON_TARGET_cmdopt "--verbose") GET_FILENAME_COMPONENT(BISON_TARGET_output_path "${BisonOutput}" PATH) GET_FILENAME_COMPONENT(BISON_TARGET_output_name "${BisonOutput}" NAME_WE) ADD_CUSTOM_COMMAND(OUTPUT ${filename} COMMAND ${CMAKE_COMMAND} ARGS -E copy "${BISON_TARGET_output_path}/${BISON_TARGET_output_name}.output" "${filename}" DEPENDS "${BISON_TARGET_output_path}/${BISON_TARGET_output_name}.output" COMMENT "[BISON][${Name}] Copying bison verbose table to ${filename}" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}) SET(BISON_${Name}_VERBOSE_FILE ${filename}) LIST(APPEND BISON_TARGET_extraoutputs "${BISON_TARGET_output_path}/${BISON_TARGET_output_name}.output") ENDMACRO(BISON_TARGET_option_verbose) # internal macro MACRO(BISON_TARGET_option_extraopts Options) SET(BISON_TARGET_extraopts "${Options}") SEPARATE_ARGUMENTS(BISON_TARGET_extraopts) LIST(APPEND BISON_TARGET_cmdopt ${BISON_TARGET_extraopts}) ENDMACRO(BISON_TARGET_option_extraopts) #============================================================ # BISON_TARGET (public macro) #============================================================ # MACRO(BISON_TARGET Name BisonInput BisonOutput) SET(BISON_TARGET_output_header "") #SET(BISON_TARGET_command_opt "") SET(BISON_TARGET_cmdopt "") SET(BISON_TARGET_outputs "${BisonOutput}") IF(NOT ${ARGC} EQUAL 3 AND NOT ${ARGC} EQUAL 5 AND NOT ${ARGC} EQUAL 7 AND NOT ${ARGC} EQUAL 9) MESSAGE(SEND_ERROR "Usage") ELSE() # Parsing parameters IF(${ARGC} GREATER 5 OR ${ARGC} EQUAL 5) IF("${ARGV3}" STREQUAL "VERBOSE") BISON_TARGET_option_verbose(${Name} ${BisonOutput} "${ARGV4}") ENDIF() IF("${ARGV3}" STREQUAL "COMPILE_FLAGS") BISON_TARGET_option_extraopts("${ARGV4}") ENDIF() IF("${ARGV3}" STREQUAL "HEADER") set(BISON_TARGET_output_header "${ARGV4}") ENDIF() ENDIF() IF(${ARGC} GREATER 7 OR ${ARGC} EQUAL 7) IF("${ARGV5}" STREQUAL "VERBOSE") BISON_TARGET_option_verbose(${Name} ${BisonOutput} "${ARGV6}") ENDIF() IF("${ARGV5}" STREQUAL "COMPILE_FLAGS") BISON_TARGET_option_extraopts("${ARGV6}") ENDIF() IF("${ARGV5}" STREQUAL "HEADER") set(BISON_TARGET_output_header "${ARGV6}") ENDIF() ENDIF() IF(${ARGC} EQUAL 9) IF("${ARGV7}" STREQUAL "VERBOSE") BISON_TARGET_option_verbose(${Name} ${BisonOutput} "${ARGV8}") ENDIF() IF("${ARGV7}" STREQUAL "COMPILE_FLAGS") BISON_TARGET_option_extraopts("${ARGV8}") ENDIF() IF("${ARGV7}" STREQUAL "HEADER") set(BISON_TARGET_output_header "${ARGV8}") ENDIF() ENDIF() IF(BISON_TARGET_output_header) # Header's name passed in as argument to be used in --defines option LIST(APPEND BISON_TARGET_cmdopt "--defines=${BISON_TARGET_output_header}") set(BISON_${Name}_OUTPUT_HEADER ${BISON_TARGET_output_header}) ELSE() # Header's name generated by bison (see option -d) LIST(APPEND BISON_TARGET_cmdopt "-d") STRING(REGEX REPLACE "^(.*)(\\.[^.]*)$" "\\2" _fileext "${ARGV2}") STRING(REPLACE "c" "h" _fileext ${_fileext}) STRING(REGEX REPLACE "^(.*)(\\.[^.]*)$" "\\1${_fileext}" BISON_${Name}_OUTPUT_HEADER "${ARGV2}") ENDIF() LIST(APPEND BISON_TARGET_outputs "${BISON_${Name}_OUTPUT_HEADER}") ADD_CUSTOM_COMMAND(OUTPUT ${BISON_TARGET_outputs} ${BISON_TARGET_extraoutputs} COMMAND ${BISON_EXECUTABLE} ARGS ${BISON_TARGET_cmdopt} -o ${ARGV2} ${ARGV1} DEPENDS ${ARGV1} COMMENT "[BISON][${Name}] Building parser with bison ${BISON_VERSION}" WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) # define target variables SET(BISON_${Name}_DEFINED TRUE) SET(BISON_${Name}_INPUT ${ARGV1}) SET(BISON_${Name}_OUTPUTS ${BISON_TARGET_outputs}) SET(BISON_${Name}_COMPILE_FLAGS ${BISON_TARGET_cmdopt}) SET(BISON_${Name}_OUTPUT_SOURCE "${BisonOutput}") ENDIF(NOT ${ARGC} EQUAL 3 AND NOT ${ARGC} EQUAL 5 AND NOT ${ARGC} EQUAL 7 AND NOT ${ARGC} EQUAL 9) ENDMACRO(BISON_TARGET) # #============================================================ ENDIF(BISON_EXECUTABLE) INCLUDE(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(BISON DEFAULT_MSG BISON_EXECUTABLE) # FindBISON.cmake ends here broccoli-python-0.63/cmake/FindBinPAC.cmake0000644000076500000240000000253213350246016020407 0ustar jonstaff00000000000000# - Try to find BinPAC binary and library # # Usage of this module as follows: # # find_package(BinPAC) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # BinPAC_ROOT_DIR Set this variable to the root installation of # BinPAC if the module has problems finding the # proper installation path. # # Variables defined by this module: # # BINPAC_FOUND System has BinPAC binary and library # BinPAC_EXE The binpac executable # BinPAC_LIBRARY The libbinpac.a library # BinPAC_INCLUDE_DIR The binpac headers # look for BinPAC in standard locations or user-provided root find_path(BinPAC_ROOT_DIR NAMES include/binpac.h include/binpac/binpac.h ) find_file(BinPAC_EXE NAMES binpac HINTS ${BinPAC_ROOT_DIR}/bin ) find_library(BinPAC_LIBRARY NAMES libbinpac.a HINTS ${BinPAC_ROOT_DIR}/lib ) find_path(BinPAC_INCLUDE_DIR NAMES binpac.h HINTS ${BinPAC_ROOT_DIR}/include ${BinPAC_ROOT_DIR}/include/binpac ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(BinPAC DEFAULT_MSG BinPAC_EXE BinPAC_LIBRARY BinPAC_INCLUDE_DIR ) mark_as_advanced( BinPAC_ROOT_DIR BinPAC_EXE BinPAC_LIBRARY BinPAC_INCLUDE_DIR ) broccoli-python-0.63/cmake/FindBro.cmake0000644000076500000240000000206013350246016020071 0ustar jonstaff00000000000000# - Try to find Bro installation # # Usage of this module as follows: # # find_package(Bro) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # BRO_ROOT_DIR Set this variable to the root installation of # Bro if the module has problems finding the # proper installation path. # # Variables defined by this module: # # BRO_FOUND Bro NIDS is installed # BRO_EXE path to the 'bro' binary if (BRO_EXE AND BRO_ROOT_DIR) # this implies that we're building from the Bro source tree set(BRO_FOUND true) return() endif () find_program(BRO_EXE bro HINTS ${BRO_ROOT_DIR}/bin /usr/local/bro/bin) if (BRO_EXE) get_filename_component(BRO_ROOT_DIR ${BRO_EXE} PATH) get_filename_component(BRO_ROOT_DIR ${BRO_ROOT_DIR} PATH) endif () include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Bro DEFAULT_MSG BRO_EXE) mark_as_advanced(BRO_ROOT_DIR) broccoli-python-0.63/cmake/FindBroccoli.cmake0000644000076500000240000000222513350246016021106 0ustar jonstaff00000000000000# - Try to find libbroccoli include dirs and libraries # # Usage of this module as follows: # # find_package(Broccoli) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # Broccoli_ROOT_DIR Set this variable to the root installation of # libbroccoli if the module has problems finding the # proper installation path. # # Variables defined by this module: # # BROCCOLI_FOUND System has libbroccoli, include and lib dirs found # Broccoli_INCLUDE_DIR The libbroccoli include directories. # Broccoli_LIBRARY The libbroccoli library. find_path(Broccoli_ROOT_DIR NAMES include/broccoli.h ) find_path(Broccoli_INCLUDE_DIR NAMES broccoli.h HINTS ${Broccoli_ROOT_DIR}/include ) find_library(Broccoli_LIBRARY NAMES broccoli HINTS ${Broccoli_ROOT_DIR}/lib ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Broccoli DEFAULT_MSG Broccoli_LIBRARY Broccoli_INCLUDE_DIR ) mark_as_advanced( Broccoli_ROOT_DIR Broccoli_INCLUDE_DIR Broccoli_LIBRARY ) broccoli-python-0.63/cmake/FindBroker.cmake0000644000076500000240000000210313350246016020571 0ustar jonstaff00000000000000# - Try to find Broker library and headers # # Usage of this module as follows: # # find_package(Broker) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # BROKER_ROOT_DIR Set this variable to the root installation of # Broker if the module has problems finding the # proper installation path. # # Variables defined by this module: # # BROKER_FOUND System has Broker library # BROKER_LIBRARY The broker library # BROKER_INCLUDE_DIR The broker headers find_path(BROKER_ROOT_DIR NAMES include/broker/broker.hh ) find_library(BROKER_LIBRARY NAMES broker HINTS ${BROKER_ROOT_DIR}/lib ) find_path(BROKER_INCLUDE_DIR NAMES broker/broker.hh HINTS ${BROKER_ROOT_DIR}/include ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Broker DEFAULT_MSG BROKER_LIBRARY BROKER_INCLUDE_DIR ) mark_as_advanced( BROKER_ROOT_DIR BROKER_LIBRARY BROKER_INCLUDE_DIR ) broccoli-python-0.63/cmake/FindCAF.cmake0000644000076500000240000000676613350246016017761 0ustar jonstaff00000000000000# Try to find CAF headers and library. # # Use this module as follows: # # find_package(CAF) # # Variables used by this module (they can change the default behaviour and need # to be set before calling find_package): # # CAF_ROOT_DIR Set this variable either to an installation prefix or to wa # CAF build directory where to look for the CAF libraries. # # Variables defined by this module: # # CAF_FOUND System has CAF headers and library # CAF_LIBRARIES List of library files for all components # CAF_INCLUDE_DIRS List of include paths for all components # CAF_LIBRARY_$C Library file for component $C # CAF_INCLUDE_DIR_$C Include path for component $C # iterate over user-defined components foreach (comp ${CAF_FIND_COMPONENTS}) # we use uppercase letters only for variable names string(TOUPPER "${comp}" UPPERCOMP) if ("${comp}" STREQUAL "core") set(HDRNAME "caf/all.hpp") elseif ("${comp}" STREQUAL "test") set(HDRNAME "caf/test/unit_test.hpp") else () set(HDRNAME "caf/${comp}/all.hpp") endif () if (CAF_ROOT_DIR) set(header_hints "${CAF_ROOT_DIR}/include" "${CAF_ROOT_DIR}/../libcaf_${comp}") endif () find_path(CAF_INCLUDE_DIR_${UPPERCOMP} NAMES ${HDRNAME} HINTS ${header_hints} /usr/include /usr/local/include /opt/local/include /sw/include ${CMAKE_INSTALL_PREFIX}/include) mark_as_advanced(CAF_INCLUDE_DIR_${UPPERCOMP}) if (NOT "${CAF_INCLUDE_DIR_${UPPERCOMP}}" STREQUAL "CAF_INCLUDE_DIR_${UPPERCOMP}-NOTFOUND") # mark as found (set back to false in case library cannot be found) set(CAF_${comp}_FOUND true) # add to CAF_INCLUDE_DIRS only if path isn't already set set(duplicate false) foreach (p ${CAF_INCLUDE_DIRS}) if (${p} STREQUAL ${CAF_INCLUDE_DIR_${UPPERCOMP}}) set(duplicate true) endif () endforeach () if (NOT duplicate) set(CAF_INCLUDE_DIRS ${CAF_INCLUDE_DIRS} ${CAF_INCLUDE_DIR_${UPPERCOMP}}) endif() # look for (.dll|.so|.dylib) file, again giving hints for non-installed CAFs # skip probe_event as it is header only if (NOT ${comp} STREQUAL "probe_event" AND NOT ${comp} STREQUAL "test") if (CAF_ROOT_DIR) set(library_hints "${CAF_ROOT_DIR}/lib") endif () find_library(CAF_LIBRARY_${UPPERCOMP} NAMES "caf_${comp}" "caf_${comp}_static" HINTS ${library_hints} /usr/lib /usr/local/lib /opt/local/lib /sw/lib ${CMAKE_INSTALL_PREFIX}/lib) mark_as_advanced(CAF_LIBRARY_${UPPERCOMP}) if ("${CAF_LIBRARY_${UPPERCOMP}}" STREQUAL "CAF_LIBRARY-NOTFOUND") set(CAF_${comp}_FOUND false) else () set(CAF_LIBRARIES ${CAF_LIBRARIES} ${CAF_LIBRARY_${UPPERCOMP}}) endif () endif () endif () endforeach () # let CMake check whether all requested components have been found include(FindPackageHandleStandardArgs) find_package_handle_standard_args(CAF FOUND_VAR CAF_FOUND REQUIRED_VARS CAF_LIBRARIES CAF_INCLUDE_DIRS HANDLE_COMPONENTS) # final step to tell CMake we're done mark_as_advanced(CAF_ROOT_DIR CAF_LIBRARIES CAF_INCLUDE_DIRS) broccoli-python-0.63/cmake/FindCapstats.cmake0000644000076500000240000000062513350246016021136 0ustar jonstaff00000000000000# - Try to find capstats program # # Usage of this module as follows: # # find_package(Capstats) # # Variables defined by this module: # # CAPSTATS_FOUND capstats binary found # Capstats_EXE path to the capstats executable binary find_program(CAPSTATS_EXE capstats) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Capstats DEFAULT_MSG CAPSTATS_EXE) broccoli-python-0.63/cmake/FindGooglePerftools.cmake0000644000076500000240000000336413350246016022471 0ustar jonstaff00000000000000# - Try to find GooglePerftools headers and libraries # # Usage of this module as follows: # # find_package(GooglePerftools) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # GooglePerftools_ROOT_DIR Set this variable to the root installation of # GooglePerftools if the module has problems finding # the proper installation path. # # Variables defined by this module: # # GOOGLEPERFTOOLS_FOUND System has GooglePerftools libs/headers # TCMALLOC_FOUND System has GooglePerftools tcmalloc library # GooglePerftools_LIBRARIES The GooglePerftools libraries # GooglePerftools_LIBRARIES_DEBUG The GooglePerftools libraries for heap checking. # GooglePerftools_INCLUDE_DIR The location of GooglePerftools headers find_path(GooglePerftools_ROOT_DIR NAMES include/google/heap-profiler.h ) find_library(GooglePerftools_LIBRARIES_DEBUG NAMES tcmalloc_and_profiler HINTS ${GooglePerftools_ROOT_DIR}/lib ) find_library(GooglePerftools_LIBRARIES NAMES tcmalloc tcmalloc_minimal HINTS ${GooglePerftools_ROOT_DIR}/lib ) find_path(GooglePerftools_INCLUDE_DIR NAMES google/heap-profiler.h HINTS ${GooglePerftools_ROOT_DIR}/include ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(GooglePerftools DEFAULT_MSG GooglePerftools_LIBRARIES GooglePerftools_LIBRARIES_DEBUG GooglePerftools_INCLUDE_DIR ) find_package_handle_standard_args(tcmalloc DEFAULT_MSG GooglePerftools_LIBRARIES ) mark_as_advanced( GooglePerftools_ROOT_DIR GooglePerftools_LIBRARIES GooglePerftools_LIBRARIES_DEBUG GooglePerftools_INCLUDE_DIR ) broccoli-python-0.63/cmake/FindJeMalloc.cmake0000644000076500000240000000217413350246016021043 0ustar jonstaff00000000000000# - Try to find jemalloc headers and libraries. # # Usage of this module as follows: # # find_package(JeMalloc) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # JEMALLOC_ROOT_DIR Set this variable to the root installation of # jemalloc if the module has problems finding # the proper installation path. # # Variables defined by this module: # # JEMALLOC_FOUND System has jemalloc libs/headers # JEMALLOC_LIBRARIES The jemalloc library/libraries # JEMALLOC_INCLUDE_DIR The location of jemalloc headers find_path(JEMALLOC_ROOT_DIR NAMES include/jemalloc/jemalloc.h ) find_library(JEMALLOC_LIBRARIES NAMES jemalloc HINTS ${JEMALLOC_ROOT_DIR}/lib ) find_path(JEMALLOC_INCLUDE_DIR NAMES jemalloc/jemalloc.h HINTS ${JEMALLOC_ROOT_DIR}/include ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(JeMalloc DEFAULT_MSG JEMALLOC_LIBRARIES JEMALLOC_INCLUDE_DIR ) mark_as_advanced( JEMALLOC_ROOT_DIR JEMALLOC_LIBRARIES JEMALLOC_INCLUDE_DIR ) broccoli-python-0.63/cmake/FindLibKrb5.cmake0000644000076500000240000000213713350246016020606 0ustar jonstaff00000000000000# - Try to find Krb5 headers and libraries # # Usage of this module as follows: # # find_package(LibKrb5) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # LibKrb5_ROOT_DIR Set this variable to the root installation of # libKrb5 if the module has problems finding the # proper installation path. # # Variables defined by this module: # # LibKrb5_FOUND System has Krb5 libraries and headers # LibKrb5_LIBRARY The Krb5 library # LibKrb5_INCLUDE_DIR The location of Krb5 headers find_path(LibKrb5_ROOT_DIR NAMES include/krb5.h ) find_library(LibKrb5_LIBRARY NAMES krb5 HINTS ${LibKrb5_ROOT_DIR}/lib ) find_path(LibKrb5_INCLUDE_DIR NAMES krb5.h HINTS ${LibKrb5_ROOT_DIR}/include ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(LibKrb5 DEFAULT_MSG LibKrb5_LIBRARY LibKrb5_INCLUDE_DIR ) mark_as_advanced( LibKrb5_ROOT_DIR LibKrb5_LIBRARY LibKrb5_INCLUDE_DIR ) broccoli-python-0.63/cmake/FindLibMMDB.cmake0000644000076500000240000000266413350246016020527 0ustar jonstaff00000000000000# - Try to find libmaxminddb headers and libraries # # Usage of this module as follows: # # find_package(LibMMDB) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # LibMMDB_ROOT_DIR Set this variable to the root installation of # libmaxminddb if the module has problems finding the # proper installation path. # # Variables defined by this module: # # LibMMDB_FOUND System has libmaxminddb libraries and headers # LibMMDB_LIBRARY The libmaxminddb library # LibMMDB_INCLUDE_DIR The location of libmaxminddb headers find_path(LibMMDB_ROOT_DIR NAMES include/maxminddb.h ) if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") # the static version of the library is preferred on OS X for the # purposes of making packages (libmaxminddb doesn't ship w/ OS X) set(libmmdb_names libmaxminddb.a maxminddb) else () set(libmmdb_names maxminddb) endif () find_library(LibMMDB_LIBRARY NAMES ${libmmdb_names} HINTS ${LibMMDB_ROOT_DIR}/lib ) find_path(LibMMDB_INCLUDE_DIR NAMES maxminddb.h HINTS ${LibMMDB_ROOT_DIR}/include ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(LibMMDB DEFAULT_MSG LibMMDB_LIBRARY LibMMDB_INCLUDE_DIR ) mark_as_advanced( LibMMDB_ROOT_DIR LibMMDB_LIBRARY LibMMDB_INCLUDE_DIR ) broccoli-python-0.63/cmake/FindPCAP.cmake0000644000076500000240000000443613350246016020103 0ustar jonstaff00000000000000# - Try to find libpcap include dirs and libraries # # Usage of this module as follows: # # find_package(PCAP) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # PCAP_ROOT_DIR Set this variable to the root installation of # libpcap if the module has problems finding the # proper installation path. # # Variables defined by this module: # # PCAP_FOUND System has libpcap, include and library dirs found # PCAP_INCLUDE_DIR The libpcap include directories. # PCAP_LIBRARY The libpcap library (possibly includes a thread # library e.g. required by pf_ring's libpcap) # HAVE_PF_RING If a found version of libpcap supports PF_RING find_path(PCAP_ROOT_DIR NAMES include/pcap.h ) find_path(PCAP_INCLUDE_DIR NAMES pcap.h HINTS ${PCAP_ROOT_DIR}/include ) find_library(PCAP_LIBRARY NAMES pcap HINTS ${PCAP_ROOT_DIR}/lib ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(PCAP DEFAULT_MSG PCAP_LIBRARY PCAP_INCLUDE_DIR ) include(CheckCSourceCompiles) set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY}) check_c_source_compiles("int main() { return 0; }" PCAP_LINKS_SOLO) set(CMAKE_REQUIRED_LIBRARIES) # check if linking against libpcap also needs to link against a thread library if (NOT PCAP_LINKS_SOLO) find_package(Threads) if (THREADS_FOUND) set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY} ${CMAKE_THREAD_LIBS_INIT}) check_c_source_compiles("int main() { return 0; }" PCAP_NEEDS_THREADS) set(CMAKE_REQUIRED_LIBRARIES) endif () if (THREADS_FOUND AND PCAP_NEEDS_THREADS) set(_tmp ${PCAP_LIBRARY} ${CMAKE_THREAD_LIBS_INIT}) list(REMOVE_DUPLICATES _tmp) set(PCAP_LIBRARY ${_tmp} CACHE STRING "Libraries needed to link against libpcap" FORCE) else () message(FATAL_ERROR "Couldn't determine how to link against libpcap") endif () endif () include(CheckFunctionExists) set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY}) check_function_exists(pcap_get_pfring_id HAVE_PF_RING) set(CMAKE_REQUIRED_LIBRARIES) mark_as_advanced( PCAP_ROOT_DIR PCAP_INCLUDE_DIR PCAP_LIBRARY ) broccoli-python-0.63/cmake/FindPyBroccoli.cmake0000644000076500000240000000137513350246016021424 0ustar jonstaff00000000000000# - Determine if the Broccoli Python bindings are available # # Usage of this module as follows: # # find_package(PythonInterp REQUIRED) # find_package(PyBroccoli) # # Variables defined by this module: # # PYBROCCOLI_FOUND Python successfully imports broccoli bindings if (NOT PYBROCCOLI_FOUND) execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c "import broccoli" RESULT_VARIABLE PYBROCCOLI_IMPORT_RESULT) if (PYBROCCOLI_IMPORT_RESULT) # python returned non-zero exit status set(BROCCOLI_PYTHON_MODULE false) else () set(BROCCOLI_PYTHON_MODULE true) endif () endif () include(FindPackageHandleStandardArgs) find_package_handle_standard_args(PyBroccoli DEFAULT_MSG BROCCOLI_PYTHON_MODULE) broccoli-python-0.63/cmake/FindPythonDev.cmake0000644000076500000240000000605613350246016021300 0ustar jonstaff00000000000000# - Try to find Python include dirs and libraries # # Usage of this module as follows: # # find_package(PythonDev) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # PYTHON_EXECUTABLE If this is set to a path to a Python interpreter # then this module attempts to infer the path to # python-config from it # PYTHON_CONFIG Set this variable to the location of python-config # if the module has problems finding the proper # installation path. # # Variables defined by this module: # # PYTHONDEV_FOUND System has Python dev headers/libraries # PYTHON_INCLUDE_DIR The Python include directories. # PYTHON_LIBRARIES The Python libraries and linker flags. include(FindPackageHandleStandardArgs) if ( CMAKE_CROSSCOMPILING ) find_package(PythonLibs) if (PYTHON_INCLUDE_PATH AND NOT PYTHON_INCLUDE_DIR) set(PYTHON_INCLUDE_DIR "${PYTHON_INCLUDE_PATH}") endif () find_package_handle_standard_args(PythonDev DEFAULT_MSG PYTHON_INCLUDE_DIR PYTHON_LIBRARIES ) return() endif () if (PYTHON_EXECUTABLE) # Get the real path so that we can reliably find the correct python-config # (e.g. some systems may have a "python" symlink, but not a "python-config" # symlink). get_filename_component(PYTHON_EXECUTABLE "${PYTHON_EXECUTABLE}" REALPATH) endif () if (PYTHON_EXECUTABLE AND EXISTS ${PYTHON_EXECUTABLE}-config) set(PYTHON_CONFIG ${PYTHON_EXECUTABLE}-config CACHE PATH "" FORCE) else () find_program(PYTHON_CONFIG NAMES python-config python-config2.7 python-config2.6 python-config2.6 python-config2.4 python-config2.3) endif () # The OpenBSD python packages have python-config's that don't reliably # report linking flags that will work. if (PYTHON_CONFIG AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD") execute_process(COMMAND "${PYTHON_CONFIG}" --ldflags OUTPUT_VARIABLE PYTHON_LIBRARIES OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) string(STRIP "${PYTHON_LIBRARIES}" PYTHON_LIBRARIES) execute_process(COMMAND "${PYTHON_CONFIG}" --includes OUTPUT_VARIABLE PYTHON_INCLUDE_DIR OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET) string(REGEX REPLACE "^[-I]" "" PYTHON_INCLUDE_DIR "${PYTHON_INCLUDE_DIR}") string(REGEX REPLACE "[ ]-I" " " PYTHON_INCLUDE_DIR "${PYTHON_INCLUDE_DIR}") separate_arguments(PYTHON_INCLUDE_DIR) find_package_handle_standard_args(PythonDev DEFAULT_MSG PYTHON_CONFIG PYTHON_INCLUDE_DIR PYTHON_LIBRARIES ) else () find_package(PythonLibs) if (PYTHON_INCLUDE_PATH AND NOT PYTHON_INCLUDE_DIR) set(PYTHON_INCLUDE_DIR "${PYTHON_INCLUDE_PATH}") endif () find_package_handle_standard_args(PythonDev DEFAULT_MSG PYTHON_INCLUDE_DIR PYTHON_LIBRARIES ) endif () broccoli-python-0.63/cmake/FindReadline.cmake0000644000076500000240000000274413350246016021103 0ustar jonstaff00000000000000# - Try to find readline include dirs and libraries # # Usage of this module as follows: # # find_package(Readline) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # Readline_ROOT_DIR Set this variable to the root installation of # readline if the module has problems finding the # proper installation path. # # Variables defined by this module: # # READLINE_FOUND System has readline, include and lib dirs found # Readline_INCLUDE_DIR The readline include directories. # Readline_LIBRARY The readline library. find_path(Readline_ROOT_DIR NAMES include/readline/readline.h ) find_path(Readline_INCLUDE_DIR NAMES readline/readline.h HINTS ${Readline_ROOT_DIR}/include ) find_library(Readline_LIBRARY NAMES readline HINTS ${Readline_ROOT_DIR}/lib ) if(Readline_INCLUDE_DIR AND Readline_LIBRARY AND Ncurses_LIBRARY) set(READLINE_FOUND TRUE) else(Readline_INCLUDE_DIR AND Readline_LIBRARY AND Ncurses_LIBRARY) FIND_LIBRARY(Readline_LIBRARY NAMES readline) include(FindPackageHandleStandardArgs) FIND_PACKAGE_HANDLE_STANDARD_ARGS(Readline DEFAULT_MSG Readline_INCLUDE_DIR Readline_LIBRARY ) MARK_AS_ADVANCED(Readline_INCLUDE_DIR Readline_LIBRARY) endif(Readline_INCLUDE_DIR AND Readline_LIBRARY AND Ncurses_LIBRARY) mark_as_advanced( Readline_ROOT_DIR Readline_INCLUDE_DIR Readline_LIBRARY ) broccoli-python-0.63/cmake/FindRequiredPackage.cmake0000644000076500000240000000355713350246016022417 0ustar jonstaff00000000000000# A wrapper macro around the standard CMake find_package macro that # facilitates displaying better error messages by default, or even # accepting custom error messages on a per package basis. # # If a package is not found, then the MISSING_PREREQS variable gets # set to true and either a default or custom error message appended # to MISSING_PREREQ_DESCS. # # The caller can use these variables to display a list of any missing # packages and abort the build/configuration if there were any. # # Use as follows: # # include(FindRequiredPackage) # FindRequiredPackage(Perl) # FindRequiredPackage(FLEX "You need to install flex (Fast Lexical Analyzer)") # # if (MISSING_PREREQS) # foreach (prereq ${MISSING_PREREQ_DESCS}) # message(SEND_ERROR ${prereq}) # endforeach () # message(FATAL_ERROR "Configuration aborted due to missing prerequisites") # endif () macro(FindRequiredPackage packageName) string(TOUPPER ${packageName} upperPackageName) if ( (DEFINED ${upperPackageName}_ROOT_DIR) AND (DEFINED CMAKE_PREFIX_PATH) ) set(CMAKE_PREFIX_SAVE ${CMAKE_PREFIX_PATH}) unset(CMAKE_PREFIX_PATH) find_package(${packageName}) set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_SAVE}) else() find_package(${packageName}) endif () string(TOUPPER ${packageName} canonPackageName) if (NOT ${canonPackageName}_FOUND) set(MISSING_PREREQS true) set(customDesc) foreach (descArg ${ARGN}) set(customDesc "${customDesc} ${descArg}") endforeach () if (customDesc) # append the custom error message that was provided as an argument list(APPEND MISSING_PREREQ_DESCS ${customDesc}) else () list(APPEND MISSING_PREREQ_DESCS " Could not find prerequisite package '${packageName}'") endif () endif () endmacro(FindRequiredPackage) broccoli-python-0.63/cmake/FindRocksDB.cmake0000644000076500000240000000216213350246016020641 0ustar jonstaff00000000000000# Try to find RocksDB headers and library. # # Usage of this module as follows: # # find_package(RocksDB) # # Variables used by this module, they can change the default behaviour and need # to be set before calling find_package: # # ROCKSDB_ROOT_DIR Set this variable to the root installation of # RocksDB if the module has problems finding the # proper installation path. # # Variables defined by this module: # # ROCKSDB_FOUND System has RocksDB library/headers. # ROCKSDB_LIBRARIES The RocksDB library. # ROCKSDB_INCLUDE_DIRS The location of RocksDB headers. find_path(ROCKSDB_ROOT_DIR NAMES include/rocksdb/db.h ) find_library(ROCKSDB_LIBRARIES NAMES rocksdb HINTS ${ROCKSDB_ROOT_DIR}/lib ) find_path(ROCKSDB_INCLUDE_DIRS NAMES rocksdb/db.h HINTS ${ROCKSDB_ROOT_DIR}/include ) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(RocksDB DEFAULT_MSG ROCKSDB_LIBRARIES ROCKSDB_INCLUDE_DIRS ) mark_as_advanced( ROCKSDB_ROOT_DIR ROCKSDB_LIBRARIES ROCKSDB_INCLUDE_DIRS ) broccoli-python-0.63/cmake/FindSubnetTree.cmake0000644000076500000240000000144613350246016021436 0ustar jonstaff00000000000000# - Determine if the SubnetTree Python module is available # # Usage of this module as follows: # # find_package(PythonInterp REQUIRED) # find_package(SubnetTree) # # Variables defined by this module: # # SUBNETTREE_FOUND Python successfully imports SubnetTree module if (NOT SUBNETTREE_FOUND) execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c "import SubnetTree" RESULT_VARIABLE SUBNETTREE_IMPORT_RESULT) if (SUBNETTREE_IMPORT_RESULT) # python returned non-zero exit status set(SUBNETTREE_PYTHON_MODULE false) else () set(SUBNETTREE_PYTHON_MODULE true) endif () endif () include(FindPackageHandleStandardArgs) find_package_handle_standard_args(SubnetTree DEFAULT_MSG SUBNETTREE_PYTHON_MODULE) broccoli-python-0.63/cmake/FindTraceSummary.cmake0000644000076500000240000000070413350246016021766 0ustar jonstaff00000000000000# - Try to find the trace-summary Python program # # Usage of this module as follows: # # find_package(TraceSummary) # # Variables defined by this module: # # TRACESUMMARY_FOUND capstats binary found # TraceSummary_EXE path to the capstats executable binary find_program(TRACE_SUMMARY_EXE trace-summary) include(FindPackageHandleStandardArgs) find_package_handle_standard_args(TraceSummary DEFAULT_MSG TRACE_SUMMARY_EXE) broccoli-python-0.63/cmake/GetArchitecture.cmake0000644000076500000240000000052713350246016021636 0ustar jonstaff00000000000000 # Determine a tag for the host architecture (e.g., "linux-x86_64"). # We run uname ourselves here as CMAKE by default uses -p rather than # -m. execute_process(COMMAND uname -m OUTPUT_VARIABLE arch OUTPUT_STRIP_TRAILING_WHITESPACE) set(HOST_ARCHITECTURE "${CMAKE_SYSTEM_NAME}-${arch}") string(TOLOWER ${HOST_ARCHITECTURE} HOST_ARCHITECTURE) broccoli-python-0.63/cmake/InstallClobberImmune.cmake0000644000076500000240000000255613350246016022632 0ustar jonstaff00000000000000# Determines at `make install` time if a file, typically a configuration # file placed in $PREFIX/etc, shouldn't be installed to prevent overwrite # of an existing file. # # _srcfile: the file to install # _dstfile: the absolute file name after installation macro(InstallClobberImmune _srcfile _dstfile) install(CODE " set(_destfile \"${_dstfile}\") if (NOT \"\$ENV{DESTDIR}\" STREQUAL \"\") # prepend install root prefix with install-time DESTDIR set(_destfile \"\$ENV{DESTDIR}/${_dstfile}\") endif () if (EXISTS \${_destfile}) message(STATUS \"Skipping: \${_destfile} (already exists)\") execute_process(COMMAND \"${CMAKE_COMMAND}\" -E compare_files ${_srcfile} \${_destfile} RESULT_VARIABLE _diff) if (NOT \"\${_diff}\" STREQUAL \"0\") message(STATUS \"Installing: \${_destfile}.example\") configure_file(${_srcfile} \${_destfile}.example COPYONLY) endif () else () message(STATUS \"Installing: \${_destfile}\") # install() is not scriptable within install(), and # configure_file() is the next best thing configure_file(${_srcfile} \${_destfile} COPYONLY) # TODO: create additional install_manifest files? endif () ") endmacro(InstallClobberImmune) broccoli-python-0.63/cmake/InstallPackageConfigFile.cmake0000644000076500000240000000527313350246016023367 0ustar jonstaff00000000000000include(InstallClobberImmune) # This macro can be used to install configuration files which # users are expected to modify after installation. It will: # # - If binary packaging is enabled: # Install the file in the typical CMake fashion, but append to the # INSTALLED_CONFIG_FILES cache variable for use with the Mac package's # pre/post install scripts # # - If binary packaging is not enabled: # Install the script in a way such that it will check at `make install` # time whether the file does not exist. See InstallClobberImmune.cmake # # - Always create a target "install-example-configs" which installs an # example version of the config file. # # _srcfile: the absolute path to the file to install # _dstdir: absolute path to the directory in which to install the file # _dstfilename: how to (re)name the file inside _dstdir macro(InstallPackageConfigFile _srcfile _dstdir _dstfilename) set(_dstfile ${_dstdir}/${_dstfilename}) if (BINARY_PACKAGING_MODE) # If packaging mode is enabled, always install the distribution's # version of the file. The Mac package's pre/post install scripts # or native functionality of RPMs will take care of not clobbering it. install(FILES ${_srcfile} DESTINATION ${_dstdir} RENAME ${_dstfilename}) # This cache variable is what the Mac package pre/post install scripts # use to avoid clobbering user-modified config files set(INSTALLED_CONFIG_FILES "${INSTALLED_CONFIG_FILES} ${_dstfile}" CACHE STRING "" FORCE) # Additionally, the Mac PackageMaker packages don't have any automatic # handling of configuration file conflicts so install an example file # that the post install script will cleanup in the case it's extraneous if (APPLE) install(FILES ${_srcfile} DESTINATION ${_dstdir} RENAME ${_dstfilename}.example) endif () else () # Have `make install` check at run time whether the file does not exist InstallClobberImmune(${_srcfile} ${_dstfile}) endif () if (NOT TARGET install-example-configs) add_custom_target(install-example-configs COMMENT "Installed example configuration files") endif () # '/' is invalid in target names, so replace w/ '.' string(REGEX REPLACE "/" "." _flatsrc ${_srcfile}) set(_example ${_dstfile}.example) add_custom_target(install-example-config-${_flatsrc} COMMAND "${CMAKE_COMMAND}" -E copy ${_srcfile} \${DESTDIR}${_example} COMMENT "Installing ${_example}") add_dependencies(install-example-configs install-example-config-${_flatsrc}) endmacro(InstallPackageConfigFile) broccoli-python-0.63/cmake/InstallShellScript.cmake0000644000076500000240000000450413350246016022336 0ustar jonstaff00000000000000# Schedules a file to be installed by the 'install' target, but first # transformed by configure_file(... @ONLY) as well as by changing the # shell script's hashbang (#!) line to use the absolute path to the # interpreter in the path of the user running ./configure (or CMake equiv.). # # Hashbangs are not transformed when in binary packaging or cross-compiling # mode because that can result in inserting paths on the build system # that are not valid on the target system. # # _dstdir: absolute path to the directory in which to install the transformed # source file # _srcfile: path relevant to CMAKE_CURRENT_SOURCE_DIR pointing to the shell # script to install # [_dstfilename]: an optional argument for how to (re)name the file as # it's installed inside _dstdir macro(InstallShellScript _dstdir _srcfile) if (NOT "${ARGN}" STREQUAL "") set(_dstfilename ${ARGN}) else () get_filename_component(_dstfilename ${_srcfile} NAME) endif () set(orig_file ${CMAKE_CURRENT_SOURCE_DIR}/${_srcfile}) set(configed_file ${CMAKE_CURRENT_BINARY_DIR}/${_srcfile}) set(dehashbanged_file ${CMAKE_CURRENT_BINARY_DIR}/${_srcfile}.dehashbanged) configure_file(${orig_file} ${configed_file} @ONLY) file(READ ${configed_file} _srclines) file(WRITE ${dehashbanged_file} "") if (NOT BINARY_PACKAGING_MODE AND NOT CMAKE_CROSSCOMPILING) set(_regex "^#![ ]*/usr/bin/env[ ]+([^\n ]*)") string(REGEX MATCH ${_regex} _match ${_srclines}) if (_match) set(_shell ${CMAKE_MATCH_1}) if (${_shell} STREQUAL "python" AND PYTHON_EXECUTABLE) set(${_shell}_interp ${PYTHON_EXECUTABLE}) else () find_program(${_shell}_interp ${_shell}) endif () if (NOT ${_shell}_interp) message(FATAL_ERROR "Absolute path to interpreter '${_shell}' not found, " "failed to configure shell script: ${orig_file}") endif () string(REGEX REPLACE ${_regex} "#!${${_shell}_interp}" _srclines "${_srclines}") endif () endif () file(WRITE ${dehashbanged_file} "${_srclines}") install(PROGRAMS ${dehashbanged_file} DESTINATION ${_dstdir} RENAME ${_dstfilename}) endmacro(InstallShellScript) broccoli-python-0.63/cmake/InstallSymlink.cmake0000644000076500000240000000347513350246016021536 0ustar jonstaff00000000000000# This macro can be used to install symlinks, which turns out to be # non-trivial due to CMake version differences and limitations on how # files can be installed when building binary packages. # # The rule for binary packaging is that files (including symlinks) must # be installed with the standard CMake install() macro. # # The rule for non-binary packaging is that CMake 2.6 cannot install() # symlinks, but can create the symlink at install-time via scripting. # Though, we assume that CMake 2.6 isn't going to be used to generate # packages because versions later than 2.8.3 are superior for that purpose. # # _filepath: the absolute path to the file to symlink # _sympath: absolute path of the installed symlink macro(InstallSymlink _filepath _sympath) get_filename_component(_symname ${_sympath} NAME) get_filename_component(_installdir ${_sympath} PATH) if (BINARY_PACKAGING_MODE) execute_process(COMMAND "${CMAKE_COMMAND}" -E create_symlink ${_filepath} ${CMAKE_CURRENT_BINARY_DIR}/${_symname}) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${_symname} DESTINATION ${_installdir}) else () # scripting the symlink installation at install time should work # for CMake 2.6.x and 2.8.x install(CODE " if (\"\$ENV{DESTDIR}\" STREQUAL \"\") execute_process(COMMAND \"${CMAKE_COMMAND}\" -E create_symlink ${_filepath} ${_installdir}/${_symname}) else () execute_process(COMMAND \"${CMAKE_COMMAND}\" -E create_symlink ${_filepath} \$ENV{DESTDIR}/${_installdir}/${_symname}) endif () ") endif () endmacro(InstallSymlink) broccoli-python-0.63/cmake/MAC_PACKAGE_INTRO0000644000076500000240000000124713350246016020163 0ustar jonstaff00000000000000This package will install @CMAKE_PROJECT_NAME@ into the following location: @CMAKE_INSTALL_PREFIX@ You may choose to update your PATH environment variable: # For Bash export PATH=@CMAKE_INSTALL_PREFIX@/bin:$PATH # For CSH setenv PATH @CMAKE_INSTALL_PREFIX@/bin:$PATH If you have more than one volume, please choose the install destination as the one that contains the root filesystem. If you have existing configuration files that are modified or otherwise different from the version included in the package, this installer will attempt to prevent overwirting them, but its also advisable to make your own backups of important files before proceeding. broccoli-python-0.63/cmake/MacDependencyPaths.cmake0000644000076500000240000000260513350246016022252 0ustar jonstaff00000000000000# As of CMake 2.8.3, Fink and MacPorts search paths are appended to the # default search prefix paths, but the nicer thing would be if they are # prepended to the default, so that is fixed here. # Prepend the default search path locations, in case for some reason the # ports/brew/fink executables are not found. # If they are found, the actual paths will be pre-pended again below. list(INSERT CMAKE_PREFIX_PATH 0 /opt/local) list(INSERT CMAKE_PREFIX_PATH 0 /usr/local) list(INSERT CMAKE_PREFIX_PATH 0 /sw) if (APPLE AND "${PROJECT_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}") find_program(MAC_PORTS_BIN ports) find_program(MAC_HBREW_BIN brew) find_program(MAC_FINK_BIN fink) if (MAC_PORTS_BIN) list(INSERT CMAKE_PREFIX_PATH 0 ${MAC_PORTS_BIN}) # MacPorts endif () if (MAC_HBREW_BIN) execute_process(COMMAND ${MAC_HBREW_BIN} "--prefix" OUTPUT_VARIABLE BREW_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE) list(INSERT CMAKE_PREFIX_PATH 0 ${BREW_PREFIX}) # Homebrew, if linked list(INSERT CMAKE_PREFIX_PATH 0 ${BREW_PREFIX}/opt/openssl) # Homebrew OpenSSL list(INSERT CMAKE_PREFIX_PATH 0 ${BREW_PREFIX}/opt/bison/bin) # Homebrew Bison list(INSERT CMAKE_PREFIX_PATH 0 ${BREW_PREFIX}/opt/actor-framework) # Homebrew actor-framework endif () if (MAC_FINK_BIN) list(INSERT CMAKE_PREFIX_PATH 0 /sw) # Fink endif () endif () broccoli-python-0.63/cmake/MiscTests.cmake0000644000076500000240000000201013350246016020457 0ustar jonstaff00000000000000include(CheckCXXSourceCompiles) include(CheckCSourceCompiles) # This autoconf variable is obsolete; it's portable to assume C89 and signal # handlers returning void set(RETSIGTYPE "void") set(RETSIGVAL "") check_c_source_compiles(" #include #include extern int socket(int, int, int); extern int connect(int, const struct sockaddr *, int); extern int send(int, const void *, int, int); extern int recvfrom(int, void *, int, int, struct sockaddr *, int *); int main() { return 0; } " DO_SOCK_DECL) if (DO_SOCK_DECL) message(STATUS "socket() and friends need explicit declaration") endif () check_cxx_source_compiles(" #include #include extern \"C\" { int openlog(const char* ident, int logopt, int facility); int syslog(int priority, const char* message_fmt, ...); int closelog(); } int main() { return 0; } " SYSLOG_INT) if (SYSLOG_INT) message(STATUS "syslog prototypes need declaration") endif () broccoli-python-0.63/cmake/OSSpecific.cmake0000644000076500000240000000356513350246016020550 0ustar jonstaff00000000000000if (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD") set(bro_LINKER_FLAGS "${bro_LINKER_FLAGS} -rdynamic") elseif (${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD") set(bro_LINKER_FLAGS "${bro_LINKER_FLAGS} -rdynamic") elseif (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") set(HAVE_DARWIN true) elseif (${CMAKE_SYSTEM_NAME} MATCHES "Linux") set(HAVE_LINUX true) elseif (${CMAKE_SYSTEM_NAME} MATCHES "Solaris") set(SOCKET_LIBS nsl socket) elseif (${CMAKE_SYSTEM_NAME} MATCHES "osf") # Workaround ip_hl vs. ip_vhl problem in netinet/ip.h add_definitions(-D__STDC__=2) elseif (${CMAKE_SYSTEM_NAME} MATCHES "irix") list(APPEND CMAKE_C_FLAGS -xansi -signed -g3) list(APPEND CMAKE_CXX_FLAGS -xansi -signed -g3) elseif (${CMAKE_SYSTEM_NAME} MATCHES "ultrix") list(APPEND CMAKE_C_FLAGS -std1 -g3) list(APPEND CMAKE_CXX_FLAGS -std1 -g3) include(CheckCSourceCompiles) check_c_source_compiles(" #include int main() { void c(const struct a *); return 0; } " have_ultrix_const) if (NOT have_ultrix_const) set(NEED_ULTRIX_CONST_HACK true) endif () elseif (${CMAKE_SYSTEM_NAME} MATCHES "hpux" OR ${CMAKE_SYSTEM_NAME} MATCHES "HP-UX") include(CheckCSourceCompiles) set(CMAKE_REQUIRED_FLAGS -Aa) set(CMAKE_REQUIRED_DEFINITIONS -D_HPUX_SOURCE) check_c_source_compiles(" #include int main() { int frob(int, char *); return 0; } " have_ansi_prototypes) set(CMAKE_REQUIRED_FLAGS) set(CMAKE_REQUIRED_DEFINITIONS) if (have_ansi_prototypes) add_definitions(-D_HPUX_SOURCE) list(APPEND CMAKE_C_FLAGS -Aa) list(APPEND CMAKE_CXX_FLAGS -Aa) endif () if (NOT have_ansi_prototypes) message(FATAL_ERROR "Can't get HPUX compiler to handle ANSI prototypes") endif () endif () broccoli-python-0.63/cmake/OpenSSLTests.cmake0000644000076500000240000000510413350246016021056 0ustar jonstaff00000000000000include(CheckCSourceCompiles) include(CheckCXXSourceCompiles) include(CheckCSourceRuns) set(CMAKE_REQUIRED_LIBRARIES ${OPENSSL_LIBRARIES} ${CMAKE_DL_LIBS}) # Use all includes, not just OpenSSL includes to see if there are # include files of different versions that do not match GET_DIRECTORY_PROPERTY(includes INCLUDE_DIRECTORIES) set(CMAKE_REQUIRED_INCLUDES ${includes}) check_c_source_compiles(" #include int main() { return 0; } " including_ssl_h_works) if (NOT including_ssl_h_works) # On Red Hat we may need to include Kerberos header. set(CMAKE_REQUIRED_INCLUDES ${includes} /usr/kerberos/include) check_c_source_compiles(" #include #include int main() { return 0; } " NEED_KRB5_H) if (NOT NEED_KRB5_H) message(FATAL_ERROR "OpenSSL test failure. See CmakeError.log for details.") else () message(STATUS "OpenSSL requires Kerberos header") include_directories("/usr/kerberos/include") endif () endif () if (OPENSSL_VERSION VERSION_LESS "0.9.7") message(FATAL_ERROR "OpenSSL >= v0.9.7 required") endif () check_cxx_source_compiles(" #include int main() { const unsigned char** cpp = 0; X509** x =0; d2i_X509(x, cpp, 0); return 0; } " OPENSSL_D2I_X509_USES_CONST_CHAR) if (NOT OPENSSL_D2I_X509_USES_CONST_CHAR) # double check that it compiles without const check_cxx_source_compiles(" #include int main() { unsigned char** cpp = 0; X509** x =0; d2i_X509(x, cpp, 0); return 0; } " OPENSSL_D2I_X509_USES_CHAR) if (NOT OPENSSL_D2I_X509_USES_CHAR) message(FATAL_ERROR "Can't determine if openssl_d2i_x509() takes const char parameter") endif () endif () if (NOT CMAKE_CROSSCOMPILING) check_c_source_runs(" #include #include #include int main() { printf(\"-- OpenSSL Library version: %s\\\\n\", SSLeay_version(SSLEAY_VERSION)); printf(\"-- OpenSSL Header version: %s\\\\n\", OPENSSL_VERSION_TEXT); if (SSLeay() == OPENSSL_VERSION_NUMBER) { return 0; } return -1; } " OPENSSL_CORRECT_VERSION_NUMBER ) if (NOT OPENSSL_CORRECT_VERSION_NUMBER) message(FATAL_ERROR "OpenSSL library version does not match headers") endif () endif () set(CMAKE_REQUIRED_INCLUDES) set(CMAKE_REQUIRED_LIBRARIES) broccoli-python-0.63/cmake/PCAPTests.cmake0000644000076500000240000000403013350246016020313 0ustar jonstaff00000000000000include(CheckFunctionExists) include(CheckSymbolExists) include(CheckCSourceCompiles) include(CheckIncludeFiles) set(CMAKE_REQUIRED_INCLUDES ${PCAP_INCLUDE_DIR}) set(CMAKE_REQUIRED_LIBRARIES ${PCAP_LIBRARY}) cmake_policy(PUSH) if ( POLICY CMP0075 ) # It's fine that check_include_files links against CMAKE_REQUIRED_LIBRARIES cmake_policy(SET CMP0075 NEW) endif () check_include_files(pcap-int.h HAVE_PCAP_INT_H) cmake_policy(POP) check_function_exists(pcap_freecode HAVE_LIBPCAP_PCAP_FREECODE) if (NOT HAVE_LIBPCAP_PCAP_FREECODE) set(DONT_HAVE_LIBPCAP_PCAP_FREECODE true) message(STATUS "No implementation for pcap_freecode()") endif () check_c_source_compiles(" #include int main () { int snaplen; int linktype; struct bpf_program fp; int optimize; bpf_u_int32 netmask; char str[10]; char error[1024]; snaplen = 50; linktype = DLT_EN10MB; optimize = 1; netmask = 0L; str[0] = 'i'; str[1] = 'p'; str[2] = '\\\\0'; (void)pcap_compile_nopcap( snaplen, linktype, &fp, str, optimize, netmask, &error); return 0; } " LIBPCAP_PCAP_COMPILE_NOPCAP_HAS_ERROR_PARAMETER) if (NOT LIBPCAP_PCAP_COMPILE_NOPCAP_HAS_ERROR_PARAMETER) # double check check_c_source_compiles(" #include int main () { int snaplen; int linktype; struct bpf_program fp; int optimize; bpf_u_int32 netmask; char str[10]; snaplen = 50; linktype = DLT_EN10MB; optimize = 1; netmask = 0L; str[0] = 'i'; str[1] = 'p'; str[2] = '\\\\0'; (void)pcap_compile_nopcap(snaplen, linktype, &fp, str, optimize, netmask); return 0; } " LIBPCAP_PCAP_COMPILE_NOPCAP_NO_ERROR_PARAMETER) if (NOT LIBPCAP_PCAP_COMPILE_NOPCAP_NO_ERROR_PARAMETER) message(FATAL_ERROR "Can't determine if pcap_compile_nopcap takes an error parameter") endif () endif () check_symbol_exists(DLT_PPP_SERIAL pcap.h HAVE_DLT_PPP_SERIAL) if (NOT HAVE_DLT_PPP_SERIAL) set(DLT_PPP_SERIAL 50) endif () set(CMAKE_REQUIRED_INCLUDES) set(CMAKE_REQUIRED_LIBRARIES) broccoli-python-0.63/cmake/ProhibitInSourceBuild.cmake0000644000076500000240000000045613350246016022765 0ustar jonstaff00000000000000# Prohibit in-source builds. if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}") message(FATAL_ERROR "In-source builds are not allowed. Please use " "./configure to choose a build directory and " "initialize the build configuration.") endif () broccoli-python-0.63/cmake/README0000644000076500000240000000020513350246016016423 0ustar jonstaff00000000000000This is a collection of CMake scripts intended to be included as a git submodule in other repositories related to Bro (www.bro.org). broccoli-python-0.63/cmake/RequireCXX11.cmake0000644000076500000240000000525013350246016020713 0ustar jonstaff00000000000000# Detect if compiler version is sufficient for supporting C++11. # If it is, CMAKE_CXX_FLAGS are modified appropriately and HAVE_CXX11 # is set to a true value. Else, CMake exits with a fatal error message. # This currently only works for GCC and Clang compilers. # In Cmake 3.1+, CMAKE_CXX_STANDARD_REQUIRED should be able to replace # all the logic below. if ( DEFINED HAVE_CXX11 ) return() endif () include(CheckCXXSourceCompiles) set(required_gcc_version 4.8) set(required_clang_version 3.3) macro(cxx11_compile_test) # test a header file that has to be present in C++11 check_cxx_source_compiles(" #include #include int main() { std::array a{ {1, 2} }; for (const auto& e: a) std::cout << e << ' '; std::cout << std::endl; } " cxx11_header_works) if (NOT cxx11_header_works) message(FATAL_ERROR "C++11 headers cannot be used for compilation") endif () endmacro() # CMAKE_CXX_COMPILER_VERSION may not always be available (e.g. particularly # for CMakes older than 2.8.10, but use it if it exists. if ( DEFINED CMAKE_CXX_COMPILER_VERSION ) if ( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" ) if ( CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${required_gcc_version} ) message(FATAL_ERROR "GCC version must be at least " "${required_gcc_version} for C++11 support, detected: " "${CMAKE_CXX_COMPILER_VERSION}") endif () elseif ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" ) if ( CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${required_clang_version} ) message(FATAL_ERROR "Clang version must be at least " "${required_clang_version} for C++11 support, detected: " "${CMAKE_CXX_COMPILER_VERSION}") endif () endif () set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") cxx11_compile_test() set(HAVE_CXX11 true) return() endif () # Need to manually retrieve compiler version. if ( CMAKE_CXX_COMPILER_ID STREQUAL "GNU" ) execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE gcc_version) if ( ${gcc_version} VERSION_LESS ${required_gcc_version} ) message(FATAL_ERROR "GCC version must be at least " "${required_gcc_version} for C++11 support, manually detected: " "${CMAKE_CXX_COMPILER_VERSION}") endif () elseif ( CMAKE_CXX_COMPILER_ID STREQUAL "Clang" ) # TODO: don't seem to be any great/easy ways to get a clang version string. endif () set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") cxx11_compile_test() set(HAVE_CXX11 true) broccoli-python-0.63/cmake/SetDefaultCompileFlags.cmake0000644000076500000240000000222313350246016023075 0ustar jonstaff00000000000000# Set up the default flags and CMake build type once during the configuration # of the top-level CMake project. if ("${PROJECT_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}") set(EXTRA_COMPILE_FLAGS "-Wall -Wno-unused") if ( NOT CMAKE_BUILD_TYPE ) if ( ENABLE_DEBUG ) set(CMAKE_BUILD_TYPE Debug) else () set(CMAKE_BUILD_TYPE RelWithDebInfo) endif () endif () string(TOUPPER ${CMAKE_BUILD_TYPE} _build_type_upper) if ( "${_build_type_upper}" STREQUAL "DEBUG" ) if ( ENABLE_COVERAGE ) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage") endif() # manual add of -g works around its omission in FreeBSD's CMake port set(EXTRA_COMPILE_FLAGS "${EXTRA_COMPILE_FLAGS} -g -DDEBUG -DBRO_DEBUG") endif () # Compiler flags may already exist in CMake cache (e.g. when specifying # CFLAGS environment variable before running cmake for the the first time) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_COMPILE_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_COMPILE_FLAGS}") endif () broccoli-python-0.63/cmake/SetupRPATH.cmake0000644000076500000240000000053013350246016020445 0ustar jonstaff00000000000000# Keep RPATH upon installing so that user doesn't have to ensure the linker # can find internal/private libraries or libraries external to the build # directory that were explicitly linked against if (NOT BINARY_PACKAGING_MODE) SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") endif () broccoli-python-0.63/cmake/UserChangedWarning.cmake0000644000076500000240000000137013350246016022267 0ustar jonstaff00000000000000# Show warning when installing user is different from the one that configured, # except when the install is root. if ("${PROJECT_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}") install(CODE " if (NOT \"$ENV{USER}\" STREQUAL \"\$ENV{USER}\" AND NOT \"\$ENV{USER}\" STREQUAL root) message(STATUS \"WARNING: Install is being performed by user \" \"'\$ENV{USER}', but the build directory was configured by \" \"user '$ENV{USER}'. This may result in a permissions error \" \"when writing the install manifest, but you can ignore it \" \"and consider the installation as successful if you don't \" \"care about the install manifest.\") endif () ") endif () broccoli-python-0.63/cmake/bro-plugin-create-package.sh0000755000076500000240000000200713350246016023014 0ustar jonstaff00000000000000#! /bin/sh # # Helper script creating a tarball with a plugin's binary distribution. We'll # also leave a MANIFEST in place with all files part of the tar ball. # # Called from BroPluginDynamic.cmake. Current directory is the plugin # build directory. if [ $# = 0 ]; then echo "usage: `basename $0` []" exit 1 fi name=$1 shift addl=$@ # Copy additional distribution files into build directory. for i in ${addl}; do if [ -e ../$i ]; then dir=`dirname $i` mkdir -p ${dir} cp -p ../$i ${dir} fi done tgz=${name}-`(test -e ../VERSION && cat ../VERSION | head -1) || echo 0.0`.tar.gz rm -f MANIFEST ${name} ${name}.tgz ${tgz} for i in __bro_plugin__ lib scripts ${addl}; do test -e $i && find -L $i -type f | sed "s%^%${name}/%g" >>MANIFEST done ln -s . ${name} mkdir -p dist flag="-T" test `uname` = "OpenBSD" && flag="-I" tar czf dist/${tgz} ${flag} MANIFEST ln -s dist/${tgz} ${name}.tgz rm -f ${name} broccoli-python-0.63/cmake/bro-plugin-install-package.sh0000755000076500000240000000077013350246016023224 0ustar jonstaff00000000000000#! /bin/sh # # Helper script to install the tarball with a plugin's binary distribution. # # Called from BroPluginDynamic.cmake. Current directory is the plugin # build directory. if [ $# != 2 ]; then echo "usage: `basename $0` " exit 1 fi dst=$2 if [ ! -d "${dst}" ]; then echo "Warning: ${dst} does not exist; has Bro been installed?" mkdir -p ${dst} fi name=$1 tgz=`pwd`/$name.tgz ( cd ${dst} && rm -rf "${name}" && tar xzf ${tgz} ) broccoli-python-0.63/cmake/cmake_uninstall.cmake.in0000644000076500000240000000221113350246016022322 0ustar jonstaff00000000000000function(uninstall_manifest manifestPath) file(READ "${manifestPath}" files) string(REGEX REPLACE "\n" ";" files "${files}") foreach (file ${files}) set(fileName $ENV{DESTDIR}${file}) if (EXISTS "${fileName}" OR IS_SYMLINK "${fileName}") message(STATUS "Uninstalling: ${fileName}") execute_process( COMMAND "@CMAKE_COMMAND@" -E remove "${fileName}" OUTPUT_VARIABLE rm_out RESULT_VARIABLE rm_retval ) if (NOT ${rm_retval} EQUAL 0) message(FATAL_ERROR "Problem when removing: ${fileName}") endif () else () message(STATUS "Does not exist: ${fileName}") endif () endforeach () endfunction(uninstall_manifest) file(GLOB install_manifests @CMAKE_CURRENT_BINARY_DIR@/install_manifest*.txt) if (install_manifests) foreach (manifest ${install_manifests}) uninstall_manifest(${manifest}) endforeach () else () message(FATAL_ERROR "Cannot find any install manifests in: " "\"@CMAKE_CURRENT_BINARY_DIR@/install_manifest*.txt\"") endif () broccoli-python-0.63/cmake/package_postupgrade.sh.in0000755000076500000240000000435713350246016022533 0ustar jonstaff00000000000000#!/bin/sh # This script is meant to be used by binary packages post-installation. # Variables between @ symbols are replaced by CMake at configure time. backupNamesFile=/tmp/bro_install_backups version=@VERSION@ sampleFiles="" # check whether it's safe to remove backup configuration files that # the most recent package install created if [ -e ${backupNamesFile} ]; then backupFileList=`cat ${backupNamesFile}` for backupFile in ${backupFileList}; do origFileName=`echo ${backupFile} | sed 's/\(.*\)\..*/\1/'` diff ${origFileName} ${backupFile} > /dev/null 2>&1 if [ $? -eq 0 ]; then # if the installed version and the backup version don't differ # then we can remove the backup version and the example file rm ${backupFile} rm ${origFileName}.example else # The backup file differs from the newly installed version, # since we can't tell if the backup version has been modified # by the user, we should restore it to its original location # and rename the new version appropriately. sampleFiles="${sampleFiles}\n${origFileName}.example" mv ${backupFile} ${origFileName} fi done rm ${backupNamesFile} fi if [ -n "${sampleFiles}" ]; then # Use some apple script to display a message to user /usr/bin/osascript << EOF tell application "System Events" activate display alert "Existing configuration files differ from the ones that would be installed by this package. To avoid overwriting configuration which you may have modified, the following new config files have been installed:\n${sampleFiles}\n\nIf you have previously modified configuration files, please make sure that they are still compatible, else you should update your config files to the new versions." end tell EOF fi # Set up world writeable spool and logs directory for broctl, making sure # to set the sticky bit so that unprivileged users can't rename/remove files. # (CMake/CPack is supposed to install them, but has problems with empty dirs) if [ -n "@EMPTY_WORLD_DIRS@" ]; then for dir in "@EMPTY_WORLD_DIRS@"; do mkdir -p ${dir} chmod 777 ${dir} chmod +t ${dir} done fi broccoli-python-0.63/cmake/package_preinstall.sh.in0000755000076500000240000000167213350246016022350 0ustar jonstaff00000000000000#!/bin/sh # This script is meant to be used by binary packages pre-installation. # Variables between @ symbols are replaced by CMake at configure time. configFiles="@INSTALLED_CONFIG_FILES@" backupNamesFile=/tmp/bro_install_backups # Checks if a config file exists in a default location and makes a backup # so that a modified version is not clobbered backupFile () { origFile="$1" if [ -e ${origFile} ]; then # choose a file suffix that doesn't already exist ver=1 while [ -e ${origFile}.${ver} ]; do ver=$(( ver + 1 )) done backupFile=${origFile}.${ver} cp -p ${origFile} ${backupFile} # the post upgrade script will check whether the installed # config file actually differs from existing version # and delete unnecessary backups echo "${backupFile}" >> ${backupNamesFile} fi } for file in ${configFiles}; do backupFile "${file}" done broccoli-python-0.63/configure0000755000076500000240000001017313350246015016376 0ustar jonstaff00000000000000#!/bin/sh # Convenience wrapper for easily viewing/setting options that # the project's CMake scripts will recognize set -e command="$0 $*" # check for `cmake` command type cmake > /dev/null 2>&1 || { echo "\ This package requires CMake, please install it first, then you may use this configure script to access CMake equivalent functionality.\ " >&2; exit 1; } # check for `python` command type python > /dev/null 2>&1 || { echo "This package requires Python, please install it first." >&2; } site_packages=`python -c "from distutils.sysconfig import get_python_lib;\ print(get_python_lib(True))"` pyver=`python -c "import sys; print(\"%s.%s\" % (sys.version_info[0], sys.version_info[1]))"` usage="\ Usage: $0 [OPTION]... [VAR=VALUE]... Build Directory: --builddir=DIR place build files in directory [build] Installation Directories: --prefix=PREFIX installs to [PREFIX/lib/python${pyver}/site-packages] --home=PATH installs to [PATH/lib/python] Optional Features: --enable-debug compile in debugging mode Required Packages in Non-Standard Locations: --with-broccoli=PATH path to Broccoli install root --with-python=PATH path to Python interpreter --with-python-lib=PATH path to libpython --with-python-inc=PATH path to Python headers --with-swig=PATH path to SWIG executable Influential Environment Variables (only on first invocation per build directory): CC C compiler command CFLAGS C compiler flags CXX C++ compiler command CXXFLAGS C++ compiler flags " sourcedir="$( cd "$( dirname "$0" )" && pwd )" # Function to append a CMake cache entry definition to the # CMakeCacheEntries variable # $1 is the cache entry variable name # $2 is the cache entry variable type # $3 is the cache entry variable value append_cache_entry () { CMakeCacheEntries="$CMakeCacheEntries -D $1:$2=$3" } # set defaults builddir=build CMakeCacheEntries="" append_cache_entry PY_MOD_INSTALL_DIR PATH $site_packages append_cache_entry ENABLE_DEBUG BOOL false # parse arguments while [ $# -ne 0 ]; do case "$1" in -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;; *) optarg= ;; esac case "$1" in --help|-h) echo "${usage}" 1>&2 exit 1 ;; --builddir=*) builddir=$optarg ;; --prefix=*) append_cache_entry PY_MOD_INSTALL_DIR PATH $optarg/lib/python${pyver}/site-packages ;; --home=*) append_cache_entry PY_MOD_INSTALL_DIR PATH $optarg/lib/python ;; --enable-debug) append_cache_entry ENABLE_DEBUG BOOL true ;; --with-broccoli=*) append_cache_entry Broccoli_ROOT_DIR PATH $optarg ;; --with-python=*) append_cache_entry PYTHON_EXECUTABLE PATH $optarg ;; --with-python-lib=*) append_cache_entry PYTHON_LIBRARY PATH $optarg ;; --with-python-inc=*) append_cache_entry PYTHON_INCLUDE_DIR PATH $optarg append_cache_entry PYTHON_INCLUDE_PATH PATH $optarg ;; --with-swig=*) append_cache_entry SWIG_EXECUTABLE PATH $optarg ;; *) echo "Invalid option '$1'. Try $0 --help to see available options." exit 1 ;; esac shift done if [ -d $builddir ]; then # If build directory exists, check if it has a CMake cache if [ -f $builddir/CMakeCache.txt ]; then # If the CMake cache exists, delete it so that this configuration # is not tainted by a previous one rm -f $builddir/CMakeCache.txt fi else # Create build directory mkdir -p $builddir fi echo "Build Directory : $builddir" echo "Source Directory: $sourcedir" cd $builddir cmake $CMakeCacheEntries $sourcedir echo "# This is the command used to configure this build" > config.status echo $command >> config.status chmod u+x config.status broccoli-python-0.63/setup.py0000755000076500000240000000074513350247745016223 0ustar jonstaff00000000000000#! /usr/bin/env python import os import sys from distutils.core import setup, Extension setup(name="broccoli-python", version="0.63", # Filled in automatically. author_email="info@bro.org", license="BSD", py_modules=['broccoli'], ext_modules = [ Extension("_broccoli_intern", ["broccoli_intern_wrap.c"], include_dirs=["../../build/src"], library_dirs=["../../build/src"], libraries=["broccoli"])] ) broccoli-python-0.63/tests/0000755000076500000240000000000013350260210015620 5ustar jonstaff00000000000000broccoli-python-0.63/tests/broping-record.py0000755000076500000240000000112713350246015021121 0ustar jonstaff00000000000000#! /usr/bin/env python # # Use with broccoli/test/broping-record.bro. from time import sleep from broccoli import * ping_data = record_type("seq", "src_time") pong_data = record_type("seq", "src_time", "dst_time") @event(pong_data) def pong(data): print("pong event: seq=%i, time=%f/%f s" % (data.seq, data.dst_time - data.src_time, current_time() - data.src_time)) bc = Connection("127.0.0.1:47758") seq = 1 while True: data = record(ping_data) data.seq = count(seq) data.src_time = time(current_time()) bc.send("ping", data) seq += 1 sleep(1) broccoli-python-0.63/tests/broping.py0000755000076500000240000000064613350246015017652 0ustar jonstaff00000000000000#! /usr/bin/env python # # Use with broccoli/test/broping.bro. from time import sleep from broccoli import * @event def pong(src_time, dst_time, seq): print("pong event: seq=%i, time=%f/%f s" % (seq, dst_time - src_time, current_time() - src_time)) bc = Connection("127.0.0.1:47758") seq = 1 while True: bc.send("ping", time(current_time()), count(seq)) seq += 1 sleep(1) broccoli-python-0.63/tests/test.bro0000644000076500000240000000347213350246015017320 0ustar jonstaff00000000000000 @load frameworks/communication/listen redef Communication::listen_port = 47758/tcp; redef Communication::nodes += { ["broping"] = [$host = 127.0.0.1, $events = /test1|test3|test5/, $connect=F, $ssl=F] }; ### Testing atomic types. type foo: enum { CONST1, CONST2, CONST3 }; # No enum currently as Broccoli has trouble receiving them. global test2: event(a: int, b: count, c: time, d: interval, e: bool, f: double, g: string, h: port, i: addr, j: subnet, i6: addr, j6: subnet); global test2b: event(a: int, b: count, c: time, d: interval, e: bool, f: double, g: string, h: port, i: addr, j: subnet, i6: addr, j6: subnet); event test1(a: int, b: count, c: time, d: interval, e: bool, f: double, g: string, h: port, i: addr, j: subnet, i6: addr, j6: subnet) { print "==== atomic"; print a; print b; print c; print d; print e; print f; print g; print h; print i; print i6; print j; print j6; event test2(-4, 42, current_time(), 1min, T, 3.14, "Hurz", 12345/udp, 1.2.3.4, 22.33.44.0/24, [2607:f8b0:4009:802::1014], [2607:f8b0:4009:802::1014]/32); event test2(a,b,c,d,e,f,g,h,i,j,i6,j6); event test2b(a,b,c,d,e,f,g,h,i,j,i6,j6); } ### Testing record types. type rec: record { a: int; b: addr; }; global test4: event(r: rec); event test3(r: rec) { print "==== record"; print r; print r$a, r$b; event test4(r); local r2 : rec; r2$a = 99; r2$b = 3.4.5.1; event test4(r2); } type opt_rec: record { one: int &optional; a: int &optional; b: addr &optional; c: string &optional; d: string &optional; }; event test5(r: opt_rec) { print "==== coerced record"; print r; if ( r?$one ) print r$one; if ( r?$a ) print r$a; if ( r?$b ) print r$b; if ( r?$c ) print r$c; if ( r?$d ) print r$d; } broccoli-python-0.63/tests/test.py0000755000076500000240000000444413350246015017171 0ustar jonstaff00000000000000#! /usr/bin/env python from __future__ import print_function import time as Time from broccoli import * # Don't mind repr() for floats, since that may be shorter as of Python 2.7. # Since the time argument might be derived from the the current time, normalize # the display precision (e.g. prevent a rounding from tripping up a diff # canonifier's regex). @event def test2(a,b,c,d,e,f,g,h,i,j,i6,j6): global recv recv += 1 print("==== atomic a %d ====" % recv) print(repr(a), a) print(repr(b), b) print("%.4f" % c) print(d) print(repr(e), e) print(f) print(repr(g), g) print(repr(h), h) print(repr(i), i) print(repr(j), j) print(repr(i6), i6) print(repr(j6), j6) # Same as test2 except with typing this time. # For floating point types that are wrapped in a class, we do want to print # repr() to see that the event typing works. Again the time argument is # normalized to a constant precision. @event(int,count,time,interval,bool,double,addr,port,addr,subnet,addr,subnet) def test2b(a,b,c,d,e,f,g,h,i,j,i6,j6): print("==== atomic b %d ====" % recv) print(repr(a), a) print(repr(b), b) print(repr(c), "%.4f" % c.val) print(repr(d), d) print(repr(e), e) print(f) print(repr(g), g) print(repr(h), h) print(repr(i), i) print(repr(j), j) print(repr(i6), i6) print(repr(j6), j6) rec = record_type("a", "b") other_rec = record_type("a") @event(rec) def test4(r): global recv recv += 1 print("==== record %d ====" % recv) print(repr(r)) print(repr(r.a), r.a) print(repr(r.b), r.b) bc = Connection("127.0.0.1:47758") bc.send("test1", int(-10), count(2), time(current_time()), interval(120), bool(False), double(1.5), string("Servus"), port("5555/tcp"), addr("6.7.6.5"), subnet("192.168.0.0/16"), addr("2001:db8:85a3::8a2e:370:7334"), subnet("2001:db8:85a3::/48") ) recv = 0 while True: bc.processInput(); if recv == 2: break Time.sleep(1) r = record(rec) r.a = 42; r.b = addr("6.6.7.7") bc.send("test3", r) recv = 0 while True: bc.processInput(); if recv == 2: break Time.sleep(1) opt_record = record_type("one", "a", "b", "c", "d") r = record(opt_record) r.a = 13 r.c = "helloworld" bc.send("test5", r)