Changeset 988 for vendor/current/lib/tevent

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/lib/tevent

Files:

• ABI/tevent-0.9.12.sigs (added)
• ABI/tevent-0.9.13.sigs (added)
• ABI/tevent-0.9.14.sigs (added)
• ABI/tevent-0.9.15.sigs (added)
• ABI/tevent-0.9.16.sigs (added)
• ABI/tevent-0.9.17.sigs (added)
• ABI/tevent-0.9.18.sigs (added)
• ABI/tevent-0.9.19.sigs (added)
• ABI/tevent-0.9.20.sigs (added)
• ABI/tevent-0.9.21.sigs (added)
• ABI/tevent-0.9.22.sigs (added)
• ABI/tevent-0.9.23.sigs (added)
• ABI/tevent-0.9.24.sigs (added)
• ABI/tevent-0.9.25.sigs (added)
• ABI/tevent-0.9.26.sigs (added)
• ABI/tevent-0.9.27.sigs (added)
• ABI/tevent-0.9.28.sigs (added)
• bindings.py (modified) (2 diffs)
• doc/img (added)
• doc/img/tevent_context_stucture.png (added)
• doc/img/tevent_subrequest.png (added)
• doc/mainpage.dox (modified) (3 diffs)
• doc/tevent_context.dox (added)
• doc/tevent_data.dox (added)
• doc/tevent_events.dox (added)
• doc/tevent_queue.dox (added)
• doc/tevent_request.dox (added)
• doc/tevent_thread.dox (added)
• doc/tevent_tutorial.dox (added)
• doxy.config (modified) (61 diffs)
• echo_server.c (added)
• libtevent.m4 (deleted)
• pytevent.c (modified) (23 diffs)
• script (deleted)
• testsuite.c (modified) (11 diffs)
• tevent.c (modified) (9 diffs)
• tevent.h (modified) (25 diffs)
• tevent.pc.in (modified) (1 diff)
• tevent.py (added)
• tevent_debug.c (modified) (1 diff)
• tevent_epoll.c (modified) (19 diffs)
• tevent_immediate.c (modified) (1 diff)
• tevent_internal.h (modified) (5 diffs)
• tevent_liboop.c (modified) (1 diff)
• tevent_poll.c (modified) (13 diffs)
• tevent_port.c (added)
• tevent_queue.c (modified) (4 diffs)
• tevent_req.c (modified) (12 diffs)
• tevent_select.c (modified) (12 diffs)
• tevent_signal.c (modified) (17 diffs)
• tevent_standard.c (modified) (3 diffs)
• tevent_threads.c (added)
• tevent_timed.c (modified) (5 diffs)
• tevent_util.c (modified) (1 diff)
• tevent_util.h (modified) (6 diffs)
• tevent_wakeup.c (modified) (1 diff)
• wscript (modified) (9 diffs)

vendor/current/lib/tevent/bindings.py

@@ -23 +23 @@
 
 import signal
+from unittest import TestCase, TestProgram
+import gc
+
 import _tevent
-from unittest import TestCase
 
 class BackendListTests(TestCase):
@@ -61 +63 @@
         sig = self.ctx.add_signal(signal.SIGINT, 0, lambda callback: None)
         self.assertTrue(isinstance(sig, _tevent.Signal))
+
+    def test_timer(self):
+        """Test a timer is can be scheduled"""
+        collecting_list = []
+        # time "0" has already passed, callback will be scheduled immediately
+        timer = self.ctx.add_timer(0, lambda t: collecting_list.append(True))
+        self.assertTrue(timer.active)
+        self.assertEqual(collecting_list, [])
+        self.ctx.loop_once()
+        self.assertFalse(timer.active)
+        self.assertEqual(collecting_list, [True])
+
+    def test_timer_deallocate_timer(self):
+        """Test timer is scheduled even if reference to it isn't held"""
+        collecting_list = []
+        def callback(t):
+            collecting_list.append(True)
+        timer = self.ctx.add_timer(0, lambda t: collecting_list.append(True))
+        gc.collect()
+        self.assertEqual(collecting_list, [])
+        self.ctx.loop_once()
+        self.assertEqual(collecting_list, [True])
+
+    def test_timer_deallocate_context(self):
+        """Test timer is unscheduled when context is freed"""
+        collecting_list = []
+        def callback(t):
+            collecting_list.append(True)
+        timer = self.ctx.add_timer(0, lambda t: collecting_list.append(True))
+        self.assertTrue(timer.active)
+        del self.ctx
+        gc.collect()
+        self.assertEqual(collecting_list, [])
+        self.assertFalse(timer.active)
+
+    def test_timer_offset(self):
+        """Test scheduling timer with an offset"""
+        collecting_list = []
+        self.ctx.add_timer_offset(0.2, lambda t: collecting_list.append(2))
+        self.ctx.add_timer_offset(0.1, lambda t: collecting_list.append(1))
+        self.assertEqual(collecting_list, [])
+        self.ctx.loop_once()
+        self.assertEqual(collecting_list, [1])
+        self.ctx.loop_once()
+        self.assertEqual(collecting_list, [1, 2])
+
+if __name__ == '__main__':
+    TestProgram()

vendor/current/lib/tevent/doc/mainpage.dox

@@ -11 +11 @@
  * tevent_req (tevent request) functions.
  *
- * @section tevent_download Download
+ * @section main_tevent_tutorial Tutorial
+ *
+ * You should start by reading @subpage tevent_tutorial, then reading the
+ * documentation of the interesting functions as you go.
+ *
+ * @section main_tevent_download Download
  *
  * You can download the latest releases of tevent from the
@@ -17 +22 @@
  * on the samba public source archive.
  *
- * @section tevent_bugs Discussion and bug reports
+ * @section main_tevent_bugs Discussion and bug reports
  *
  * tevent does not currently have its own mailing list or bug tracking system.
@@ -26 +31 @@
  * bug tracking system.
  *
- * @section tevent_devel Development
+ * @section main_tevent_devel Development
  * You can download the latest code either via git or rsync.
  *

vendor/current/lib/tevent/doxy.config

@@ -1 @@
-# Doxyfile 1.6.1
+# Doxyfile 1.8.4
 
 # This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project
+# doxygen (www.doxygen.org) for a project.
 #
-# All text after a hash (#) is considered a comment and will be ignored
+# All text after a double hash (##) is considered a comment and is placed
+# in front of the TAG it is preceding .
+# All text after a hash (#) is considered a comment and will be ignored.
 # The format is:
 #       TAG = value [value, ...]
 # For lists items can also be appended using:
 #       TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (" ")
+# Values that contain spaces should be placed between quotes (" ").
 
 #---------------------------------------------------------------------------
@@ -23 +25 @@
 DOXYFILE_ENCODING      = UTF-8
 
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
-# by quotes) that should identify the project.
+# The PROJECT_NAME tag is a single word (or sequence of words) that should
+# identify the project. Note that if you do not use Doxywizard you need
+# to put quotes around the project name if it contains spaces.
 
 PROJECT_NAME           = tevent
@@ -33 +36 @@
 
 PROJECT_NUMBER         = 0.9.8
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          =
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# included in the documentation. The maximum height of the logo should not
+# exceed 55 pixels and the maximum width should not exceed 200 pixels.
+# Doxygen will copy the logo to the output directory.
+
+PROJECT_LOGO           =
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
@@ -57 +73 @@
 # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
 # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
-# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
-# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak,
-# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+# messages), Korean, Korean-en, Latvian, Lithuanian, Norwegian, Macedonian,
+# Persian, Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic,
+# Slovak, Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
 
 OUTPUT_LANGUAGE        = English
@@ -123 +139 @@
 # the path. The tag can be used to show relative paths in the file list.
 # If left blank the directory from which doxygen is run is used as the
-# path to strip.
+# path to strip. Note that you specify absolute paths here, but also
+# relative paths, which will be relative from the directory where doxygen is
+# started.
 
 STRIP_FROM_PATH        =
@@ -137 +155 @@
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
-# (but less readable) file names. This can be useful is your file systems
+# (but less readable) file names. This can be useful if your file system
 # doesn't support long names like on DOS, Mac, or CD-ROM.
 
@@ -192 +210 @@
 ALIASES                =
 
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding
+# "class=itcl::class" will allow you to use the command class in the
+# itcl::class meaning.
+
+TCL_SUBST              =
+
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
 # sources only. Doxygen will then generate output that is more tailored for C.
@@ -218 +243 @@
 OPTIMIZE_OUTPUT_VHDL   = NO
 
-# Doxygen selects the parser to use depending on the extension of the files it parses.
-# With this tag you can assign which parser to use for a given extension.
-# Doxygen has a built-in mapping, but you can override or extend it using this tag.
-# The format is ext=language, where ext is a file extension, and language is one of
-# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP,
-# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat
-# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran),
-# use: inc=Fortran f=C. Note that for custom extensions you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension,
+# and language is one of the parsers supported by doxygen: IDL, Java,
+# Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
+# C++. For instance to make doxygen treat .inc files as Fortran files (default
+# is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
+# that for custom extensions you also need to set FILE_PATTERNS otherwise the
+# files are not read by doxygen.
 
 EXTENSION_MAPPING      =
+
+# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
+# comments according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you
+# can mix doxygen, HTML, and XML commands with Markdown formatting.
+# Disable only in case of backward compatibilities issues.
+
+MARKDOWN_SUPPORT       = YES
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by by putting a % sign in front of the word
+# or globally by setting AUTOLINK_SUPPORT to NO.
+
+AUTOLINK_SUPPORT       = YES
 
 # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
@@ -233 +276 @@
 # set this tag to YES in order to let doxygen match functions declarations and
 # definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
-# func(std::string) {}). This also make the inheritance and collaboration
+# func(std::string) {}). This also makes the inheritance and collaboration
 # diagrams that involve STL classes more complete and accurate.
 
@@ -249 +292 @@
 SIP_SUPPORT            = NO
 
-# For Microsoft's IDL there are propget and propput attributes to indicate getter
-# and setter methods for a property. Setting this option to YES (the default)
-# will make doxygen to replace the get and set methods by a property in the
-# documentation. This will only work if the methods are indeed getting or
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES (the
+# default) will make doxygen replace the get and set methods by a property in
+# the documentation. This will only work if the methods are indeed getting or
 # setting a simple type. If this is not the case, or you want to show the
 # methods anyway, you should set this option to NO.
@@ -272 +315 @@
 
 SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
+# unions are shown inside the group in which they are included (e.g. using
+# @ingroup) instead of on a separate page (for HTML and Man pages) or
+# section (for LaTeX and RTF).
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
+# unions with only public data fields or simple typedef fields will be shown
+# inline in the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO (the default), structs, classes, and unions are shown on a separate
+# page (for HTML and Man pages) or section (for LaTeX and RTF).
+
+INLINE_SIMPLE_STRUCTS  = NO
 
 # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
@@ -283 +342 @@
 TYPEDEF_HIDES_STRUCT   = NO
 
-# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
-# determine which symbols to keep in memory and which to flush to disk.
-# When the cache is full, less often used symbols will be written to disk.
-# For small to medium size projects (<1000 input files) the default value is
-# probably good enough. For larger projects a too small cache size can cause
-# doxygen to be busy swapping symbols to and from disk most of the time
-# causing a significant performance penality.
-# If the system has enough physical memory increasing the cache will improve the
-# performance by keeping more symbols in memory. Note that the value works on
-# a logarithmic scale so increasing the size by one will rougly double the
-# memory usage. The cache size is given by this formula:
-# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
-# corresponding to a cache size of 2^16 = 65536 symbols
-
-SYMBOL_CACHE_SIZE      = 0
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can
+# be an expensive process and often the same symbol appear multiple times in
+# the code, doxygen keeps a cache of pre-resolved symbols. If the cache is too
+# small doxygen will become slower. If the cache is too large, memory is wasted.
+# The cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid
+# range is 0..9, the default is 0, corresponding to a cache size of 2^16 = 65536
+# symbols.
+
+LOOKUP_CACHE_SIZE      = 0
 
 #---------------------------------------------------------------------------
@@ -306 +360 @@
 # documentation are documented, even if no documentation was available.
 # Private class members and static file members will be hidden unless
-# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+# the EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES
 
 EXTRACT_ALL            = NO
@@ -314 +368 @@
 
 EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
+# scope will be included in the documentation.
+
+EXTRACT_PACKAGE        = NO
 
 # If the EXTRACT_STATIC tag is set to YES all static members of a file
@@ -337 +396 @@
 # 'anonymous_namespace{file}', where file will be replaced with the base
 # name of the file that contains the anonymous namespace. By default
-# anonymous namespace are hidden.
+# anonymous namespaces are hidden.
 
 EXTRACT_ANON_NSPACES   = NO
@@ -397 +456 @@
 SHOW_INCLUDE_FILES     = YES
 
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES   = NO
+
 # If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
 # is inserted in the documentation for inline members.
@@ -416 +481 @@
 SORT_BRIEF_DOCS        = NO
 
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the (brief and detailed) documentation of class members so that constructors and destructors are listed first. If set to NO (the default) the constructors will appear in the respective orders defined by SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
 
 SORT_MEMBERS_CTORS_1ST = NO
@@ -436 +507 @@
 SORT_BY_SCOPE_NAME     = NO
 
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING  = NO
+
 # The GENERATE_TODOLIST tag can be used to enable (YES) or
 # disable (NO) the todo list. This list is created by putting \todo
@@ -461 +541 @@
 
 # The ENABLED_SECTIONS tag can be used to enable conditional
-# documentation sections, marked by \if sectionname ... \endif.
+# documentation sections, marked by \if section-label ... \endif
+# and \cond section-label ... \endcond blocks.
 
 ENABLED_SECTIONS       =
 
 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines
-# the initial value of a variable or define consists of for it to appear in
+# the initial value of a variable or macro consists of for it to appear in
 # the documentation. If the initializer consists of more lines than specified
 # here it will be hidden. Use a value of 0 to hide initializers completely.
-# The appearance of the initializer of individual variables and defines in the
+# The appearance of the initializer of individual variables and macros in the
 # documentation can be controlled using \showinitializer or \hideinitializer
 # command in the documentation regardless of this setting.
@@ -480 +561 @@
 
 SHOW_USED_FILES        = YES
-
-# If the sources in your project are distributed over multiple directories
-# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
-# in the documentation. The default is NO.
-
-SHOW_DIRECTORIES       = NO
 
 # Set the SHOW_FILES tag to NO to disable the generation of the Files page.
@@ -510 +585 @@
 FILE_VERSION_FILTER    =
 
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by
-# doxygen. The layout file controls the global structure of the generated output files
-# in an output format independent way. The create the layout file that represents
-# doxygen's defaults, run doxygen with the -l option. You can optionally specify a
-# file name after the option, if omitted DoxygenLayout.xml will be used as the name
-# of the layout file.
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
 
 LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files
+# containing the references data. This must be a list of .bib files. The
+# .bib extension is automatically appended if omitted. Using this command
+# requires the bibtex tool to be installed. See also
+# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
+# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
+# feature you need bibtex and perl available in the search path. Do not use
+# file names with spaces, bibtex cannot handle them.
+
+CITE_BIB_FILES         =
 
 #---------------------------------------------------------------------------
@@ -547 +633 @@
 WARN_IF_DOC_ERROR      = YES
 
-# This WARN_NO_PARAMDOC option can be abled to get warnings for
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for
 # functions that are documented, but have no documentation for their parameters
 # or return value. If set to NO (the default) doxygen will only warn about
@@ -579 +665 @@
 # with spaces.
 
-INPUT                  = . doc
+INPUT                  = . \
+                         doc
 
 # This tag can be used to specify the character encoding of the source files
@@ -593 +680 @@
 # and *.h) to filter out the source-files in the directories. If left
 # blank the following patterns are tested:
-# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
-# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
+# *.f90 *.f *.for *.vhd *.vhdl
 
 FILE_PATTERNS          = *.cpp \
@@ -610 +698 @@
 RECURSIVE              = NO
 
-# The EXCLUDE tag can be used to specify files and/or directories that should
+# The EXCLUDE tag can be used to specify files and/or directories that should be
 # excluded from the INPUT source files. This way you can easily exclude a
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
 
 EXCLUDE                =
 
-# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
-# directories that are symbolic links (a Unix filesystem feature) are excluded
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
 # from the input.
 
@@ -628 +718 @@
 # for example use the pattern */test/*
 
-EXCLUDE_PATTERNS       = */.git/* \
-                         */.svn/* \
-                         */cmake/* \
-                         */build/*
+EXCLUDE_PATTERNS       = */.git/*
 
 # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
@@ -665 +752 @@
 # the \image command).
 
-IMAGE_PATH             =
+IMAGE_PATH             = doc/img
 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
@@ -673 +760 @@
 # input file. Doxygen will then use the output that the filter program writes
 # to standard output.
-# If FILTER_PATTERNS is specified, this tag will be
-# ignored.
+# If FILTER_PATTERNS is specified, this tag will be ignored.
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
 
 INPUT_FILTER           =
@@ -684 +773 @@
 # The filters are a list of the form:
 # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
-# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
-# is applied to all files.
+# info on how filters are used. If FILTER_PATTERNS is empty or if
+# non of the patterns match the file name, INPUT_FILTER is applied.
 
 FILTER_PATTERNS        =
@@ -694 +783 @@
 
 FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
+# and it is also possible to disable source filtering for a specific pattern
+# using *.ext= (so without naming a filter). This option only has effect when
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
 
 #---------------------------------------------------------------------------
@@ -713 +817 @@
 # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
 # doxygen to hide any special comment blocks from generated source code
-# fragments. Normal C and C++ comments will always remain visible.
+# fragments. Normal C, C++ and Fortran comments will always remain visible.
 
 STRIP_CODE_COMMENTS    = YES
@@ -783 +887 @@
 GENERATE_HTML          = YES
 
-# If the HTML_FOOTER_DESCRIPTION tag is set to YES, Doxygen will
-# add generated date, project name and doxygen version to HTML footer.
-
-HTML_FOOTER_DESCRIPTION= NO
-
 # The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
 # If a relative path is entered the value of OUTPUT_DIRECTORY will be
@@ -802 +901 @@
 # The HTML_HEADER tag can be used to specify a personal HTML header for
 # each generated HTML page. If it is left blank doxygen will generate a
-# standard header.
+# standard header. Note that when using a custom header you are responsible
+#  for the proper inclusion of any scripts and style sheets that doxygen
+# needs, which is dependent on the configuration options used.
+# It is advised to generate a default header using "doxygen -w html
+# header.html footer.html stylesheet.css YourConfigFile" and then modify
+# that header. Note that the header is subject to change so you typically
+# have to redo this when upgrading to a newer version of doxygen or when
+# changing the value of configuration settings such as GENERATE_TREEVIEW!
 
 HTML_HEADER            =
@@ -814 +920 @@
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
 # style sheet that is used by each HTML page. It can be used to
-# fine-tune the look of the HTML output. If the tag is left blank doxygen
-# will generate a default style sheet. Note that doxygen will try to copy
-# the style sheet file to the HTML output directory, so don't put your own
-# stylesheet in the HTML output directory as well, or it will be erased!
+# fine-tune the look of the HTML output. If left blank doxygen will
+# generate a default style sheet. Note that it is recommended to use
+# HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
+# tag will in the future become obsolete.
 
 HTML_STYLESHEET        =
 
-# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
-# files or namespaces will be aligned in HTML using tables. If set to
-# NO a bullet list will be used.
-
-HTML_ALIGN_MEMBERS     = YES
+# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
+# user-defined cascading style sheet that is included after the standard
+# style sheets created by doxygen. Using this option one can overrule
+# certain style aspects. This is preferred over using HTML_STYLESHEET
+# since it does not replace the standard style sheet and is therefor more
+# robust against future updates. Doxygen will copy the style sheet file to
+# the output directory.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that
+# the files will be copied as-is; there are no commands or markers available.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the style sheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP         = NO
 
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
-# page has loaded. For this to work a browser that supports
-# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
-# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+# page has loaded.
 
 HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
+# entries shown in the various tree structured indices initially; the user
+# can expand and collapse entries dynamically later on. Doxygen will expand
+# the tree to such a level that at most the specified number of entries are
+# visible (unless a fully collapsed tree already exceeds this amount).
+# So setting the number of entries 1 will produce a full collapsed tree by
+# default. 0 is a special value representing an infinite number of entries
+# and will result in a full expanded tree by default.
+
+HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files
@@ -843 +1002 @@
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
 # it at startup.
-# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
 
 GENERATE_DOCSET        = NO
@@ -861 +1021 @@
 DOCSET_BUNDLE_ID       = org.doxygen.Project
 
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
+# identify the documentation publisher. This should be a reverse domain-name
+# style string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
 # If the GENERATE_HTMLHELP tag is set to YES, additional index files
 # will be generated that can be used as input for tools like the
@@ -905 +1075 @@
 TOC_EXPAND             = NO
 
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER
-# are set, an additional index file will be generated that can be used as input for
-# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated
-# HTML documentation.
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
 
 GENERATE_QHP           = NO
@@ -930 +1100 @@
 QHP_VIRTUAL_FOLDER     = doc
 
-# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add.
-# For more information please see
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
 # http://doc.trolltech.com/qthelpproject.html#custom-filters
 
 QHP_CUST_FILTER_NAME   =
 
-# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see
-# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
 
 QHP_CUST_FILTER_ATTRS  =
 
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
 # filter section matches.
-# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">Qt Help Project / Filter Attributes</a>.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
 
 QHP_SECT_FILTER_ATTRS  =
@@ -954 +1128 @@
 QHG_LOCATION           =
 
-# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
-# top of each HTML page. The value NO (the default) enables the index and
-# the value YES disables it.
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+#  will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
+# at top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it. Since the tabs have the same information as the
+# navigation tree you can set this option to NO if you already set
+# GENERATE_TREEVIEW to YES.
 
 DISABLE_INDEX          = NO
-
-# This tag can be used to set the number of enum values (range [1..20])
-# that doxygen will group on one line in the generated HTML documentation.
-
-ENUM_VALUES_PER_LINE   = 4
 
 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
@@ -972 +1160 @@
 # JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
 # Windows users are probably better off using the HTML help feature.
+# Since the tree basically has the same information as the tab index you
+# could consider to set DISABLE_INDEX to NO when enabling this option.
 
 GENERATE_TREEVIEW      = NONE
 
-# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
-# and Class Hierarchy pages using a tree view instead of an ordered list.
-
-USE_INLINE_TREES       = NO
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
+# (range [0,1..20]) that doxygen will group on one line in the generated HTML
+# documentation. Note that a value of 0 will completely suppress the enum
+# values from appearing in the overview section.
+
+ENUM_VALUES_PER_LINE   = 4
 
 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
@@ -985 +1177 @@
 
 TREEVIEW_WIDTH         = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW    = NO
 
 # Use this tag to change the font size of Latex formulas included
@@ -994 +1191 @@
 FORMULA_FONTSIZE       = 10
 
-# When the SEARCHENGINE tag is enable doxygen will generate a search box for the HTML output. The underlying search engine uses javascript
-# and DHTML and should work on any modern browser. Note that when using HTML help (GENERATE_HTMLHELP) or Qt help (GENERATE_QHP)
-# there is already a search function so this one should typically
-# be disabled.
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
+# (see http://www.mathjax.org) which uses client side Javascript for the
+# rendering instead of using prerendered bitmaps. Use this if you do not
+# have LaTeX installed or if you want to formulas look prettier in the HTML
+# output. When enabled you may also need to install MathJax separately and
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
+# SVG. The default value is HTML-CSS, which is slower, but has the best
+# compatibility.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the
+# HTML output directory using the MATHJAX_RELPATH option. The destination
+# directory should contain the MathJax.js script. For instance, if the mathjax
+# directory is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to
+# the MathJax Content Delivery Network so you can quickly see the result without
+# installing MathJax.
+# However, it is strongly recommended to install a local
+# copy of MathJax from http://www.mathjax.org before deployment.
+
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
+# names that should be enabled during MathJax rendering.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript
+# pieces of code that will be used on startup of the MathJax code.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
 
 SEARCHENGINE           = NO
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using Javascript.
+# There are two flavours of web server based search depending on the
+# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
+# searching and an index file used by the script. When EXTERNAL_SEARCH is
+# enabled the indexing and searching needs to be provided by external tools.
+# See the manual for details.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain
+# the search results. Doxygen ships with an example indexer (doxyindexer) and
+# search engine (doxysearch.cgi) which are based on the open source search
+# engine library Xapian. See the manual for configuration details.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will returned the search results when EXTERNAL_SEARCH is enabled.
+# Doxygen ships with an example search engine (doxysearch) which is based on
+# the open source search engine library Xapian. See the manual for configuration
+# details.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
+# of to a relative location where the documentation can be found.
+# The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...
+
+EXTRA_SEARCH_MAPPINGS  =
 
 #---------------------------------------------------------------------------
@@ -1018 +1314 @@
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
 # invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
 
 LATEX_CMD_NAME         = latex
@@ -1034 +1333 @@
 
 # The PAPER_TYPE tag can be used to set the paper type that is used
-# by the printer. Possible values are: a4, a4wide, letter, legal and
-# executive. If left blank a4wide will be used.
+# by the printer. Possible values are: a4, letter, legal and
+# executive. If left blank a4 will be used.
 
 PAPER_TYPE             = a4wide
@@ -1051 +1350 @@
 LATEX_HEADER           =
 
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
+# the generated latex document. The footer should contain everything after
+# the last chapter. If it is left blank doxygen will generate a
+# standard footer. Notice: only use this tag if you know what you are doing!
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images
+# or other source files which should be copied to the LaTeX output directory.
+# Note that the files will be copied as-is; there are no commands or markers
+# available.
+
+LATEX_EXTRA_FILES      =
+
 # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
 # is prepared for conversion to pdf (using ps2pdf). The pdf file will
@@ -1077 +1390 @@
 LATEX_HIDE_INDICES     = NO
 
-# If LATEX_SOURCE_CODE is set to YES then doxygen will include source code with syntax highlighting in the LaTeX output. Note that which sources are shown also depends on other settings such as SOURCE_BROWSER.
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
 
 LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
+# http://en.wikipedia.org/wiki/BibTeX for more info.
+
+LATEX_BIB_STYLE        = plain
 
 #---------------------------------------------------------------------------
@@ -1112 +1434 @@
 RTF_HYPERLINKS         = NO
 
-# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# Load style sheet definitions from file. Syntax is similar to doxygen's
 # config file, i.e. a series of assignments. You only have to provide
 # replacements, missing definitions are set to their default value.
@@ -1185 +1507 @@
 
 XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES Doxygen will generate DOCBOOK files
+# that can be used to generate PDF.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the DOCBOOK pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it. If left blank docbook will be used as the default path.
+
+DOCBOOK_OUTPUT         = docbook
 
 #---------------------------------------------------------------------------
@@ -1257 +1594 @@
 
 # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
-# in the INCLUDE_PATH (see below) will be search if a #include is found.
+# pointed to by INCLUDE_PATH will be searched when a #include is found.
 
 SEARCH_INCLUDES        = YES
@@ -1282 +1619 @@
 # instead of the = operator.
 
-PREDEFINED             = DOXYGEN PRINTF_ATTRIBUTE(x,y)=
+PREDEFINED             = DOXYGEN \
+                         PRINTF_ATTRIBUTE(x,y)=
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
 # this tag can be used to specify a list of macro names that should be expanded.
 # The macro definition that is found in the sources will be used.
-# Use the PREDEFINED tag if you want to use a different macro definition.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
 
 EXPAND_AS_DEFINED      =
 
 # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
-# doxygen's preprocessor will remove all function-like macros that are alone
-# on a line, have an all uppercase name, and do not end with a semicolon. Such
-# function macros are typically used for boiler-plate code, and will confuse
-# the parser if not removed.
+# doxygen's preprocessor will remove all references to function-like macros
+# that are alone on a line, have an all uppercase name, and do not end with a
+# semicolon, because these will confuse the parser if not removed.
 
 SKIP_FUNCTION_MACROS   = YES
@@ -1303 +1641 @@
 #---------------------------------------------------------------------------
 
-# The TAGFILES option can be used to specify one or more tagfiles.
-# Optionally an initial location of the external documentation
-# can be added for each tagfile. The format of a tag file without
-# this location is as follows:
+# The TAGFILES option can be used to specify one or more tagfiles. For each
+# tag file the location of the external documentation should be added. The
+# format of a tag file without this location is as follows:
 #
 # TAGFILES = file1 file2 ...
@@ -1312 +1649 @@
 #
 # TAGFILES = file1=loc1 "file2 = loc2" ...
-# where "loc1" and "loc2" can be relative or absolute paths or
-# URLs. If a location is present for each tag, the installdox tool
-# does not have to be run to correct the links.
-# Note that each tag file must have a unique name
-# (where the name does NOT include the path)
-# If a tag file is not located in the directory in which doxygen
-# is run, you must also specify the path to the tagfile here.
+# where "loc1" and "loc2" can be relative or absolute paths
+# or URLs. Note that each tag file must have a unique name (where the name does
+# NOT include the path). If a tag file is not located in the directory in which
+# doxygen is run, you must also specify the path to the tagfile here.
 
 TAGFILES               =
@@ -1339 +1673 @@
 EXTERNAL_GROUPS        = YES
 
+# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed
+# in the related pages index. If set to NO, only the current project's
+# pages will be listed.
+
+EXTERNAL_PAGES         = YES
+
 # The PERL_PATH should be the absolute path and name of the perl script
 # interpreter (i.e. the result of `which perl').
@@ -1351 +1691 @@
 # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
 # or super classes. Setting the tag to NO turns the diagrams off. Note that
-# this option is superseded by the HAVE_DOT option below. This is only a
-# fallback. It is recommended to install and use dot, since it yields more
-# powerful graphs.
+# this option also works with HAVE_DOT disabled, but it is recommended to
+# install and use dot, since it yields more powerful graphs.
 
 CLASS_DIAGRAMS         = YES
@@ -1379 +1718 @@
 HAVE_DOT               = NO
 
-# By default doxygen will write a font called FreeSans.ttf to the output
-# directory and reference it in all dot files that doxygen generates. This
-# font does not include all possible unicode characters however, so when you need
-# these (or just want a differently looking font) you can specify the font name
-# using DOT_FONTNAME. You need need to make sure dot is able to find the font,
-# which can be done by putting it in a standard location or by setting the
-# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory
-# containing the font.
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS        = 0
+
+# By default doxygen will use the Helvetica font for all dot files that
+# doxygen generates. When you want a differently looking font you can specify
+# the font name using DOT_FONTNAME. You need to make sure dot is able to find
+# the font, which can be done by putting it in a standard location or by setting
+# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font.
 
 DOT_FONTNAME           = FreeSans
@@ -1395 +1740 @@
 DOT_FONTSIZE           = 10
 
-# By default doxygen will tell dot to use the output directory to look for the
-# FreeSans.ttf font (which doxygen will put there itself). If you specify a
-# different font using DOT_FONTNAME you can set the path where dot
-# can find it using this tag.
+# By default doxygen will tell dot to use the Helvetica font.
+# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
+# set the path where dot can find it.
 
 DOT_FONTPATH           =
@@ -1405 +1749 @@
 # will generate a graph for each documented class showing the direct and
 # indirect inheritance relations. Setting this tag to YES will force the
-# the CLASS_DIAGRAMS tag to NO.
+# CLASS_DIAGRAMS tag to NO.
 
 CLASS_GRAPH            = YES
@@ -1426 +1770 @@
 
 UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside
+# the class node. If there are many fields or methods and many nodes the
+# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
+# threshold limits the number of items for each type to make the size more
+# manageable. Set this to 0 for no limit. Note that the threshold may be
+# exceeded by 50% before the limit is enforced.
+
+UML_LIMIT_NUM_FIELDS   = 10
 
 # If set to YES, the inheritance and collaboration graphs will show the
@@ -1463 +1816 @@
 
 # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
-# will graphical hierarchy of all classes instead of a textual one.
+# will generate a graphical hierarchy of all classes instead of a textual one.
 
 GRAPHICAL_HIERARCHY    = YES
 
-# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
 # then doxygen will show the dependencies a directory has on other directories
 # in a graphical way. The dependency relations are determined by the #include
@@ -1475 +1828 @@
 
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot. Possible values are png, jpg, or gif
-# If left blank png will be used.
+# generated by dot. Possible values are svg, png, jpg, or gif.
+# If left blank png will be used. If you choose svg you need to set
+# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible in IE 9+ (other browsers do not have this requirement).
 
 DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+# Note that this requires a modern browser other than Internet Explorer.
+# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
+# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible. Older versions of IE do not have SVG support.
+
+INTERACTIVE_SVG        = NO
 
 # The tag DOT_PATH can be used to specify the path where the dot tool can be
@@ -1490 +1854 @@
 
 DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the
+# \mscfile command).
+
+MSCFILE_DIRS           =
 
 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of

vendor/current/lib/tevent/pytevent.c

@@ -24 +24 @@
 
 #include <Python.h>
+#include "replace.h"
 #include <tevent.h>
+
+#if PY_MAJOR_VERSION >= 3
+#define PyStr_Check PyUnicode_Check
+#define PyStr_FromString PyUnicode_FromString
+#define PyStr_AsUTF8 PyUnicode_AsUTF8
+#define PyInt_FromLong PyLong_FromLong
+#else
+#define PyStr_Check PyString_Check
+#define PyStr_FromString PyString_FromString
+#define PyStr_AsUTF8 PyString_AsString
+#endif
+
+void init_tevent(void);
 
 typedef struct {
@@ -49 +63 @@
         PyObject_HEAD
         struct tevent_timer *timer;
+        PyObject *callback;
 } TeventTimer_Object;
 
@@ -56 +71 @@
 } TeventFd_Object;
 
-staticforward PyTypeObject TeventContext_Type;
-staticforward PyTypeObject TeventReq_Type;
-staticforward PyTypeObject TeventQueue_Type;
-staticforward PyTypeObject TeventSignal_Type;
-staticforward PyTypeObject TeventTimer_Type;
-staticforward PyTypeObject TeventFd_Type;
+static PyTypeObject TeventContext_Type;
+static PyTypeObject TeventReq_Type;
+static PyTypeObject TeventQueue_Type;
+static PyTypeObject TeventSignal_Type;
+static PyTypeObject TeventTimer_Type;
+static PyTypeObject TeventFd_Type;
 
 static int py_context_init(struct tevent_context *ev)
@@ -87 +102 @@
 }
 
-uint16_t py_get_fd_flags(struct tevent_fd *fde)
+static uint16_t py_get_fd_flags(struct tevent_fd *fde)
 {
         /* FIXME */
@@ -174 +189 @@
         }
 
-        if (!PyString_Check(name)) {
+        if (!PyStr_Check(name)) {
                 PyErr_SetNone(PyExc_TypeError);
-                return NULL;
-        }
-
-        if (!tevent_register_backend(PyString_AsString(name), &py_tevent_ops)) { /* FIXME: What to do with backend */
+                Py_DECREF(name);
+                return NULL;
+        }
+
+        if (!tevent_register_backend(PyStr_AsUTF8(name), &py_tevent_ops)) { /* FIXME: What to do with backend */
                 PyErr_SetNone(PyExc_RuntimeError);
-                return NULL;
-        }
+                Py_DECREF(name);
+                return NULL;
+        }
+
+        Py_DECREF(name);
 
         Py_RETURN_NONE;
@@ -213 +232 @@
         PyObject *callback = private_data, *ret;
 
-        ret = PyObject_CallFunction(callback, "");
+        ret = PyObject_CallFunction(callback, discard_const_p(char, ""));
         Py_XDECREF(ret);
 }
@@ -278 +297 @@
 }
 
-#ifdef TEVENT_DEPRECATED
-static bool py_tevent_finished(PyObject *callback)
-{
-        PyObject *py_ret;
-        bool ret;
-
-        py_ret = PyObject_CallFunction(callback, "");
-        if (py_ret == NULL)
-                return true;
-        ret = PyObject_IsTrue(py_ret);
-        Py_DECREF(py_ret);
-        return ret;
-}
-
-static PyObject *py_tevent_context_loop_until(TeventContext_Object *self, PyObject *args)
-{
-        PyObject *callback;
-        if (!PyArg_ParseTuple(args, "O", &callback))
-                return NULL;
-
-        if (tevent_loop_until(self->ev, py_tevent_finished, callback) != 0) {
-                PyErr_SetNone(PyExc_RuntimeError);
-                return NULL;
-        }
-
-        if (PyErr_Occurred())
-                return NULL;
-
-        Py_RETURN_NONE;
-}
-#endif
-
 static void py_tevent_signal_handler(struct tevent_context *ev,
                                         struct tevent_signal *se,
@@ -319 +306 @@
         PyObject *callback = (PyObject *)private_data, *ret;
 
-        ret = PyObject_CallFunction(callback, "ii", signum, count);
+        ret = PyObject_CallFunction(callback, discard_const_p(char, "ii"), signum, count);
         Py_XDECREF(ret);
 }
@@ -330 +317 @@
 
 static PyTypeObject TeventSignal_Type = {
-        .tp_name = "Signal",
+        .tp_name = "tevent.Signal",
         .tp_basicsize = sizeof(TeventSignal_Object),
         .tp_dealloc = (destructor)py_tevent_signal_dealloc,
@@ -367 +354 @@
                                        void *private_data)
 {
-        PyObject *callback = private_data, *ret;
-        ret = PyObject_CallFunction(callback, "l", te);
+        TeventTimer_Object *self = private_data;
+        PyObject *ret;
+
+        ret = PyObject_CallFunction(self->callback, discard_const_p(char, "l"), te);
+        if (ret == NULL) {
+                /* No Python stack to propagate exception to; just print traceback */
+                PyErr_PrintEx(0);
+        }
         Py_XDECREF(ret);
 }
 
-static PyObject *py_tevent_context_add_timer(TeventContext_Object *self, PyObject *args)
-{
+static void py_tevent_timer_dealloc(TeventTimer_Object *self)
+{
+        if (self->timer) {
+                talloc_free(self->timer);
+        }
+        Py_DECREF(self->callback);
+        PyObject_Del(self);
+}
+
+static int py_tevent_timer_traverse(TeventTimer_Object *self, visitproc visit, void *arg)
+{
+        Py_VISIT(self->callback);
+        return 0;
+}
+
+static PyObject* py_tevent_timer_get_active(TeventTimer_Object *self) {
+        return PyBool_FromLong(self->timer != NULL);
+}
+
+struct PyGetSetDef py_tevent_timer_getset[] = {
+        {
+                .name = discard_const_p(char, "active"),
+                .get = (getter)py_tevent_timer_get_active,
+                .doc = discard_const_p(char, "true if the timer is scheduled to run"),
+        },
+        {NULL},
+};
+
+static PyTypeObject TeventTimer_Type = {
+        .tp_name = "tevent.Timer",
+        .tp_basicsize = sizeof(TeventTimer_Object),
+        .tp_dealloc = (destructor)py_tevent_timer_dealloc,
+        .tp_traverse = (traverseproc)py_tevent_timer_traverse,
+        .tp_getset = py_tevent_timer_getset,
+        .tp_flags = Py_TPFLAGS_DEFAULT,
+};
+
+struct TeventTimer_Object_ref {
+        TeventTimer_Object *obj;
+};
+
+static int TeventTimer_Object_ref_destructor(struct TeventTimer_Object_ref *ref)
+{
+        ref->obj->timer = NULL;
+        Py_DECREF(ref->obj);
+        return 0;
+}
+
+static PyObject *py_tevent_context_add_timer_internal(TeventContext_Object *self,
+                                                      struct timeval next_event,
+                                                      PyObject *callback)
+{
+        /* Ownership notes:
+         *
+         * There are 5 pieces in play; two tevent contexts and 3 Python objects:
+         * - The tevent timer
+         * - The tevent context
+         * - The Python context -- "self"
+         * - The Python timer (TeventTimer_Object) -- "ret"
+         * - The Python callback function -- "callback"
+         *
+         * We only use the Python context for getting the tevent context,
+         * afterwards it can be destroyed.
+         *
+         * The tevent context owns the tevent timer.
+         *
+         * The tevent timer holds a reference to the Python timer, so the Python
+         * timer must always outlive the tevent timer.
+         * The Python timer has a pointer to the tevent timer; a destructor is
+         * used to set this to NULL when the tevent timer is deallocated.
+         *
+         * The tevent timer can be deallocated in these cases:
+         *  1) when the context is destroyed
+         *  2) after the event fires
+         *  Posssibly, API might be added to cancel (free the tevent timer).
+         *
+         * The Python timer holds a reference to the callback.
+         */
         TeventTimer_Object *ret;
-        struct timeval next_event;
-        struct tevent_timer *timer;
-        PyObject *handler;
-        if (!PyArg_ParseTuple(args, "lO", &next_event, &handler))
-                return NULL;
-
-        timer = tevent_add_timer(self->ev, NULL, next_event, py_timer_handler,
-                                                         handler);
-        if (timer == NULL) {
-                PyErr_SetNone(PyExc_RuntimeError);
-                return NULL;
-        }
+        struct TeventTimer_Object_ref *ref;
 
         ret = PyObject_New(TeventTimer_Object, &TeventTimer_Type);
         if (ret == NULL) {
                 PyErr_NoMemory();
-                talloc_free(timer);
-                return NULL;
-        }
-        ret->timer = timer;
+                return NULL;
+        }
+        Py_INCREF(callback);
+        ret->callback = callback;
+        ret->timer = tevent_add_timer(self->ev, NULL, next_event, py_timer_handler,
+                                      ret);
+        if (ret->timer == NULL) {
+                Py_DECREF(ret);
+                PyErr_SetString(PyExc_RuntimeError, "Could not initialize timer");
+                return NULL;
+        }
+        ref = talloc(ret->timer, struct TeventTimer_Object_ref);
+        if (ref == NULL) {
+                talloc_free(ret->timer);
+                Py_DECREF(ret);
+                PyErr_SetString(PyExc_RuntimeError, "Could not initialize timer");
+                return NULL;
+        }
+        Py_INCREF(ret);
+        ref->obj = ret;
+
+        talloc_set_destructor(ref, TeventTimer_Object_ref_destructor);
 
         return (PyObject *)ret;
+}
+
+static PyObject *py_tevent_context_add_timer(TeventContext_Object *self, PyObject *args)
+{
+        struct timeval next_event;
+        PyObject *callback;
+        if (!PyArg_ParseTuple(args, "lO", &next_event, &callback))
+                return NULL;
+
+        return py_tevent_context_add_timer_internal(self, next_event, callback);
+}
+
+static PyObject *py_tevent_context_add_timer_offset(TeventContext_Object *self, PyObject *args)
+{
+        struct timeval next_event;
+        double offset;
+        int seconds;
+        PyObject *callback;
+        if (!PyArg_ParseTuple(args, "dO", &offset, &callback))
+                return NULL;
+
+        seconds = offset;
+        offset -= seconds;
+        next_event = tevent_timeval_current_ofs(seconds, (int)(offset*1000000));
+        return py_tevent_context_add_timer_internal(self, next_event, callback);
 }
 
@@ -406 +507 @@
         PyObject *callback = private_data, *ret;
 
-        ret = PyObject_CallFunction(callback, "i", flags);
+        ret = PyObject_CallFunction(callback, discard_const_p(char, "i"), flags);
         Py_XDECREF(ret);
 }
+
+static void py_tevent_fp_dealloc(TeventFd_Object *self)
+{
+        talloc_free(self->fd);
+        PyObject_Del(self);
+}
+
+static PyTypeObject TeventFd_Type = {
+        .tp_name = "tevent.Fd",
+        .tp_basicsize = sizeof(TeventFd_Object),
+        .tp_dealloc = (destructor)py_tevent_fp_dealloc,
+        .tp_flags = Py_TPFLAGS_DEFAULT,
+};
 
 static PyObject *py_tevent_context_add_fd(TeventContext_Object *self, PyObject *args)
@@ -435 +549 @@
         return (PyObject *)ret;
 }
-
-#ifdef TEVENT_DEPRECATED
-static PyObject *py_tevent_context_set_allow_nesting(TeventContext_Object *self)
-{
-        tevent_loop_allow_nesting(self->ev);
-        Py_RETURN_NONE;
-}
-#endif
 
 static PyMethodDef py_tevent_context_methods[] = {
@@ -453 +559 @@
         { "loop_once", (PyCFunction)py_tevent_context_loop_once,
                 METH_NOARGS, "S.loop_once()" },
-#ifdef TEVENT_DEPRECATED
-        { "loop_until", (PyCFunction)py_tevent_context_loop_until,
-                METH_VARARGS, "S.loop_until(callback)" },
-#endif
         { "add_signal", (PyCFunction)py_tevent_context_add_signal,
                 METH_VARARGS, "S.add_signal(signum, sa_flags, handler) -> signal" },
         { "add_timer", (PyCFunction)py_tevent_context_add_timer,
                 METH_VARARGS, "S.add_timer(next_event, handler) -> timer" },
+        { "add_timer_offset", (PyCFunction)py_tevent_context_add_timer_offset,
+                METH_VARARGS, "S.add_timer(offset_seconds, handler) -> timer" },
         { "add_fd", (PyCFunction)py_tevent_context_add_fd, 
                 METH_VARARGS, "S.add_fd(fd, flags, handler) -> fd" },
-#ifdef TEVENT_DEPRECATED
-        { "allow_nesting", (PyCFunction)py_tevent_context_set_allow_nesting, 
-                METH_NOARGS, "Whether to allow nested tevent loops." },
-#endif
         { NULL },
 };
@@ -501 +601 @@
 
 static PyGetSetDef py_tevent_req_getsetters[] = {
-        { "in_progress", (getter)py_tevent_req_is_in_progress, NULL,
-                "Whether the request is in progress" },
+        {
+                .name = discard_const_p(char, "in_progress"),
+                .get = (getter)py_tevent_req_is_in_progress,
+                .doc = discard_const_p(char, "Whether the request is in progress"),
+        },
         { NULL }
 };
@@ -590 +693 @@
 
 static PyGetSetDef py_tevent_queue_getsetters[] = {
-        { "length", (getter)py_tevent_queue_get_length,
-                NULL, "The number of elements in the queue." },
+        {
+                .name = discard_const_p(char, "length"),
+                .get = (getter)py_tevent_queue_get_length,
+                .doc = discard_const_p(char, "The number of elements in the queue."),
+        },
         { NULL },
 };
@@ -617 +723 @@
 
 static PyGetSetDef py_tevent_context_getsetters[] = {
-        { "signal_support", (getter)py_tevent_context_signal_support,
-                NULL, "if this platform and tevent context support signal handling" },
+        {
+                .name = discard_const_p(char, "signal_support"),
+                .get = (getter)py_tevent_context_signal_support,
+                .doc = discard_const_p(char, "if this platform and tevent context support signal handling"),
+        },
         { NULL }
 };
@@ -635 +744 @@
         TeventContext_Object *ret;
 
-        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwnames, &name))
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", discard_const_p(char *, kwnames), &name))
                 return NULL;
 
@@ -661 +770 @@
 
 static PyTypeObject TeventContext_Type = {
-        .tp_name = "_tevent.Context",
+        .tp_name = "tevent.Context",
         .tp_new = py_tevent_context_new,
         .tp_basicsize = sizeof(TeventContext_Object),
@@ -683 +792 @@
 static PyObject *py_backend_list(PyObject *self)
 {
-        PyObject *ret;
-        int i;
-        const char **backends;
+        PyObject *ret = NULL;
+        PyObject *string = NULL;
+        int i, result;
+        const char **backends = NULL;
 
         ret = PyList_New(0);
@@ -695 +805 @@
         if (backends == NULL) {
                 PyErr_SetNone(PyExc_RuntimeError);
-                Py_DECREF(ret);
-                return NULL;
+                goto err;
         }
         for (i = 0; backends[i]; i++) {
-                PyList_Append(ret, PyString_FromString(backends[i]));
+                string = PyStr_FromString(backends[i]);
+                if (!string) {
+                        goto err;
+                }
+                result = PyList_Append(ret, string);
+                if (result) {
+                        goto err;
+                }
+                Py_DECREF(string);
+                string = NULL;
         }
 
@@ -705 +823 @@
 
         return ret;
+
+err:
+        Py_XDECREF(ret);
+        Py_XDECREF(string);
+        talloc_free(backends);
+        return NULL;
 }
 
@@ -717 +841 @@
 };
 
-void init_tevent(void)
+#define MODULE_DOC PyDoc_STR("Python wrapping of talloc-maintained objects.")
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        .m_name = "_tevent",
+        .m_doc = MODULE_DOC,
+        .m_size = -1,
+        .m_methods = tevent_methods,
+};
+#endif
+
+PyObject * module_init(void);
+PyObject * module_init(void)
 {
         PyObject *m;
 
         if (PyType_Ready(&TeventContext_Type) < 0)
-                return;
+                return NULL;
 
         if (PyType_Ready(&TeventQueue_Type) < 0)
-                return;
+                return NULL;
 
         if (PyType_Ready(&TeventReq_Type) < 0)
-                return;
+                return NULL;
 
         if (PyType_Ready(&TeventSignal_Type) < 0)
-                return;
+                return NULL;
 
         if (PyType_Ready(&TeventTimer_Type) < 0)
-                return;
+                return NULL;
 
         if (PyType_Ready(&TeventFd_Type) < 0)
-                return;
-
-        m = Py_InitModule3("_tevent", tevent_methods, "Tevent integration for twisted.");
+                return NULL;
+
+#if PY_MAJOR_VERSION >= 3
+        m = PyModule_Create(&moduledef);
+#else
+        m = Py_InitModule3("_tevent", tevent_methods, MODULE_DOC);
+#endif
         if (m == NULL)
-                return;
+                return NULL;
 
         Py_INCREF(&TeventContext_Type);
@@ -760 +901 @@
         Py_INCREF(&TeventFd_Type);
         PyModule_AddObject(m, "Fd", (PyObject *)&TeventFd_Type);
-}
+
+        PyModule_AddStringConstant(m, "__version__", PACKAGE_VERSION);
+
+        return m;
+}
+
+#if PY_MAJOR_VERSION >= 3
+PyMODINIT_FUNC PyInit__tevent(void);
+PyMODINIT_FUNC PyInit__tevent(void)
+{
+        return module_init();
+}
+#else
+void init_tevent(void);
+void init_tevent(void)
+{
+        module_init();
+}
+#endif

vendor/current/lib/tevent/testsuite.c

@@ -5 +5 @@
 
    Copyright (C) Stefan Metzmacher 2006-2009
+   Copyright (C) Jeremy Allison    2013
 
      ** NOTE! The following LGPL license applies to the tevent
@@ -25 +26 @@
 
 #include "includes.h"
-#include "lib/events/events.h"
+#include "lib/tevent/tevent.h"
 #include "system/filesys.h"
+#include "system/select.h"
+#include "system/network.h"
 #include "torture/torture.h"
+#include "torture/local/proto.h"
+#ifdef HAVE_PTHREAD
+#include <pthread.h>
+#include <assert.h>
+#endif
 
 static int fde_count;
 
-static void fde_handler(struct tevent_context *ev_ctx, struct tevent_fd *f, 
+static void fde_handler_read(struct tevent_context *ev_ctx, struct tevent_fd *f,
                         uint16_t flags, void *private_data)
 {
@@ -40 +48 @@
 #endif
         kill(getpid(), SIGALRM);
+
         read(fd[0], &c, 1);
+        fde_count++;
+}
+
+static void fde_handler_write(struct tevent_context *ev_ctx, struct tevent_fd *f,
+                        uint16_t flags, void *private_data)
+{
+        int *fd = (int *)private_data;
+        char c = 0;
         write(fd[1], &c, 1);
+}
+
+
+/* This will only fire if the fd's returned from pipe() are bi-directional. */
+static void fde_handler_read_1(struct tevent_context *ev_ctx, struct tevent_fd *f,
+                        uint16_t flags, void *private_data)
+{
+        int *fd = (int *)private_data;
+        char c;
+#ifdef SA_SIGINFO
+        kill(getpid(), SIGUSR1);
+#endif
+        kill(getpid(), SIGALRM);
+
+        read(fd[1], &c, 1);
         fde_count++;
+}
+
+/* This will only fire if the fd's returned from pipe() are bi-directional. */
+static void fde_handler_write_1(struct tevent_context *ev_ctx, struct tevent_fd *f,
+                        uint16_t flags, void *private_data)
+{
+        int *fd = (int *)private_data;
+        char c = 0;
+        write(fd[0], &c, 1);
 }
 
@@ -52 +93 @@
 }
 
-static void count_handler(struct tevent_context *ev_ctx, struct signal_event *te,
+static void count_handler(struct tevent_context *ev_ctx, struct tevent_signal *te,
                           int signum, int count, void *info, void *private_data)
 {
@@ -66 +107 @@
         const char *backend = (const char *)test_data;
         int alarm_count=0, info_count=0;
-        struct tevent_fd *fde;
+        struct tevent_fd *fde_read;
+        struct tevent_fd *fde_read_1;
+        struct tevent_fd *fde_write;
+        struct tevent_fd *fde_write_1;
 #ifdef SA_RESTART
         struct tevent_signal *se1 = NULL;
 #endif
+#ifdef SA_RESETHAND
         struct tevent_signal *se2 = NULL;
+#endif
 #ifdef SA_SIGINFO
         struct tevent_signal *se3 = NULL;
@@ -76 +122 @@
         int finished=0;
         struct timeval t;
-        char c = 0;
-
-        ev_ctx = event_context_init_byname(test, backend);
+        int ret;
+
+        ev_ctx = tevent_context_init_byname(test, backend);
         if (ev_ctx == NULL) {
                 torture_comment(test, "event backend '%s' not supported\n", backend);
@@ -84 +130 @@
         }
 
-        torture_comment(test, "Testing event backend '%s'\n", backend);
+        torture_comment(test, "backend '%s' - %s\n",
+                        backend, __FUNCTION__);
 
         /* reset globals */
@@ -90 +137 @@
 
         /* create a pipe */
-        pipe(fd);
-
-        fde = event_add_fd(ev_ctx, ev_ctx, fd[0], EVENT_FD_READ,
-                           fde_handler, fd);
-        tevent_fd_set_auto_close(fde);
-
-        event_add_timed(ev_ctx, ev_ctx, timeval_current_ofs(2,0), 
-                        finished_handler, &finished);
+        ret = pipe(fd);
+        torture_assert_int_equal(test, ret, 0, "pipe failed");
+
+        fde_read = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_READ,
+                            fde_handler_read, fd);
+        fde_write_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_WRITE,
+                            fde_handler_write_1, fd);
+
+        fde_write = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_WRITE,
+                            fde_handler_write, fd);
+        fde_read_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_READ,
+                            fde_handler_read_1, fd);
+
+        tevent_fd_set_auto_close(fde_read);
+        tevent_fd_set_auto_close(fde_write);
+
+        tevent_add_timer(ev_ctx, ev_ctx, timeval_current_ofs(2,0),
+                         finished_handler, &finished);
 
 #ifdef SA_RESTART
-        se1 = event_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESTART, count_handler, &alarm_count);
+        se1 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESTART, count_handler, &alarm_count);
+        torture_assert(test, se1 != NULL, "failed to setup se1");
 #endif
 #ifdef SA_RESETHAND
-        se2 = event_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESETHAND, count_handler, &alarm_count);
+        se2 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESETHAND, count_handler, &alarm_count);
+        torture_assert(test, se2 != NULL, "failed to setup se2");
 #endif
 #ifdef SA_SIGINFO
-        se3 = event_add_signal(ev_ctx, ev_ctx, SIGUSR1, SA_SIGINFO, count_handler, &info_count);
-#endif
-
-        write(fd[1], &c, 1);
+        se3 = tevent_add_signal(ev_ctx, ev_ctx, SIGUSR1, SA_SIGINFO, count_handler, &info_count);
+        torture_assert(test, se3 != NULL, "failed to setup se3");
+#endif
 
         t = timeval_current();
         while (!finished) {
                 errno = 0;
-                if (event_loop_once(ev_ctx) == -1) {
+                if (tevent_loop_once(ev_ctx) == -1) {
                         talloc_free(ev_ctx);
                         torture_fail(test, talloc_asprintf(test, "Failed event loop %s\n", strerror(errno)));
@@ -120 +178 @@
         }
 
-        talloc_free(fde);
-        close(fd[1]);
+        talloc_free(fde_read_1);
+        talloc_free(fde_write_1);
+        talloc_free(fde_read);
+        talloc_free(fde_write);
 
         while (alarm_count < fde_count+1) {
-                if (event_loop_once(ev_ctx) == -1) {
+                if (tevent_loop_once(ev_ctx) == -1) {
                         break;
                 }
@@ -136 +196 @@
 
         torture_assert_int_equal(test, alarm_count, 1+fde_count, "alarm count mismatch");
+
+#ifdef SA_RESETHAND
+        /*
+         * we do not call talloc_free(se2)
+         * because it is already gone,
+         * after triggering the event handler.
+         */
+#endif
 
 #ifdef SA_SIGINFO
@@ -147 +215 @@
 }
 
+struct test_event_fd1_state {
+        struct torture_context *tctx;
+        const char *backend;
+        struct tevent_context *ev;
+        int sock[2];
+        struct tevent_timer *te;
+        struct tevent_fd *fde0;
+        struct tevent_fd *fde1;
+        bool got_write;
+        bool got_read;
+        bool drain;
+        bool drain_done;
+        unsigned loop_count;
+        bool finished;
+        const char *error;
+};
+
+static void test_event_fd1_fde_handler(struct tevent_context *ev_ctx,
+                                       struct tevent_fd *fde,
+                                       uint16_t flags,
+                                       void *private_data)
+{
+        struct test_event_fd1_state *state =
+                (struct test_event_fd1_state *)private_data;
+
+        if (state->drain_done) {
+                state->finished = true;
+                state->error = __location__;
+                return;
+        }
+
+        if (state->drain) {
+                ssize_t ret;
+                uint8_t c = 0;
+
+                if (!(flags & TEVENT_FD_READ)) {
+                        state->finished = true;
+                        state->error = __location__;
+                        return;
+                }
+
+                ret = read(state->sock[0], &c, 1);
+                if (ret == 1) {
+                        return;
+                }
+
+                /*
+                 * end of test...
+                 */
+                tevent_fd_set_flags(fde, 0);
+                state->drain_done = true;
+                return;
+        }
+
+        if (!state->got_write) {
+                uint8_t c = 0;
+
+                if (flags != TEVENT_FD_WRITE) {
+                        state->finished = true;
+                        state->error = __location__;
+                        return;
+                }
+                state->got_write = true;
+
+                /*
+                 * we write to the other socket...
+                 */
+                write(state->sock[1], &c, 1);
+                TEVENT_FD_NOT_WRITEABLE(fde);
+                TEVENT_FD_READABLE(fde);
+                return;
+        }
+
+        if (!state->got_read) {
+                if (flags != TEVENT_FD_READ) {
+                        state->finished = true;
+                        state->error = __location__;
+                        return;
+                }
+                state->got_read = true;
+
+                TEVENT_FD_NOT_READABLE(fde);
+                return;
+        }
+
+        state->finished = true;
+        state->error = __location__;
+        return;
+}
+
+static void test_event_fd1_finished(struct tevent_context *ev_ctx,
+                                    struct tevent_timer *te,
+                                    struct timeval tval,
+                                    void *private_data)
+{
+        struct test_event_fd1_state *state =
+                (struct test_event_fd1_state *)private_data;
+
+        if (state->drain_done) {
+                state->finished = true;
+                return;
+        }
+
+        if (!state->got_write) {
+                state->finished = true;
+                state->error = __location__;
+                return;
+        }
+
+        if (!state->got_read) {
+                state->finished = true;
+                state->error = __location__;
+                return;
+        }
+
+        state->loop_count++;
+        if (state->loop_count > 3) {
+                state->finished = true;
+                state->error = __location__;
+                return;
+        }
+
+        state->got_write = false;
+        state->got_read = false;
+
+        tevent_fd_set_flags(state->fde0, TEVENT_FD_WRITE);
+
+        if (state->loop_count > 2) {
+                state->drain = true;
+                TALLOC_FREE(state->fde1);
+                TEVENT_FD_READABLE(state->fde0);
+        }
+
+        state->te = tevent_add_timer(state->ev, state->ev,
+                                    timeval_current_ofs(0,2000),
+                                    test_event_fd1_finished, state);
+}
+
+static bool test_event_fd1(struct torture_context *tctx,
+                           const void *test_data)
+{
+        struct test_event_fd1_state state;
+
+        ZERO_STRUCT(state);
+        state.tctx = tctx;
+        state.backend = (const char *)test_data;
+
+        state.ev = tevent_context_init_byname(tctx, state.backend);
+        if (state.ev == NULL) {
+                torture_skip(tctx, talloc_asprintf(tctx,
+                             "event backend '%s' not supported\n",
+                             state.backend));
+                return true;
+        }
+
+        tevent_set_debug_stderr(state.ev);
+        torture_comment(tctx, "backend '%s' - %s\n",
+                        state.backend, __FUNCTION__);
+
+        /*
+         * This tests the following:
+         *
+         * It monitors the state of state.sock[0]
+         * with tevent_fd, but we never read/write on state.sock[0]
+         * while state.sock[1] * is only used to write a few bytes.
+         *
+         * We have a loop:
+         *   - we wait only for TEVENT_FD_WRITE on state.sock[0]
+         *   - we write 1 byte to state.sock[1]
+         *   - we wait only for TEVENT_FD_READ on state.sock[0]
+         *   - we disable events on state.sock[0]
+         *   - the timer event restarts the loop
+         * Then we close state.sock[1]
+         * We have a loop:
+         *   - we wait for TEVENT_FD_READ/WRITE on state.sock[0]
+         *   - we try to read 1 byte
+         *   - if the read gets an error of returns 0
+         *     we disable the event handler
+         *   - the timer finishes the test
+         */
+        state.sock[0] = -1;
+        state.sock[1] = -1;
+        socketpair(AF_UNIX, SOCK_STREAM, 0, state.sock);
+
+        state.te = tevent_add_timer(state.ev, state.ev,
+                                    timeval_current_ofs(0,1000),
+                                    test_event_fd1_finished, &state);
+        state.fde0 = tevent_add_fd(state.ev, state.ev,
+                                   state.sock[0], TEVENT_FD_WRITE,
+                                   test_event_fd1_fde_handler, &state);
+        /* state.fde1 is only used to auto close */
+        state.fde1 = tevent_add_fd(state.ev, state.ev,
+                                   state.sock[1], 0,
+                                   test_event_fd1_fde_handler, &state);
+
+        tevent_fd_set_auto_close(state.fde0);
+        tevent_fd_set_auto_close(state.fde1);
+
+        while (!state.finished) {
+                errno = 0;
+                if (tevent_loop_once(state.ev) == -1) {
+                        talloc_free(state.ev);
+                        torture_fail(tctx, talloc_asprintf(tctx,
+                                     "Failed event loop %s\n",
+                                     strerror(errno)));
+                }
+        }
+
+        talloc_free(state.ev);
+
+        torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
+                       "%s", state.error));
+
+        return true;
+}
+
+struct test_event_fd2_state {
+        struct torture_context *tctx;
+        const char *backend;
+        struct tevent_context *ev;
+        struct tevent_timer *te;
+        struct test_event_fd2_sock {
+                struct test_event_fd2_state *state;
+                int fd;
+                struct tevent_fd *fde;
+                size_t num_written;
+                size_t num_read;
+                bool got_full;
+        } sock0, sock1;
+        bool finished;
+        const char *error;
+};
+
+static void test_event_fd2_sock_handler(struct tevent_context *ev_ctx,
+                                        struct tevent_fd *fde,
+                                        uint16_t flags,
+                                        void *private_data)
+{
+        struct test_event_fd2_sock *cur_sock =
+                (struct test_event_fd2_sock *)private_data;
+        struct test_event_fd2_state *state = cur_sock->state;
+        struct test_event_fd2_sock *oth_sock = NULL;
+        uint8_t v = 0, c;
+        ssize_t ret;
+
+        if (cur_sock == &state->sock0) {
+                oth_sock = &state->sock1;
+        } else {
+                oth_sock = &state->sock0;
+        }
+
+        if (oth_sock->num_written == 1) {
+                if (flags != (TEVENT_FD_READ | TEVENT_FD_WRITE)) {
+                        state->finished = true;
+                        state->error = __location__;
+                        return;
+                }
+        }
+
+        if (cur_sock->num_read == oth_sock->num_written) {
+                state->finished = true;
+                state->error = __location__;
+                return;
+        }
+
+        if (!(flags & TEVENT_FD_READ)) {
+                state->finished = true;
+                state->error = __location__;
+                return;
+        }
+
+        if (oth_sock->num_read >= PIPE_BUF) {
+                /*
+                 * On Linux we become writable once we've read
+                 * one byte. On Solaris we only become writable
+                 * again once we've read 4096 bytes. PIPE_BUF
+                 * is probably a safe bet to test against.
+                 *
+                 * There should be room to write a byte again
+                 */
+                if (!(flags & TEVENT_FD_WRITE)) {
+                        state->finished = true;
+                        state->error = __location__;
+                        return;
+                }
+        }
+
+        if ((flags & TEVENT_FD_WRITE) && !cur_sock->got_full) {
+                v = (uint8_t)cur_sock->num_written;
+                ret = write(cur_sock->fd, &v, 1);
+                if (ret != 1) {
+                        state->finished = true;
+                        state->error = __location__;
+                        return;
+                }
+                cur_sock->num_written++;
+                if (cur_sock->num_written > 0x80000000) {
+                        state->finished = true;
+                        state->error = __location__;
+                        return;
+                }
+                return;
+        }
+
+        if (!cur_sock->got_full) {
+                cur_sock->got_full = true;
+
+                if (!oth_sock->got_full) {
+                        /*
+                         * cur_sock is full,
+                         * lets wait for oth_sock
+                         * to be filled
+                         */
+                        tevent_fd_set_flags(cur_sock->fde, 0);
+                        return;
+                }
+
+                /*
+                 * oth_sock waited for cur_sock,
+                 * lets restart it
+                 */
+                tevent_fd_set_flags(oth_sock->fde,
+                                    TEVENT_FD_READ|TEVENT_FD_WRITE);
+        }
+
+        ret = read(cur_sock->fd, &v, 1);
+        if (ret != 1) {
+                state->finished = true;
+                state->error = __location__;
+                return;
+        }
+        c = (uint8_t)cur_sock->num_read;
+        if (c != v) {
+                state->finished = true;
+                state->error = __location__;
+                return;
+        }
+        cur_sock->num_read++;
+
+        if (cur_sock->num_read < oth_sock->num_written) {
+                /* there is more to read */
+                return;
+        }
+        /*
+         * we read everything, we need to remove TEVENT_FD_WRITE
+         * to avoid spinning
+         */
+        TEVENT_FD_NOT_WRITEABLE(cur_sock->fde);
+
+        if (oth_sock->num_read == cur_sock->num_written) {
+                /*
+                 * both directions are finished
+                 */
+                state->finished = true;
+        }
+
+        return;
+}
+
+static void test_event_fd2_finished(struct tevent_context *ev_ctx,
+                                    struct tevent_timer *te,
+                                    struct timeval tval,
+                                    void *private_data)
+{
+        struct test_event_fd2_state *state =
+                (struct test_event_fd2_state *)private_data;
+
+        /*
+         * this should never be triggered
+         */
+        state->finished = true;
+        state->error = __location__;
+}
+
+static bool test_event_fd2(struct torture_context *tctx,
+                           const void *test_data)
+{
+        struct test_event_fd2_state state;
+        int sock[2];
+        uint8_t c = 0;
+
+        ZERO_STRUCT(state);
+        state.tctx = tctx;
+        state.backend = (const char *)test_data;
+
+        state.ev = tevent_context_init_byname(tctx, state.backend);
+        if (state.ev == NULL) {
+                torture_skip(tctx, talloc_asprintf(tctx,
+                             "event backend '%s' not supported\n",
+                             state.backend));
+                return true;
+        }
+
+        tevent_set_debug_stderr(state.ev);
+        torture_comment(tctx, "backend '%s' - %s\n",
+                        state.backend, __FUNCTION__);
+
+        /*
+         * This tests the following
+         *
+         * - We write 1 byte to each socket
+         * - We wait for TEVENT_FD_READ/WRITE on both sockets
+         * - When we get TEVENT_FD_WRITE we write 1 byte
+         *   until both socket buffers are full, which
+         *   means both sockets only get TEVENT_FD_READ.
+         * - Then we read 1 byte until we have consumed
+         *   all bytes the other end has written.
+         */
+        sock[0] = -1;
+        sock[1] = -1;
+        socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
+
+        /*
+         * the timer should never expire
+         */
+        state.te = tevent_add_timer(state.ev, state.ev,
+                                    timeval_current_ofs(600, 0),
+                                    test_event_fd2_finished, &state);
+        state.sock0.state = &state;
+        state.sock0.fd = sock[0];
+        state.sock0.fde = tevent_add_fd(state.ev, state.ev,
+                                        state.sock0.fd,
+                                        TEVENT_FD_READ | TEVENT_FD_WRITE,
+                                        test_event_fd2_sock_handler,
+                                        &state.sock0);
+        state.sock1.state = &state;
+        state.sock1.fd = sock[1];
+        state.sock1.fde = tevent_add_fd(state.ev, state.ev,
+                                        state.sock1.fd,
+                                        TEVENT_FD_READ | TEVENT_FD_WRITE,
+                                        test_event_fd2_sock_handler,
+                                        &state.sock1);
+
+        tevent_fd_set_auto_close(state.sock0.fde);
+        tevent_fd_set_auto_close(state.sock1.fde);
+
+        write(state.sock0.fd, &c, 1);
+        state.sock0.num_written++;
+        write(state.sock1.fd, &c, 1);
+        state.sock1.num_written++;
+
+        while (!state.finished) {
+                errno = 0;
+                if (tevent_loop_once(state.ev) == -1) {
+                        talloc_free(state.ev);
+                        torture_fail(tctx, talloc_asprintf(tctx,
+                                     "Failed event loop %s\n",
+                                     strerror(errno)));
+                }
+        }
+
+        talloc_free(state.ev);
+
+        torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
+                       "%s", state.error));
+
+        return true;
+}
+
+#ifdef HAVE_PTHREAD
+
+static pthread_mutex_t threaded_mutex = PTHREAD_MUTEX_INITIALIZER;
+static bool do_shutdown = false;
+
+static void test_event_threaded_lock(void)
+{
+        int ret;
+        ret = pthread_mutex_lock(&threaded_mutex);
+        assert(ret == 0);
+}
+
+static void test_event_threaded_unlock(void)
+{
+        int ret;
+        ret = pthread_mutex_unlock(&threaded_mutex);
+        assert(ret == 0);
+}
+
+static void test_event_threaded_trace(enum tevent_trace_point point,
+                                      void *private_data)
+{
+        switch (point) {
+        case TEVENT_TRACE_BEFORE_WAIT:
+                test_event_threaded_unlock();
+                break;
+        case TEVENT_TRACE_AFTER_WAIT:
+                test_event_threaded_lock();
+                break;
+        case TEVENT_TRACE_BEFORE_LOOP_ONCE:
+        case TEVENT_TRACE_AFTER_LOOP_ONCE:
+                break;
+        }
+}
+
+static void test_event_threaded_timer(struct tevent_context *ev,
+                                      struct tevent_timer *te,
+                                      struct timeval current_time,
+                                      void *private_data)
+{
+        return;
+}
+
+static void *test_event_poll_thread(void *private_data)
+{
+        struct tevent_context *ev = (struct tevent_context *)private_data;
+
+        test_event_threaded_lock();
+
+        while (true) {
+                int ret;
+                ret = tevent_loop_once(ev);
+                assert(ret == 0);
+                if (do_shutdown) {
+                        test_event_threaded_unlock();
+                        return NULL;
+                }
+        }
+
+}
+
+static void test_event_threaded_read_handler(struct tevent_context *ev,
+                                             struct tevent_fd *fde,
+                                             uint16_t flags,
+                                             void *private_data)
+{
+        int *pfd = (int *)private_data;
+        char c;
+        ssize_t nread;
+
+        if ((flags & TEVENT_FD_READ) == 0) {
+                return;
+        }
+
+        do {
+                nread = read(*pfd, &c, 1);
+        } while ((nread == -1) && (errno == EINTR));
+
+        assert(nread == 1);
+}
+
+static bool test_event_context_threaded(struct torture_context *test,
+                                        const void *test_data)
+{
+        struct tevent_context *ev;
+        struct tevent_timer *te;
+        struct tevent_fd *fde;
+        pthread_t poll_thread;
+        int fds[2];
+        int ret;
+        char c = 0;
+
+        ev = tevent_context_init_byname(test, "poll_mt");
+        torture_assert(test, ev != NULL, "poll_mt not supported");
+
+        tevent_set_trace_callback(ev, test_event_threaded_trace, NULL);
+
+        te = tevent_add_timer(ev, ev, timeval_current_ofs(5, 0),
+                              test_event_threaded_timer, NULL);
+        torture_assert(test, te != NULL, "Could not add timer");
+
+        ret = pthread_create(&poll_thread, NULL, test_event_poll_thread, ev);
+        torture_assert(test, ret == 0, "Could not create poll thread");
+
+        ret = pipe(fds);
+        torture_assert(test, ret == 0, "Could not create pipe");
+
+        poll(NULL, 0, 100);
+
+        test_event_threaded_lock();
+
+        fde = tevent_add_fd(ev, ev, fds[0], TEVENT_FD_READ,
+                            test_event_threaded_read_handler, &fds[0]);
+        torture_assert(test, fde != NULL, "Could not add fd event");
+
+        test_event_threaded_unlock();
+
+        poll(NULL, 0, 100);
+
+        write(fds[1], &c, 1);
+
+        poll(NULL, 0, 100);
+
+        test_event_threaded_lock();
+        do_shutdown = true;
+        test_event_threaded_unlock();
+
+        write(fds[1], &c, 1);
+
+        ret = pthread_join(poll_thread, NULL);
+        torture_assert(test, ret == 0, "pthread_join failed");
+
+        return true;
+}
+
+#define NUM_TEVENT_THREADS 100
+
+/* Ugly, but needed for torture_comment... */
+static struct torture_context *thread_test_ctx;
+static pthread_t thread_map[NUM_TEVENT_THREADS];
+static unsigned thread_counter;
+
+/* Called in master thread context */
+static void callback_nowait(struct tevent_context *ev,
+                                struct tevent_immediate *im,
+                                void *private_ptr)
+{
+        pthread_t *thread_id_ptr =
+                talloc_get_type_abort(private_ptr, pthread_t);
+        unsigned i;
+
+        for (i = 0; i < NUM_TEVENT_THREADS; i++) {
+                if (pthread_equal(*thread_id_ptr,
+                                thread_map[i])) {
+                        break;
+                }
+        }
+        torture_comment(thread_test_ctx,
+                        "Callback %u from thread %u\n",
+                        thread_counter,
+                        i);
+        thread_counter++;
+}
+
+/* Blast the master tevent_context with a callback, no waiting. */
+static void *thread_fn_nowait(void *private_ptr)
+{
+        struct tevent_thread_proxy *master_tp =
+                talloc_get_type_abort(private_ptr, struct tevent_thread_proxy);
+        struct tevent_immediate *im;
+        pthread_t *thread_id_ptr;
+
+        im = tevent_create_immediate(NULL);
+        if (im == NULL) {
+                return NULL;
+        }
+        thread_id_ptr = talloc(NULL, pthread_t);
+        if (thread_id_ptr == NULL) {
+                return NULL;
+        }
+        *thread_id_ptr = pthread_self();
+
+        tevent_thread_proxy_schedule(master_tp,
+                                &im,
+                                callback_nowait,
+                                &thread_id_ptr);
+        return NULL;
+}
+
+static void timeout_fn(struct tevent_context *ev,
+                        struct tevent_timer *te,
+                        struct timeval tv, void *p)
+{
+        thread_counter = NUM_TEVENT_THREADS * 10;
+}
+
+static bool test_multi_tevent_threaded(struct torture_context *test,
+                                        const void *test_data)
+{
+        unsigned i;
+        struct tevent_context *master_ev;
+        struct tevent_thread_proxy *tp;
+
+        talloc_disable_null_tracking();
+
+        /* Ugly global stuff. */
+        thread_test_ctx = test;
+        thread_counter = 0;
+
+        master_ev = tevent_context_init(NULL);
+        if (master_ev == NULL) {
+                return false;
+        }
+        tevent_set_debug_stderr(master_ev);
+
+        tp = tevent_thread_proxy_create(master_ev);
+        if (tp == NULL) {
+                torture_fail(test,
+                        talloc_asprintf(test,
+                                "tevent_thread_proxy_create failed\n"));
+                talloc_free(master_ev);
+                return false;
+        }
+
+        for (i = 0; i < NUM_TEVENT_THREADS; i++) {
+                int ret = pthread_create(&thread_map[i],
+                                NULL,
+                                thread_fn_nowait,
+                                tp);
+                if (ret != 0) {
+                        torture_fail(test,
+                                talloc_asprintf(test,
+                                        "Failed to create thread %i, %d\n",
+                                        i, ret));
+                        return false;
+                }
+        }
+
+        /* Ensure we don't wait more than 10 seconds. */
+        tevent_add_timer(master_ev,
+                        master_ev,
+                        timeval_current_ofs(10,0),
+                        timeout_fn,
+                        NULL);
+
+        while (thread_counter < NUM_TEVENT_THREADS) {
+                int ret = tevent_loop_once(master_ev);
+                torture_assert(test, ret == 0, "tevent_loop_once failed");
+        }
+
+        torture_assert(test, thread_counter == NUM_TEVENT_THREADS,
+                "thread_counter fail\n");
+
+        talloc_free(master_ev);
+        return true;
+}
+
+struct reply_state {
+        struct tevent_thread_proxy *reply_tp;
+        pthread_t thread_id;
+        int *p_finished;
+};
+
+static void thread_timeout_fn(struct tevent_context *ev,
+                        struct tevent_timer *te,
+                        struct timeval tv, void *p)
+{
+        int *p_finished = (int *)p;
+
+        *p_finished = 2;
+}
+
+/* Called in child-thread context */
+static void thread_callback(struct tevent_context *ev,
+                                struct tevent_immediate *im,
+                                void *private_ptr)
+{
+        struct reply_state *rsp =
+                talloc_get_type_abort(private_ptr, struct reply_state);
+
+        talloc_steal(ev, rsp);
+        *rsp->p_finished = 1;
+}
+
+/* Called in master thread context */
+static void master_callback(struct tevent_context *ev,
+                                struct tevent_immediate *im,
+                                void *private_ptr)
+{
+        struct reply_state *rsp =
+                talloc_get_type_abort(private_ptr, struct reply_state);
+        unsigned i;
+
+        talloc_steal(ev, rsp);
+
+        for (i = 0; i < NUM_TEVENT_THREADS; i++) {
+                if (pthread_equal(rsp->thread_id,
+                                thread_map[i])) {
+                        break;
+                }
+        }
+        torture_comment(thread_test_ctx,
+                        "Callback %u from thread %u\n",
+                        thread_counter,
+                        i);
+        /* Now reply to the thread ! */
+        tevent_thread_proxy_schedule(rsp->reply_tp,
+                                &im,
+                                thread_callback,
+                                &rsp);
+
+        thread_counter++;
+}
+
+static void *thread_fn_1(void *private_ptr)
+{
+        struct tevent_thread_proxy *master_tp =
+                talloc_get_type_abort(private_ptr, struct tevent_thread_proxy);
+        struct tevent_thread_proxy *tp;
+        struct tevent_immediate *im;
+        struct tevent_context *ev;
+        struct reply_state *rsp;
+        int finished = 0;
+        int ret;
+
+        ev = tevent_context_init(NULL);
+        if (ev == NULL) {
+                return NULL;
+        }
+
+        tp = tevent_thread_proxy_create(ev);
+        if (tp == NULL) {
+                talloc_free(ev);
+                return NULL;
+        }
+
+        im = tevent_create_immediate(ev);
+        if (im == NULL) {
+                talloc_free(ev);
+                return NULL;
+        }
+
+        rsp = talloc(ev, struct reply_state);
+        if (rsp == NULL) {
+                talloc_free(ev);
+                return NULL;
+        }
+
+        rsp->thread_id = pthread_self();
+        rsp->reply_tp = tp;
+        rsp->p_finished = &finished;
+
+        /* Introduce a little randomness into the mix.. */
+        usleep(random() % 7000);
+
+        tevent_thread_proxy_schedule(master_tp,
+                                &im,
+                                master_callback,
+                                &rsp);
+
+        /* Ensure we don't wait more than 10 seconds. */
+        tevent_add_timer(ev,
+                        ev,
+                        timeval_current_ofs(10,0),
+                        thread_timeout_fn,
+                        &finished);
+
+        while (finished == 0) {
+                ret = tevent_loop_once(ev);
+                assert(ret == 0);
+        }
+
+        if (finished > 1) {
+                /* Timeout ! */
+                abort();
+        }
+
+        /*
+         * NB. We should talloc_free(ev) here, but if we do
+         * we currently get hit by helgrind Fix #323432
+         * "When calling pthread_cond_destroy or pthread_mutex_destroy
+         * with initializers as argument Helgrind (incorrectly) reports errors."
+         *
+         * http://valgrind.10908.n7.nabble.com/Helgrind-3-9-0-false-positive-
+         * with-pthread-mutex-destroy-td47757.html
+         *
+         * Helgrind doesn't understand that the request/reply
+         * messages provide synchronization between the lock/unlock
+         * in tevent_thread_proxy_schedule(), and the pthread_destroy()
+         * when the struct tevent_thread_proxy object is talloc_free'd.
+         *
+         * As a work-around for now return ev for the parent thread to free.
+         */
+        return ev;
+}
+
+static bool test_multi_tevent_threaded_1(struct torture_context *test,
+                                        const void *test_data)
+{
+        unsigned i;
+        struct tevent_context *master_ev;
+        struct tevent_thread_proxy *master_tp;
+        int ret;
+
+        talloc_disable_null_tracking();
+
+        /* Ugly global stuff. */
+        thread_test_ctx = test;
+        thread_counter = 0;
+
+        master_ev = tevent_context_init(NULL);
+        if (master_ev == NULL) {
+                return false;
+        }
+        tevent_set_debug_stderr(master_ev);
+
+        master_tp = tevent_thread_proxy_create(master_ev);
+        if (master_tp == NULL) {
+                torture_fail(test,
+                        talloc_asprintf(test,
+                                "tevent_thread_proxy_create failed\n"));
+                talloc_free(master_ev);
+                return false;
+        }
+
+        for (i = 0; i < NUM_TEVENT_THREADS; i++) {
+                ret = pthread_create(&thread_map[i],
+                                NULL,
+                                thread_fn_1,
+                                master_tp);
+                if (ret != 0) {
+                        torture_fail(test,
+                                talloc_asprintf(test,
+                                        "Failed to create thread %i, %d\n",
+                                        i, ret));
+                                return false;
+                }
+        }
+
+        while (thread_counter < NUM_TEVENT_THREADS) {
+                ret = tevent_loop_once(master_ev);
+                torture_assert(test, ret == 0, "tevent_loop_once failed");
+        }
+
+        /* Wait for all the threads to finish - join 'em. */
+        for (i = 0; i < NUM_TEVENT_THREADS; i++) {
+                void *retval;
+                ret = pthread_join(thread_map[i], &retval);
+                torture_assert(test, ret == 0, "pthread_join failed");
+                /* Free the child thread event context. */
+                talloc_free(retval);
+        }
+
+        talloc_free(master_ev);
+        return true;
+}
+#endif
+
 struct torture_suite *torture_local_event(TALLOC_CTX *mem_ctx)
 {
         struct torture_suite *suite = torture_suite_create(mem_ctx, "event");
-        const char **list = event_backend_list(suite);
+        const char **list = tevent_backend_list(suite);
         int i;
 
         for (i=0;list && list[i];i++) {
-                torture_suite_add_simple_tcase_const(suite, list[i],
+                struct torture_suite *backend_suite;
+
+                backend_suite = torture_suite_create(mem_ctx, list[i]);
+
+                torture_suite_add_simple_tcase_const(backend_suite,
+                                               "context",
                                                test_event_context,
                                                (const void *)list[i]);
-        }
+                torture_suite_add_simple_tcase_const(backend_suite,
+                                               "fd1",
+                                               test_event_fd1,
+                                               (const void *)list[i]);
+                torture_suite_add_simple_tcase_const(backend_suite,
+                                               "fd2",
+                                               test_event_fd2,
+                                               (const void *)list[i]);
+
+                torture_suite_add_suite(suite, backend_suite);
+        }
+
+#ifdef HAVE_PTHREAD
+        torture_suite_add_simple_tcase_const(suite, "threaded_poll_mt",
+                                             test_event_context_threaded,
+                                             NULL);
+
+        torture_suite_add_simple_tcase_const(suite, "multi_tevent_threaded",
+                                             test_multi_tevent_threaded,
+                                             NULL);
+
+        torture_suite_add_simple_tcase_const(suite, "multi_tevent_threaded_1",
+                                             test_multi_tevent_threaded_1,
+                                             NULL);
+
+#endif
 
         return suite;

vendor/current/lib/tevent/tevent.c

@@ -113 +113 @@
 static void tevent_backend_init(void)
 {
+        static bool done;
+
+        if (done) {
+                return;
+        }
+
+        done = true;
+
         tevent_select_init();
         tevent_poll_init();
+        tevent_poll_mt_init();
+#if defined(HAVE_EPOLL)
+        tevent_epoll_init();
+#elif defined(HAVE_SOLARIS_PORTS)
+        tevent_port_init();
+#endif
+
         tevent_standard_init();
-#ifdef HAVE_EPOLL
-        tevent_epoll_init();
-#endif
+}
+
+_PRIVATE_ const struct tevent_ops *tevent_find_ops_byname(const char *name)
+{
+        struct tevent_ops_list *e;
+
+        tevent_backend_init();
+
+        if (name == NULL) {
+                name = tevent_default_backend;
+        }
+        if (name == NULL) {
+                name = "standard";
+        }
+
+        for (e = tevent_backends; e != NULL; e = e->next) {
+                if (0 == strcmp(e->name, name)) {
+                        return e->ops;
+                }
+        }
+
+        return NULL;
 }
 
@@ -160 +194 @@
         }
 
+        ev->last_zero_timer = NULL;
         for (te = ev->timer_events; te; te = tn) {
                 tn = te->next;
@@ -186 +221 @@
         }
 
+        /* removing nesting hook or we get an abort when nesting is
+         * not allowed. -- SSS
+         * Note that we need to leave the allowed flag at its current
+         * value, otherwise the use in tevent_re_initialise() will
+         * leave the event context with allowed forced to false, which
+         * will break users that expect nesting to be allowed
+         */
+        ev->nesting.level = 0;
+        ev->nesting.hook_fn = NULL;
+        ev->nesting.hook_private = NULL;
+
         return 0;
 }
@@ -200 +246 @@
   NOTE: use tevent_context_init() inside of samba!
 */
-static struct tevent_context *tevent_context_init_ops(TALLOC_CTX *mem_ctx,
-                                                      const struct tevent_ops *ops)
+struct tevent_context *tevent_context_init_ops(TALLOC_CTX *mem_ctx,
+                                               const struct tevent_ops *ops,
+                                               void *additional_data)
 {
         struct tevent_context *ev;
@@ -212 +259 @@
 
         ev->ops = ops;
+        ev->additional_data = additional_data;
 
         ret = ev->ops->context_init(ev);
@@ -230 +278 @@
                                                   const char *name)
 {
-        struct tevent_ops_list *e;
-
-        tevent_backend_init();
-
-        if (name == NULL) {
-                name = tevent_default_backend;
-        }
-        if (name == NULL) {
-                name = "standard";
-        }
-
-        for (e=tevent_backends;e;e=e->next) {
-                if (strcmp(name, e->name) == 0) {
-                        return tevent_context_init_ops(mem_ctx, e->ops);
-                }
-        }
-        return NULL;
+        const struct tevent_ops *ops;
+
+        ops = tevent_find_ops_byname(name);
+        if (ops == NULL) {
+                return NULL;
+        }
+
+        return tevent_context_init_ops(mem_ctx, ops, NULL);
 }
 
@@ -392 +431 @@
 /*
   schedule an immediate event
-  return NULL on failure
 */
 void _tevent_schedule_immediate(struct tevent_immediate *im,
@@ -492 +530 @@
         }
 
+        tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_LOOP_ONCE);
         ret = ev->ops->loop_once(ev, location);
+        tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_LOOP_ONCE);
 
         if (ev->nesting.level > 0) {
@@ -552 +592 @@
 
         while (!finished(private_data)) {
+                tevent_trace_point_callback(ev, TEVENT_TRACE_BEFORE_LOOP_ONCE);
                 ret = ev->ops->loop_once(ev, location);
+                tevent_trace_point_callback(ev, TEVENT_TRACE_AFTER_LOOP_ONCE);
                 if (ret != 0) {
                         break;

vendor/current/lib/tevent/tevent.h

@@ -40 +40 @@
 struct tevent_immediate;
 struct tevent_signal;
+struct tevent_thread_proxy;
 
 /**
@@ -112 +113 @@
 
 /**
- * @brief Create a event_context structure and name it.
+ * @brief Create a event_context structure and select a specific backend.
  *
  * This must be the first events call, and all subsequent calls pass this
@@ -120 +121 @@
  * @param[in]  mem_ctx  The memory context to use.
  *
- * @param[in]  name     The name for the tevent context.
+ * @param[in]  name     The name of the backend to use.
  *
  * @return              An allocated tevent context, NULL on error.
  */
 struct tevent_context *tevent_context_init_byname(TALLOC_CTX *mem_ctx, const char *name);
+
+/**
+ * @brief Create a custom event context
+ *
+ * @param[in]  mem_ctx  The memory context to use.
+ * @param[in]  ops      The function pointer table of the backend.
+ * @param[in]  additional_data  The additional/private data to this instance
+ *
+ * @return              An allocated tevent context, NULL on error.
+ *
+ */
+struct tevent_context *tevent_context_init_ops(TALLOC_CTX *mem_ctx,
+                                               const struct tevent_ops *ops,
+                                               void *additional_data);
 
 /**
@@ -137 +152 @@
 
 /**
- * @brief Set the default tevent backent.
+ * @brief Set the default tevent backend.
  *
  * @param[in]  backend  The name of the backend to set.
@@ -163 +178 @@
  * @note To cancel the monitoring of a file descriptor, call talloc_free()
  * on the object returned by this function.
+ *
+ * @note The caller should avoid closing the file descriptor before
+ * calling talloc_free()! Otherwise the behaviour is undefined which
+ * might result in crashes. See https://bugzilla.samba.org/show_bug.cgi?id=11141
+ * for an example.
  */
 struct tevent_fd *tevent_add_fd(struct tevent_context *ev,
@@ -306 +326 @@
  * @note To cancel a signal handler, call talloc_free() on the event returned
  * from this function.
+ *
+ * @see tevent_num_signals, tevent_sa_info_queue_count
  */
 struct tevent_signal *tevent_add_signal(struct tevent_context *ev,
@@ -327 +349 @@
 #endif
 
+/**
+ * @brief the number of supported signals
+ *
+ * This returns value of the configure time TEVENT_NUM_SIGNALS constant.
+ *
+ * The 'signum' argument of tevent_add_signal() must be less than
+ * TEVENT_NUM_SIGNALS.
+ *
+ * @see tevent_add_signal
+ */
+size_t tevent_num_signals(void);
+
+/**
+ * @brief the number of pending realtime signals
+ *
+ * This returns value of TEVENT_SA_INFO_QUEUE_COUNT.
+ *
+ * The tevent internals remember the last TEVENT_SA_INFO_QUEUE_COUNT
+ * siginfo_t structures for SA_SIGINFO signals. If the system generates
+ * more some signals get lost.
+ *
+ * @see tevent_add_signal
+ */
+size_t tevent_sa_info_queue_count(void);
+
 #ifdef DOXYGEN
 /**
@@ -502 +549 @@
 int tevent_set_debug_stderr(struct tevent_context *ev);
 
+enum tevent_trace_point {
+        /**
+         * Corresponds to a trace point just before waiting
+         */
+        TEVENT_TRACE_BEFORE_WAIT,
+        /**
+         * Corresponds to a trace point just after waiting
+         */
+        TEVENT_TRACE_AFTER_WAIT,
+#define TEVENT_HAS_LOOP_ONCE_TRACE_POINTS 1
+        /**
+         * Corresponds to a trace point just before calling
+         * the loop_once() backend function.
+         */
+        TEVENT_TRACE_BEFORE_LOOP_ONCE,
+        /**
+         * Corresponds to a trace point right after the
+         * loop_once() backend function has returned.
+         */
+        TEVENT_TRACE_AFTER_LOOP_ONCE,
+};
+
+typedef void (*tevent_trace_callback_t)(enum tevent_trace_point,
+                                        void *private_data);
+
+/**
+ * Register a callback to be called at certain trace points
+ *
+ * @param[in] ev             Event context
+ * @param[in] cb             Trace callback
+ * @param[in] private_data   Data to be passed to callback
+ *
+ * @note The callback will be called at trace points defined by
+ * tevent_trace_point.  Call with NULL to reset.
+ */
+void tevent_set_trace_callback(struct tevent_context *ev,
+                               tevent_trace_callback_t cb,
+                               void *private_data);
+
+/**
+ * Retrieve the current trace callback
+ *
+ * @param[in] ev             Event context
+ * @param[out] cb            Registered trace callback
+ * @param[out] private_data  Registered data to be passed to callback
+ *
+ * @note This can be used to allow one component that wants to
+ * register a callback to respect the callback that another component
+ * has already registered.
+ */
+void tevent_get_trace_callback(struct tevent_context *ev,
+                               tevent_trace_callback_t *cb,
+                               void *private_data);
+
 /**
  * @}
@@ -517 +618 @@
  * are considered too low-level to be used in larger computations. To
  * read and write from and to sockets, Samba provides two calls on top
- * of tevent_add_fd: read_packet_send/recv and writev_send/recv. These
- * requests are much easier to compose than the low-level event
+ * of tevent_add_fd: tstream_read_packet_send/recv and tstream_writev_send/recv.
+ * These requests are much easier to compose than the low-level event
  * handlers called from tevent_add_fd.
  *
@@ -840 +941 @@
 #endif
 
+/**
+ * @brief A typedef for a cleanup function for a tevent request.
+ *
+ * @param[in]  req       The tevent request calling this function.
+ *
+ * @param[in]  req_state The current tevent_req_state.
+ *
+ */
+typedef void (*tevent_req_cleanup_fn)(struct tevent_req *req,
+                                      enum tevent_req_state req_state);
+
+/**
+ * @brief This function sets a cleanup function for the given tevent request.
+ *
+ * This function can be used to setup a cleanup function for the given request.
+ * This will be triggered when the tevent_req_done() or tevent_req_error()
+ * function was called, before notifying the callers callback function,
+ * and also before scheduling the deferred trigger.
+ *
+ * This might be useful if more than one tevent_req belong together
+ * and need to finish both requests at the same time.
+ *
+ * The cleanup function is able to call tevent_req_done() or tevent_req_error()
+ * recursively, the cleanup function is only triggered the first time.
+ *
+ * The cleanup function is also called by tevent_req_received()
+ * (possibly triggered from tevent_req_destructor()) before destroying
+ * the private data of the tevent_req.
+ *
+ * @param[in]  req      The request to use.
+ *
+ * @param[in]  fn       A pointer to the cancel function.
+ */
+void tevent_req_set_cleanup_fn(struct tevent_req *req, tevent_req_cleanup_fn fn);
+
 #ifdef DOXYGEN
 /**
@@ -852 +988 @@
  * @endcode
  *
- * Tevent_req_create() creates the state variable as a talloc child of
- * its result. The state variable should be used as the talloc parent
- * for all temporary variables that are allocated during the async
+ * Tevent_req_create() allocates and zeros the state variable as a talloc
+ * child of its result. The state variable should be used as the talloc
+ * parent for all temporary variables that are allocated during the async
  * computation. This way, when the user of the async computation frees
  * the request, the state as a talloc child will be free'd along with
@@ -996 +1132 @@
 #endif
 
+#ifdef DOXYGEN
+/**
+ * @brief Indicate out of memory to a request
+ *
+ * @param[in]  req      The request being processed.
+ */
+void tevent_req_oom(struct tevent_req *req);
+#else
+void _tevent_req_oom(struct tevent_req *req,
+                     const char *location);
+#define tevent_req_oom(req) \
+        _tevent_req_oom(req, __location__)
+#endif
+
 /**
  * @brief Finish a request before the caller had the change to set the callback.
@@ -1003 +1153 @@
  * the engine. To present the illusion of a callback to the user of the API,
  * the implementation can call this helper function which triggers an
- * immediate timed event. This way the caller can use the same calling
+ * immediate event. This way the caller can use the same calling
  * conventions, independent of whether the request was actually deferred.
  *
@@ -1027 +1177 @@
  * @param[in]  req      The finished request.
  *
- * @param[in]  ev       The tevent_context for the timed event.
+ * @param[in]  ev       The tevent_context for the immediate event.
  *
  * @return              The given request will be returned.
@@ -1033 +1183 @@
 struct tevent_req *tevent_req_post(struct tevent_req *req,
                                    struct tevent_context *ev);
+
+/**
+ * @brief Finish multiple requests within one function
+ *
+ * Normally tevent_req_notify_callback() and all wrappers
+ * (e.g. tevent_req_done() and tevent_req_error())
+ * need to be the last thing an event handler should call.
+ * This is because the callback is likely to destroy the
+ * context of the current function.
+ *
+ * If a function wants to notify more than one caller,
+ * it is dangerous if it just triggers multiple callbacks
+ * in a row. With tevent_req_defer_callback() it is possible
+ * to set an event context that will be used to defer the callback
+ * via an immediate event (similar to tevent_req_post()).
+ *
+ * @code
+ * struct complete_state {
+ *       struct tevent_context *ev;
+ *
+ *       struct tevent_req **reqs;
+ * };
+ *
+ * void complete(struct complete_state *state)
+ * {
+ *       size_t i, c = talloc_array_length(state->reqs);
+ *
+ *       for (i=0; i < c; i++) {
+ *            tevent_req_defer_callback(state->reqs[i], state->ev);
+ *            tevent_req_done(state->reqs[i]);
+ *       }
+ * }
+ * @endcode
+ *
+ * @param[in]  req      The finished request.
+ *
+ * @param[in]  ev       The tevent_context for the immediate event.
+ *
+ * @return              The given request will be returned.
+ */
+void tevent_req_defer_callback(struct tevent_req *req,
+                               struct tevent_context *ev);
 
 /**
@@ -1219 +1411 @@
  * @param[in]  secs     The seconds to set.
  *
- * @param[in]  usecs    The milliseconds to set.
+ * @param[in]  usecs    The microseconds to set.
  *
  * @return              A timeval structure with the given values.
@@ -1254 +1446 @@
  * @param[in]  secs      The seconds to add to the timeval.
  *
- * @param[in]  usecs     The milliseconds to add to the timeval.
+ * @param[in]  usecs     The microseconds to add to the timeval.
  *
  * @return               The timeval structure with the new time.
@@ -1266 +1458 @@
  * @param[in]  secs     The seconds of the offset from now.
  *
- * @param[in]  usecs    The milliseconds of the offset from now.
+ * @param[in]  usecs    The microseconds of the offset from now.
  *
  * @return              A timval with the given offset in the future.
@@ -1292 +1484 @@
 
 struct tevent_queue;
+struct tevent_queue_entry;
 
 #ifdef DOXYGEN
@@ -1303 +1496 @@
  * @return              An allocated tevent queue on success, NULL on error.
  *
- * @see tevent_start()
- * @see tevent_stop()
+ * @see tevent_queue_start()
+ * @see tevent_queue_stop()
  */
 struct tevent_queue *tevent_queue_create(TALLOC_CTX *mem_ctx,
@@ -1326 +1519 @@
  *
  * @see tevent_queue_add()
+ * @see tevent_queue_add_entry()
+ * @see tevent_queue_add_optimize_empty()
  */
 typedef void (*tevent_queue_trigger_fn_t)(struct tevent_req *req,
@@ -1340 +1535 @@
  *
  * @param[in]  trigger  The function triggered by the queue when the request
- *                      is called.
+ *                      is called. Since tevent 0.9.14 it's possible to
+ *                      pass NULL, in order to just add a "blocker" to the
+ *                      queue.
  *
  * @param[in]  private_data The private data passed to the trigger function.
@@ -1354 +1551 @@
 
 /**
+ * @brief Add a tevent request to the queue.
+ *
+ * The request can be removed from the queue by calling talloc_free()
+ * (or a similar function) on the returned queue entry. This
+ * is the only difference to tevent_queue_add().
+ *
+ * @param[in]  queue    The queue to add the request.
+ *
+ * @param[in]  ev       The event handle to use for the request.
+ *
+ * @param[in]  req      The tevent request to add to the queue.
+ *
+ * @param[in]  trigger  The function triggered by the queue when the request
+ *                      is called. Since tevent 0.9.14 it's possible to
+ *                      pass NULL, in order to just add a "blocker" to the
+ *                      queue.
+ *
+ * @param[in]  private_data The private data passed to the trigger function.
+ *
+ * @return              a pointer to the tevent_queue_entry if the request
+ *                      has been successfully added, NULL otherwise.
+ *
+ * @see tevent_queue_add()
+ * @see tevent_queue_add_optimize_empty()
+ */
+struct tevent_queue_entry *tevent_queue_add_entry(
+                                        struct tevent_queue *queue,
+                                        struct tevent_context *ev,
+                                        struct tevent_req *req,
+                                        tevent_queue_trigger_fn_t trigger,
+                                        void *private_data);
+
+/**
+ * @brief Add a tevent request to the queue using a possible optimization.
+ *
+ * This tries to optimize for the empty queue case and may calls
+ * the trigger function directly. This is the only difference compared
+ * to tevent_queue_add_entry().
+ *
+ * The caller needs to be prepared that the trigger function has
+ * already called tevent_req_notify_callback(), tevent_req_error(),
+ * tevent_req_done() or a similar function.
+ *
+ * The request can be removed from the queue by calling talloc_free()
+ * (or a similar function) on the returned queue entry.
+ *
+ * @param[in]  queue    The queue to add the request.
+ *
+ * @param[in]  ev       The event handle to use for the request.
+ *
+ * @param[in]  req      The tevent request to add to the queue.
+ *
+ * @param[in]  trigger  The function triggered by the queue when the request
+ *                      is called. Since tevent 0.9.14 it's possible to
+ *                      pass NULL, in order to just add a "blocker" to the
+ *                      queue.
+ *
+ * @param[in]  private_data The private data passed to the trigger function.
+ *
+ * @return              a pointer to the tevent_queue_entry if the request
+ *                      has been successfully added, NULL otherwise.
+ *
+ * @see tevent_queue_add()
+ * @see tevent_queue_add_entry()
+ */
+struct tevent_queue_entry *tevent_queue_add_optimize_empty(
+                                        struct tevent_queue *queue,
+                                        struct tevent_context *ev,
+                                        struct tevent_req *req,
+                                        tevent_queue_trigger_fn_t trigger,
+                                        void *private_data);
+
+/**
  * @brief Start a tevent queue.
  *
@@ -1379 +1649 @@
  */
 size_t tevent_queue_length(struct tevent_queue *queue);
+
+/**
+ * @brief Is the tevent queue running.
+ *
+ * The queue is started by default.
+ *
+ * @param[in]  queue    The queue.
+ *
+ * @return              Wether the queue is running or not..
+ */
+bool tevent_queue_running(struct tevent_queue *queue);
+
+/**
+ * @brief Create a tevent subrequest that waits in a tevent_queue
+ *
+ * The idea is that always the same syntax for tevent requests.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The event handle to setup the request.
+ *
+ * @param[in]  queue    The queue to wait in.
+ *
+ * @return              The new subrequest, NULL on error.
+ *
+ * @see tevent_queue_wait_recv()
+ */
+struct tevent_req *tevent_queue_wait_send(TALLOC_CTX *mem_ctx,
+                                          struct tevent_context *ev,
+                                          struct tevent_queue *queue);
+
+/**
+ * @brief Check if we no longer need to wait in the queue.
+ *
+ * This function needs to be called in the callback function set after calling
+ * tevent_queue_wait_send().
+ *
+ * @param[in]  req      The tevent request to check.
+ *
+ * @return              True on success, false otherwise.
+ *
+ * @see tevent_queue_wait_send()
+ */
+bool tevent_queue_wait_recv(struct tevent_req *req);
 
 typedef int (*tevent_nesting_hook)(struct tevent_context *ev,
@@ -1386 +1700 @@
                                    void *stack_ptr,
                                    const char *location);
+
+/**
+ * @brief Create a tevent_thread_proxy for message passing between threads.
+ *
+ * The tevent_context must have been allocated on the NULL
+ * talloc context, and talloc_disable_null_tracking() must
+ * have been called.
+ *
+ * @param[in]  dest_ev_ctx      The tevent_context to receive events.
+ *
+ * @return              An allocated tevent_thread_proxy, NULL on error.
+ *                      If tevent was compiled without PTHREAD support
+ *                      NULL is always returned and errno set to ENOSYS.
+ *
+ * @see tevent_thread_proxy_schedule()
+ */
+struct tevent_thread_proxy *tevent_thread_proxy_create(
+                struct tevent_context *dest_ev_ctx);
+
+/**
+ * @brief Schedule an immediate event on an event context from another thread.
+ *
+ * Causes dest_ev_ctx, being run by another thread, to receive an
+ * immediate event calling the handler with the *pp_private parameter.
+ *
+ * *pp_im must be a pointer to an immediate event talloced on a context owned
+ * by the calling thread, or the NULL context. Ownership will
+ * be transferred to the tevent_thread_proxy and *pp_im will be returned as NULL.
+ *
+ * *pp_private_data must be a talloced area of memory with no destructors.
+ * Ownership of this memory will be transferred to the tevent library and
+ * *pp_private_data will be set to NULL on successful completion of
+ * the call. Set pp_private to NULL if no parameter transfer
+ * needed (a pure callback). This is an asynchronous request, caller
+ * does not wait for callback to be completed before returning.
+ *
+ * @param[in]  tp               The tevent_thread_proxy to use.
+ *
+ * @param[in]  pp_im            Pointer to immediate event pointer.
+ *
+ * @param[in]  handler          The function that will be called.
+ *
+ * @param[in]  pp_private_data  The talloced memory to transfer.
+ *
+ * @see tevent_thread_proxy_create()
+ */
+void tevent_thread_proxy_schedule(struct tevent_thread_proxy *tp,
+                                  struct tevent_immediate **pp_im,
+                                  tevent_immediate_handler_t handler,
+                                  void *pp_private_data);
+
 #ifdef TEVENT_DEPRECATED
 #ifndef _DEPRECATED_

vendor/current/lib/tevent/tevent.pc.in

@@ -8 +8 @@
 Version: @PACKAGE_VERSION@
 Requires: talloc
-Libs: -L${libdir} -ltevent
-Cflags: @LIB_RPATH@ -I${includedir}
+Libs: @LIB_RPATH@ -L${libdir} -ltevent
+Cflags: -I${includedir}
 URL: http://samba.org/

vendor/current/lib/tevent/tevent_debug.c

@@ -95 +95 @@
 }
 
+void tevent_set_trace_callback(struct tevent_context *ev,
+                               tevent_trace_callback_t cb,
+                               void *private_data)
+{
+        ev->tracing.callback = cb;
+        ev->tracing.private_data = private_data;
+}
+
+void tevent_get_trace_callback(struct tevent_context *ev,
+                               tevent_trace_callback_t *cb,
+                               void *private_data)
+{
+        *cb = ev->tracing.callback;
+        *(void**)private_data = ev->tracing.private_data;
+}
+
+void tevent_trace_point_callback(struct tevent_context *ev,
+                                 enum tevent_trace_point tp)
+{
+        if (ev->tracing.callback != NULL) {
+                ev->tracing.callback(tp, ev->tracing.private_data);
+        }
+}

vendor/current/lib/tevent/tevent_epoll.c

@@ -5 +5 @@
 
    Copyright (C) Andrew Tridgell        2003-2005
-   Copyright (C) Stefan Metzmacher      2005-2009
+   Copyright (C) Stefan Metzmacher      2005-2013
+   Copyright (C) Jeremy Allison         2013
 
      ** NOTE! The following LGPL license applies to the tevent
@@ -40 +41 @@
 
         pid_t pid;
+
+        bool panic_force_replay;
+        bool *panic_state;
+        bool (*panic_fallback)(struct tevent_context *ev, bool replay);
 };
 
+#define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT      (1<<0)
+#define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR   (1<<1)
+#define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR      (1<<2)
+#define EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX        (1<<3)
+
+#ifdef TEST_PANIC_FALLBACK
+
+static int epoll_create_panic_fallback(struct epoll_event_context *epoll_ev,
+                                       int size)
+{
+        if (epoll_ev->panic_fallback == NULL) {
+                return epoll_create(size);
+        }
+
+        /* 50% of the time, fail... */
+        if ((random() % 2) == 0) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        return epoll_create(size);
+}
+
+static int epoll_ctl_panic_fallback(struct epoll_event_context *epoll_ev,
+                                    int epfd, int op, int fd,
+                                    struct epoll_event *event)
+{
+        if (epoll_ev->panic_fallback == NULL) {
+                return epoll_ctl(epfd, op, fd, event);
+        }
+
+        /* 50% of the time, fail... */
+        if ((random() % 2) == 0) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        return epoll_ctl(epfd, op, fd, event);
+}
+
+static int epoll_wait_panic_fallback(struct epoll_event_context *epoll_ev,
+                                     int epfd,
+                                     struct epoll_event *events,
+                                     int maxevents,
+                                     int timeout)
+{
+        if (epoll_ev->panic_fallback == NULL) {
+                return epoll_wait(epfd, events, maxevents, timeout);
+        }
+
+        /* 50% of the time, fail... */
+        if ((random() % 2) == 0) {
+                errno = EINVAL;
+                return -1;
+        }
+
+        return epoll_wait(epfd, events, maxevents, timeout);
+}
+
+#define epoll_create(_size) \
+        epoll_create_panic_fallback(epoll_ev, _size)
+#define epoll_ctl(_epfd, _op, _fd, _event) \
+        epoll_ctl_panic_fallback(epoll_ev,_epfd, _op, _fd, _event)
+#define epoll_wait(_epfd, _events, _maxevents, _timeout) \
+        epoll_wait_panic_fallback(epoll_ev, _epfd, _events, _maxevents, _timeout)
+#endif
+
+/*
+  called to set the panic fallback function.
+*/
+_PRIVATE_ void tevent_epoll_set_panic_fallback(struct tevent_context *ev,
+                                bool (*panic_fallback)(struct tevent_context *ev,
+                                                       bool replay))
+{
+        struct epoll_event_context *epoll_ev =
+                talloc_get_type_abort(ev->additional_data,
+                struct epoll_event_context);
+
+        epoll_ev->panic_fallback = panic_fallback;
+}
+
 /*
   called when a epoll call fails
 */
-static void epoll_panic(struct epoll_event_context *epoll_ev, const char *reason)
-{
-        tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
-                 "%s (%s) - calling abort()\n", reason, strerror(errno));
-        abort();
+static void epoll_panic(struct epoll_event_context *epoll_ev,
+                        const char *reason, bool replay)
+{
+        struct tevent_context *ev = epoll_ev->ev;
+        bool (*panic_fallback)(struct tevent_context *ev, bool replay);
+
+        panic_fallback = epoll_ev->panic_fallback;
+
+        if (epoll_ev->panic_state != NULL) {
+                *epoll_ev->panic_state = true;
+        }
+
+        if (epoll_ev->panic_force_replay) {
+                replay = true;
+        }
+
+        TALLOC_FREE(ev->additional_data);
+
+        if (panic_fallback == NULL) {
+                tevent_debug(ev, TEVENT_DEBUG_FATAL,
+                        "%s (%s) replay[%u] - calling abort()\n",
+                        reason, strerror(errno), (unsigned)replay);
+                abort();
+        }
+
+        tevent_debug(ev, TEVENT_DEBUG_ERROR,
+                     "%s (%s) replay[%u] - calling panic_fallback\n",
+                     reason, strerror(errno), (unsigned)replay);
+
+        if (!panic_fallback(ev, replay)) {
+                /* Fallback failed. */
+                tevent_debug(ev, TEVENT_DEBUG_FATAL,
+                        "%s (%s) replay[%u] - calling abort()\n",
+                        reason, strerror(errno), (unsigned)replay);
+                abort();
+        }
 }
 
@@ -79 +196 @@
 {
         epoll_ev->epoll_fd = epoll_create(64);
+        if (epoll_ev->epoll_fd == -1) {
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
+                             "Failed to create epoll handle.\n");
+                return -1;
+        }
+
+        if (!ev_set_close_on_exec(epoll_ev->epoll_fd)) {
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
+                             "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
+        }
+
         epoll_ev->pid = getpid();
         talloc_set_destructor(epoll_ev, epoll_ctx_destructor);
-        if (epoll_ev->epoll_fd == -1) {
-                return -1;
-        }
+
         return 0;
 }
 
-static void epoll_add_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde);
+static void epoll_update_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde);
 
 /*
   reopen the epoll handle when our pid changes
-  see http://junkcode.samba.org/ftp/unpacked/junkcode/epoll_fork.c for an 
+  see http://junkcode.samba.org/ftp/unpacked/junkcode/epoll_fork.c for an
   demonstration of why this is needed
  */
@@ -97 +223 @@
 {
         struct tevent_fd *fde;
+        bool *caller_panic_state = epoll_ev->panic_state;
+        bool panic_triggered = false;
 
         if (epoll_ev->pid == getpid()) {
@@ -105 +233 @@
         epoll_ev->epoll_fd = epoll_create(64);
         if (epoll_ev->epoll_fd == -1) {
+                epoll_panic(epoll_ev, "epoll_create() failed", false);
+                return;
+        }
+
+        if (!ev_set_close_on_exec(epoll_ev->epoll_fd)) {
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
+                             "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
+        }
+
+        epoll_ev->pid = getpid();
+        epoll_ev->panic_state = &panic_triggered;
+        for (fde=epoll_ev->ev->fd_events;fde;fde=fde->next) {
+                fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+                epoll_update_event(epoll_ev, fde);
+
+                if (panic_triggered) {
+                        if (caller_panic_state != NULL) {
+                                *caller_panic_state = true;
+                        }
+                        return;
+                }
+        }
+        epoll_ev->panic_state = NULL;
+}
+
+/*
+ epoll cannot add the same file descriptor twice, once
+ with read, once with write which is allowed by the
+ tevent backend. Multiplex the existing fde, flag it
+ as such so we can search for the correct fde on
+ event triggering.
+*/
+
+static int epoll_add_multiplex_fd(struct epoll_event_context *epoll_ev,
+                                  struct tevent_fd *add_fde)
+{
+        struct epoll_event event;
+        struct tevent_fd *mpx_fde;
+        int ret;
+
+        /* Find the existing fde that caused the EEXIST error. */
+        for (mpx_fde = epoll_ev->ev->fd_events; mpx_fde; mpx_fde = mpx_fde->next) {
+                if (mpx_fde->fd != add_fde->fd) {
+                        continue;
+                }
+
+                if (mpx_fde == add_fde) {
+                        continue;
+                }
+
+                break;
+        }
+        if (mpx_fde == NULL) {
                 tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
-                             "Failed to recreate epoll handle after fork\n");
-                return;
-        }
-        epoll_ev->pid = getpid();
-        for (fde=epoll_ev->ev->fd_events;fde;fde=fde->next) {
-                epoll_add_event(epoll_ev, fde);
-        }
-}
-
-#define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT      (1<<0)
-#define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR   (1<<1)
-#define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR      (1<<2)
+                             "can't find multiplex fde for fd[%d]",
+                             add_fde->fd);
+                return -1;
+        }
+
+        if (mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
+                /* Logic error. Can't have more than 2 multiplexed fde's. */
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
+                             "multiplex fde for fd[%d] is already multiplexed\n",
+                             mpx_fde->fd);
+                return -1;
+        }
+
+        /*
+         * The multiplex fde must have the same fd, and also
+         * already have an epoll event attached.
+         */
+        if (!(mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) {
+                /* Logic error. Can't have more than 2 multiplexed fde's. */
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
+                             "multiplex fde for fd[%d] has no event\n",
+                             mpx_fde->fd);
+                return -1;
+        }
+
+        /* Modify the mpx_fde to add in the new flags. */
+        ZERO_STRUCT(event);
+        event.events = epoll_map_flags(mpx_fde->flags);
+        event.events |= epoll_map_flags(add_fde->flags);
+        event.data.ptr = mpx_fde;
+        ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_MOD, mpx_fde->fd, &event);
+        if (ret != 0 && errno == EBADF) {
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
+                             "EPOLL_CTL_MOD EBADF for "
+                             "add_fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
+                             add_fde, mpx_fde, add_fde->fd);
+                DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
+                mpx_fde->event_ctx = NULL;
+                DLIST_REMOVE(epoll_ev->ev->fd_events, add_fde);
+                add_fde->event_ctx = NULL;
+                return 0;
+        } else if (ret != 0) {
+                return ret;
+        }
+
+        /*
+         * Make each fde->additional_data pointers point at each other
+         * so we can look them up from each other. They are now paired.
+         */
+        mpx_fde->additional_data = (struct tevent_fd *)add_fde;
+        add_fde->additional_data = (struct tevent_fd *)mpx_fde;
+
+        /* Now flag both fde's as being multiplexed. */
+        mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
+        add_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
+
+        /* we need to keep the GOT_ERROR flag */
+        if (mpx_fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR) {
+                add_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
+        }
+
+        return 0;
+}
 
 /*
@@ -125 +357 @@
 {
         struct epoll_event event;
-
-        if (epoll_ev->epoll_fd == -1) return;
-
+        int ret;
+        struct tevent_fd *mpx_fde = NULL;
+
+        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 
-        /* if we don't want events yet, don't add an epoll_event */
-        if (fde->flags == 0) return;
+        if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
+                /*
+                 * This is a multiplexed fde, we need to include both
+                 * flags in the modified event.
+                 */
+                mpx_fde = talloc_get_type_abort(fde->additional_data,
+                                                struct tevent_fd);
+
+                mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+                mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+        }
 
         ZERO_STRUCT(event);
         event.events = epoll_map_flags(fde->flags);
+        if (mpx_fde != NULL) {
+                event.events |= epoll_map_flags(mpx_fde->flags);
+        }
         event.data.ptr = fde;
-        if (epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event) != 0) {
-                epoll_panic(epoll_ev, "EPOLL_CTL_ADD failed");
-        }
+        ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event);
+        if (ret != 0 && errno == EBADF) {
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
+                             "EPOLL_CTL_ADD EBADF for "
+                             "fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
+                             fde, mpx_fde, fde->fd);
+                DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
+                fde->event_ctx = NULL;
+                if (mpx_fde != NULL) {
+                        DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
+                        mpx_fde->event_ctx = NULL;
+                }
+                return;
+        } else if (ret != 0 && errno == EEXIST && mpx_fde == NULL) {
+                ret = epoll_add_multiplex_fd(epoll_ev, fde);
+                if (ret != 0) {
+                        epoll_panic(epoll_ev, "epoll_add_multiplex_fd failed",
+                                    false);
+                        return;
+                }
+        } else if (ret != 0) {
+                epoll_panic(epoll_ev, "EPOLL_CTL_ADD failed", false);
+                return;
+        }
+
         fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
-
         /* only if we want to read we want to tell the event handler about errors */
         if (fde->flags & TEVENT_FD_READ) {
                 fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
         }
+
+        if (mpx_fde == NULL) {
+                return;
+        }
+
+        mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+        /* only if we want to read we want to tell the event handler about errors */
+        if (mpx_fde->flags & TEVENT_FD_READ) {
+                mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+        }
 }
 
@@ -153 +429 @@
 {
         struct epoll_event event;
-
-        if (epoll_ev->epoll_fd == -1) return;
-
+        int ret;
+        struct tevent_fd *mpx_fde = NULL;
+
+        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
 
-        /* if there's no epoll_event, we don't need to delete it */
-        if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) return;
+        if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
+                /*
+                 * This is a multiplexed fde, we need to modify both events.
+                 */
+                mpx_fde = talloc_get_type_abort(fde->additional_data,
+                                                struct tevent_fd);
+
+                mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+                mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+        }
+
+        ZERO_STRUCT(event);
+        ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
+        if (ret != 0 && errno == ENOENT) {
+                /*
+                 * This can happen after a epoll_check_reopen
+                 * within epoll_event_fd_destructor.
+                 */
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_TRACE,
+                             "EPOLL_CTL_DEL ignoring ENOENT for fd[%d]\n",
+                             fde->fd);
+                return;
+        } else if (ret != 0 && errno == EBADF) {
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_WARNING,
+                             "EPOLL_CTL_DEL EBADF for "
+                             "fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
+                             fde, mpx_fde, fde->fd);
+                DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
+                fde->event_ctx = NULL;
+                if (mpx_fde != NULL) {
+                        DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
+                        mpx_fde->event_ctx = NULL;
+                }
+                return;
+        } else if (ret != 0) {
+                epoll_panic(epoll_ev, "EPOLL_CTL_DEL failed", false);
+                return;
+        }
+}
+
+/*
+ change the epoll event to the given fd_event
+*/
+static void epoll_mod_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
+{
+        struct tevent_fd *mpx_fde = NULL;
+        struct epoll_event event;
+        int ret;
+
+        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+
+        if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
+                /*
+                 * This is a multiplexed fde, we need to include both
+                 * flags in the modified event.
+                 */
+                mpx_fde = talloc_get_type_abort(fde->additional_data,
+                                                struct tevent_fd);
+
+                mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+                mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+        }
 
         ZERO_STRUCT(event);
         event.events = epoll_map_flags(fde->flags);
+        if (mpx_fde != NULL) {
+                event.events |= epoll_map_flags(mpx_fde->flags);
+        }
         event.data.ptr = fde;
-        if (epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event) != 0) {
-                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_FATAL,
-                             "epoll_del_event failed! probable early close bug (%s)\n",
-                             strerror(errno));
-        }
-        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
-}
-
-/*
- change the epoll event to the given fd_event
-*/
-static void epoll_mod_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
-{
-        struct epoll_event event;
-        if (epoll_ev->epoll_fd == -1) return;
-
-        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
-
-        ZERO_STRUCT(event);
-        event.events = epoll_map_flags(fde->flags);
-        event.data.ptr = fde;
-        if (epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
-                epoll_panic(epoll_ev, "EPOLL_CTL_MOD failed");
-        }
-
+        ret = epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event);
+        if (ret != 0 && errno == EBADF) {
+                tevent_debug(epoll_ev->ev, TEVENT_DEBUG_ERROR,
+                             "EPOLL_CTL_MOD EBADF for "
+                             "fde[%p] mpx_fde[%p] fd[%d] - disabling\n",
+                             fde, mpx_fde, fde->fd);
+                DLIST_REMOVE(epoll_ev->ev->fd_events, fde);
+                fde->event_ctx = NULL;
+                if (mpx_fde != NULL) {
+                        DLIST_REMOVE(epoll_ev->ev->fd_events, mpx_fde);
+                        mpx_fde->event_ctx = NULL;
+                }
+                return;
+        } else if (ret != 0) {
+                epoll_panic(epoll_ev, "EPOLL_CTL_MOD failed", false);
+                return;
+        }
+
+        fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
         /* only if we want to read we want to tell the event handler about errors */
         if (fde->flags & TEVENT_FD_READ) {
                 fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
         }
-}
-
-static void epoll_change_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
+
+        if (mpx_fde == NULL) {
+                return;
+        }
+
+        mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+        /* only if we want to read we want to tell the event handler about errors */
+        if (mpx_fde->flags & TEVENT_FD_READ) {
+                mpx_fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+        }
+}
+
+static void epoll_update_event(struct epoll_event_context *epoll_ev, struct tevent_fd *fde)
 {
         bool got_error = (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
         bool want_read = (fde->flags & TEVENT_FD_READ);
         bool want_write= (fde->flags & TEVENT_FD_WRITE);
-
-        if (epoll_ev->epoll_fd == -1) return;
-
-        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
+        struct tevent_fd *mpx_fde = NULL;
+
+        if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
+                /*
+                 * work out what the multiplexed fde wants.
+                 */
+                mpx_fde = talloc_get_type_abort(fde->additional_data,
+                                                struct tevent_fd);
+
+                if (mpx_fde->flags & TEVENT_FD_READ) {
+                        want_read = true;
+                }
+
+                if (mpx_fde->flags & TEVENT_FD_WRITE) {
+                        want_write = true;
+                }
+        }
 
         /* there's already an event */
@@ -229 +587 @@
 
 /*
+  Cope with epoll returning EPOLLHUP|EPOLLERR on an event.
+  Return true if there's nothing else to do, false if
+  this event needs further handling.
+*/
+static bool epoll_handle_hup_or_err(struct epoll_event_context *epoll_ev,
+                                struct tevent_fd *fde)
+{
+        if (fde == NULL) {
+                /* Nothing to do if no event. */
+                return true;
+        }
+
+        fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
+        /*
+         * if we only wait for TEVENT_FD_WRITE, we should not tell the
+         * event handler about it, and remove the epoll_event,
+         * as we only report errors when waiting for read events,
+         * to match the select() behavior
+         */
+        if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
+                /*
+                 * Do the same as the poll backend and
+                 * remove the writeable flag.
+                 */
+                fde->flags &= ~TEVENT_FD_WRITE;
+                return true;
+        }
+        /* This has TEVENT_FD_READ set, we're not finished. */
+        return false;
+}
+
+/*
   event loop handling using epoll
 */
@@ -237 +627 @@
         struct epoll_event events[MAXEVENTS];
         int timeout = -1;
-
-        if (epoll_ev->epoll_fd == -1) return -1;
+        int wait_errno;
 
         if (tvalp) {
-                /* it's better to trigger timed events a bit later than to early */
+                /* it's better to trigger timed events a bit later than too early */
                 timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
         }
@@ -250 +639 @@
         }
 
+        tevent_trace_point_callback(epoll_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
         ret = epoll_wait(epoll_ev->epoll_fd, events, MAXEVENTS, timeout);
-
-        if (ret == -1 && errno == EINTR && epoll_ev->ev->signal_events) {
+        wait_errno = errno;
+        tevent_trace_point_callback(epoll_ev->ev, TEVENT_TRACE_AFTER_WAIT);
+
+        if (ret == -1 && wait_errno == EINTR && epoll_ev->ev->signal_events) {
                 if (tevent_common_check_signal(epoll_ev->ev)) {
                         return 0;
@@ -258 +650 @@
         }
 
-        if (ret == -1 && errno != EINTR) {
-                epoll_panic(epoll_ev, "epoll_wait() failed");
+        if (ret == -1 && wait_errno != EINTR) {
+                epoll_panic(epoll_ev, "epoll_wait() failed", true);
                 return -1;
         }
@@ -270 +662 @@
 
         for (i=0;i<ret;i++) {
-                struct tevent_fd *fde = talloc_get_type(events[i].data.ptr, 
+                struct tevent_fd *fde = talloc_get_type(events[i].data.ptr,
                                                        struct tevent_fd);
                 uint16_t flags = 0;
+                struct tevent_fd *mpx_fde = NULL;
 
                 if (fde == NULL) {
-                        epoll_panic(epoll_ev, "epoll_wait() gave bad data");
+                        epoll_panic(epoll_ev, "epoll_wait() gave bad data", true);
                         return -1;
                 }
+                if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
+                        /*
+                         * Save off the multiplexed event in case we need
+                         * to use it to call the handler function.
+                         */
+                        mpx_fde = talloc_get_type_abort(fde->additional_data,
+                                                        struct tevent_fd);
+                }
                 if (events[i].events & (EPOLLHUP|EPOLLERR)) {
-                        fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
-                        /*
-                         * if we only wait for TEVENT_FD_WRITE, we should not tell the
-                         * event handler about it, and remove the epoll_event,
-                         * as we only report errors when waiting for read events,
-                         * to match the select() behavior
-                         */
-                        if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
-                                epoll_del_event(epoll_ev, fde);
+                        bool handled_fde = epoll_handle_hup_or_err(epoll_ev, fde);
+                        bool handled_mpx = epoll_handle_hup_or_err(epoll_ev, mpx_fde);
+
+                        if (handled_fde && handled_mpx) {
+                                epoll_update_event(epoll_ev, fde);
                                 continue;
                         }
+
+                        if (!handled_mpx) {
+                                /*
+                                 * If the mpx event was the one that needs
+                                 * further handling, it's the TEVENT_FD_READ
+                                 * event so switch over and call that handler.
+                                 */
+                                fde = mpx_fde;
+                                mpx_fde = NULL;
+                        }
                         flags |= TEVENT_FD_READ;
                 }
                 if (events[i].events & EPOLLIN) flags |= TEVENT_FD_READ;
                 if (events[i].events & EPOLLOUT) flags |= TEVENT_FD_WRITE;
+
+                if (flags & TEVENT_FD_WRITE) {
+                        if (fde->flags & TEVENT_FD_WRITE) {
+                                mpx_fde = NULL;
+                        }
+                        if (mpx_fde && mpx_fde->flags & TEVENT_FD_WRITE) {
+                                fde = mpx_fde;
+                                mpx_fde = NULL;
+                        }
+                }
+
+                if (mpx_fde) {
+                        /* Ensure we got the right fde. */
+                        if ((flags & fde->flags) == 0) {
+                                fde = mpx_fde;
+                                mpx_fde = NULL;
+                        }
+                }
+
+                /*
+                 * make sure we only pass the flags
+                 * the handler is expecting.
+                 */
+                flags &= fde->flags;
                 if (flags) {
                         fde->handler(epoll_ev->ev, fde, flags, fde->private_data);
@@ -310 +741 @@
         int ret;
         struct epoll_event_context *epoll_ev;
+
+        /*
+         * We might be called during tevent_re_initialise()
+         * which means we need to free our old additional_data.
+         */
+        TALLOC_FREE(ev->additional_data);
 
         epoll_ev = talloc_zero(ev, struct epoll_event_context);
@@ -333 +770 @@
         struct tevent_context *ev = fde->event_ctx;
         struct epoll_event_context *epoll_ev = NULL;
-
-        if (ev) {
-                epoll_ev = talloc_get_type(ev->additional_data,
-                                           struct epoll_event_context);
-
-                epoll_check_reopen(epoll_ev);
-
-                epoll_del_event(epoll_ev, fde);
-        }
+        bool panic_triggered = false;
+        struct tevent_fd *mpx_fde = NULL;
+        int flags = fde->flags;
+
+        if (ev == NULL) {
+                return tevent_common_fd_destructor(fde);
+        }
+
+        epoll_ev = talloc_get_type_abort(ev->additional_data,
+                                         struct epoll_event_context);
+
+        /*
+         * we must remove the event from the list
+         * otherwise a panic fallback handler may
+         * reuse invalid memory
+         */
+        DLIST_REMOVE(ev->fd_events, fde);
+
+        if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX) {
+                mpx_fde = talloc_get_type_abort(fde->additional_data,
+                                                struct tevent_fd);
+
+                fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
+                mpx_fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_MPX;
+
+                fde->additional_data = NULL;
+                mpx_fde->additional_data = NULL;
+
+                fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
+        }
+
+        epoll_ev->panic_state = &panic_triggered;
+        epoll_check_reopen(epoll_ev);
+        if (panic_triggered) {
+                return tevent_common_fd_destructor(fde);
+        }
+
+        if (mpx_fde != NULL) {
+                epoll_update_event(epoll_ev, mpx_fde);
+                if (panic_triggered) {
+                        return tevent_common_fd_destructor(fde);
+                }
+        }
+
+        fde->flags = 0;
+        epoll_update_event(epoll_ev, fde);
+        fde->flags = flags;
+        if (panic_triggered) {
+                return tevent_common_fd_destructor(fde);
+        }
+        epoll_ev->panic_state = NULL;
 
         return tevent_common_fd_destructor(fde);
@@ -357 +836 @@
                                             const char *location)
 {
-        struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
-                                                           struct epoll_event_context);
+        struct epoll_event_context *epoll_ev =
+                talloc_get_type_abort(ev->additional_data,
+                struct epoll_event_context);
         struct tevent_fd *fde;
-
-        epoll_check_reopen(epoll_ev);
+        bool panic_triggered = false;
 
         fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
@@ -370 +849 @@
         talloc_set_destructor(fde, epoll_event_fd_destructor);
 
-        epoll_add_event(epoll_ev, fde);
+        epoll_ev->panic_state = &panic_triggered;
+        epoll_check_reopen(epoll_ev);
+        if (panic_triggered) {
+                return fde;
+        }
+        epoll_ev->panic_state = NULL;
+
+        epoll_update_event(epoll_ev, fde);
 
         return fde;
@@ -382 +868 @@
         struct tevent_context *ev;
         struct epoll_event_context *epoll_ev;
+        bool panic_triggered = false;
 
         if (fde->flags == flags) return;
 
         ev = fde->event_ctx;
-        epoll_ev = talloc_get_type(ev->additional_data, struct epoll_event_context);
+        epoll_ev = talloc_get_type_abort(ev->additional_data,
+                                         struct epoll_event_context);
 
         fde->flags = flags;
 
+        epoll_ev->panic_state = &panic_triggered;
         epoll_check_reopen(epoll_ev);
-
-        epoll_change_event(epoll_ev, fde);
-}
-
-/*
-  do a single event loop using the events defined in ev 
+        if (panic_triggered) {
+                return;
+        }
+        epoll_ev->panic_state = NULL;
+
+        epoll_update_event(epoll_ev, fde);
+}
+
+/*
+  do a single event loop using the events defined in ev
 */
 static int epoll_event_loop_once(struct tevent_context *ev, const char *location)
 {
-        struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
-                                                           struct epoll_event_context);
+        struct epoll_event_context *epoll_ev =
+                talloc_get_type_abort(ev->additional_data,
+                struct epoll_event_context);
         struct timeval tval;
+        bool panic_triggered = false;
 
         if (ev->signal_events &&
@@ -419 +914 @@
         }
 
+        epoll_ev->panic_state = &panic_triggered;
+        epoll_ev->panic_force_replay = true;
         epoll_check_reopen(epoll_ev);
+        if (panic_triggered) {
+                errno = EINVAL;
+                return -1;
+        }
+        epoll_ev->panic_force_replay = false;
+        epoll_ev->panic_state = NULL;
 
         return epoll_event_loop(epoll_ev, &tval);
@@ -430 +933 @@
         .get_fd_flags           = tevent_common_fd_get_flags,
         .set_fd_flags           = epoll_event_set_fd_flags,
-        .add_timer              = tevent_common_add_timer,
+        .add_timer              = tevent_common_add_timer_v2,
         .schedule_immediate     = tevent_common_schedule_immediate,
         .add_signal             = tevent_common_add_signal,

vendor/current/lib/tevent/tevent_immediate.c

@@ -89 +89 @@
         im->additional_data     = NULL;
 
-        DLIST_ADD_END(ev->immediate_events, im, struct tevent_immediate *);
+        DLIST_ADD_END(ev->immediate_events, im);
         talloc_set_destructor(im, tevent_common_immediate_destructor);
 

vendor/current/lib/tevent/tevent_internal.h

@@ -75 +75 @@
 
         /**
+         * @brief A function to cleanup the request
+         *
+         * The implementation might want to set a function
+         * that is called before the tevent_req_done() and tevent_req_error()
+         * trigger the callers callback function.
+         */
+        struct {
+                tevent_req_cleanup_fn fn;
+                enum tevent_req_state state;
+        } private_cleanup;
+
+        /**
          * @brief Internal state of the request
          *
@@ -141 +153 @@
                  */
                 struct tevent_immediate *trigger;
+
+                /**
+                 * @brief An event context which will be used to
+                 *        defer the _tevent_req_notify_callback().
+                 */
+                struct tevent_context *defer_callback_ev;
 
                 /**
@@ -253 +271 @@
                 void *hook_private;
         } nesting;
-};
-
+
+        struct {
+                tevent_trace_callback_t callback;
+                void *private_data;
+        } tracing;
+
+        /*
+         * an optimization pointer into timer_events
+         * used by used by common code via
+         * tevent_common_add_timer_v2()
+         */
+        struct tevent_timer *last_zero_timer;
+};
+
+const struct tevent_ops *tevent_find_ops_byname(const char *name);
 
 int tevent_common_context_destructor(struct tevent_context *ev);
@@ -281 +312 @@
                                              const char *handler_name,
                                              const char *location);
+struct tevent_timer *tevent_common_add_timer_v2(struct tevent_context *ev,
+                                                TALLOC_CTX *mem_ctx,
+                                                struct timeval next_event,
+                                                tevent_timer_handler_t handler,
+                                                void *private_data,
+                                                const char *handler_name,
+                                                const char *location);
 struct timeval tevent_common_loop_timer_delay(struct tevent_context *);
 
@@ -305 +343 @@
 bool tevent_select_init(void);
 bool tevent_poll_init(void);
+void tevent_poll_event_add_fd_internal(struct tevent_context *ev,
+                                       struct tevent_fd *fde);
+bool tevent_poll_mt_init(void);
 #ifdef HAVE_EPOLL
 bool tevent_epoll_init(void);
+void tevent_epoll_set_panic_fallback(struct tevent_context *ev,
+                        bool (*panic_fallback)(struct tevent_context *ev,
+                                               bool replay));
 #endif
+#ifdef HAVE_SOLARIS_PORTS
+bool tevent_port_init(void);
+#endif
+
+
+void tevent_trace_point_callback(struct tevent_context *ev,
+                                 enum tevent_trace_point);

vendor/current/lib/tevent/tevent_liboop.c

@@ -2 +2 @@
    Unix SMB/CIFS implementation.
    main select loop and event handling
-   wrapper for http://liboop.org/
+   wrapper for http://git.lysator.liu.se/liboop/
 
    Copyright (C) Stefan Metzmacher 2005

vendor/current/lib/tevent/tevent_poll.c

@@ -31 +31 @@
 
 struct poll_event_context {
+        /* a pointer back to the generic event_context */
+        struct tevent_context *ev;
+
+        /*
+         * A DLIST for fresh fde's added by poll_event_add_fd but not
+         * picked up yet by poll_event_loop_once
+         */
+        struct tevent_fd *fresh;
+        /*
+         * A DLIST for disabled fde's.
+         */
+        struct tevent_fd *disabled;
+        /*
+         * one or more events were deleted or disabled
+         */
+        bool deleted;
+
         /*
          * These two arrays are maintained together.
          */
         struct pollfd *fds;
-        struct tevent_fd **fd_events;
-        uint64_t num_fds;
-
-        /* information for exiting from the event loop */
-        int exit_code;
+        struct tevent_fd **fdes;
+        unsigned num_fds;
+
+        /*
+         * Signal fd to wake the poll() thread
+         */
+        int signal_fd;
 };
 
+static int poll_event_context_destructor(struct poll_event_context *poll_ev)
+{
+        struct tevent_fd *fd, *fn;
+
+        for (fd = poll_ev->fresh; fd; fd = fn) {
+                fn = fd->next;
+                fd->event_ctx = NULL;
+                DLIST_REMOVE(poll_ev->fresh, fd);
+        }
+
+        for (fd = poll_ev->disabled; fd; fd = fn) {
+                fn = fd->next;
+                fd->event_ctx = NULL;
+                DLIST_REMOVE(poll_ev->disabled, fd);
+        }
+
+        if (poll_ev->signal_fd == -1) {
+                /*
+                 * Non-threaded, no signal pipe
+                 */
+                return 0;
+        }
+
+        close(poll_ev->signal_fd);
+        poll_ev->signal_fd = -1;
+
+        if (poll_ev->num_fds == 0) {
+                return 0;
+        }
+        if (poll_ev->fds[0].fd != -1) {
+                close(poll_ev->fds[0].fd);
+                poll_ev->fds[0].fd = -1;
+        }
+        return 0;
+}
+
 /*
-  create a select_event_context structure.
+  create a poll_event_context structure.
 */
 static int poll_event_context_init(struct tevent_context *ev)
 {
         struct poll_event_context *poll_ev;
+
+        /*
+         * we might be called during tevent_re_initialise()
+         * which means we need to free our old additional_data
+         * in order to detach old fd events from the
+         * poll_ev->fresh list
+         */
+        TALLOC_FREE(ev->additional_data);
 
         poll_ev = talloc_zero(ev, struct poll_event_context);
@@ -53 +116 @@
                 return -1;
         }
+        poll_ev->ev = ev;
+        poll_ev->signal_fd = -1;
         ev->additional_data = poll_ev;
+        talloc_set_destructor(poll_ev, poll_event_context_destructor);
         return 0;
+}
+
+static bool set_nonblock(int fd)
+{
+        int val;
+
+        val = fcntl(fd, F_GETFL, 0);
+        if (val == -1) {
+                return false;
+        }
+        val |= O_NONBLOCK;
+
+        return (fcntl(fd, F_SETFL, val) != -1);
+}
+
+static int poll_event_context_init_mt(struct tevent_context *ev)
+{
+        struct poll_event_context *poll_ev;
+        struct pollfd *pfd;
+        int fds[2];
+        int ret;
+
+        ret = poll_event_context_init(ev);
+        if (ret == -1) {
+                return ret;
+        }
+
+        poll_ev = talloc_get_type_abort(
+                ev->additional_data, struct poll_event_context);
+
+        poll_ev->fds = talloc_zero(poll_ev, struct pollfd);
+        if (poll_ev->fds == NULL) {
+                return -1;
+        }
+
+        ret = pipe(fds);
+        if (ret == -1) {
+                return -1;
+        }
+
+        if (!set_nonblock(fds[0]) || !set_nonblock(fds[1])) {
+                close(fds[0]);
+                close(fds[1]);
+                return -1;
+        }
+
+        poll_ev->signal_fd = fds[1];
+
+        pfd = &poll_ev->fds[0];
+        pfd->fd = fds[0];
+        pfd->events = (POLLIN|POLLHUP);
+
+        poll_ev->num_fds = 1;
+
+        talloc_set_destructor(poll_ev, poll_event_context_destructor);
+
+        return 0;
+}
+
+static void poll_event_wake_pollthread(struct poll_event_context *poll_ev)
+{
+        char c;
+        ssize_t ret;
+
+        if (poll_ev->signal_fd == -1) {
+                return;
+        }
+        c = 0;
+        do {
+                ret = write(poll_ev->signal_fd, &c, sizeof(c));
+        } while ((ret == -1) && (errno == EINTR));
+}
+
+static void poll_event_drain_signal_fd(struct poll_event_context *poll_ev)
+{
+        char buf[16];
+        ssize_t ret;
+        int fd;
+
+        if (poll_ev->signal_fd == -1) {
+                return;
+        }
+
+        if (poll_ev->num_fds < 1) {
+                return;
+        }
+        fd = poll_ev->fds[0].fd;
+
+        do {
+                ret = read(fd, buf, sizeof(buf));
+        } while (ret == sizeof(buf));
 }
 
@@ -63 +220 @@
 {
         struct tevent_context *ev = fde->event_ctx;
-        struct poll_event_context *poll_ev = NULL;
-        struct tevent_fd *moved_fde;
+        struct poll_event_context *poll_ev;
         uint64_t del_idx = fde->additional_flags;
 
@@ -74 +230 @@
                 ev->additional_data, struct poll_event_context);
 
-        moved_fde = poll_ev->fd_events[poll_ev->num_fds-1];
-        poll_ev->fd_events[del_idx] = moved_fde;
-        poll_ev->fds[del_idx] = poll_ev->fds[poll_ev->num_fds-1];
-        moved_fde->additional_flags = del_idx;
-
-        poll_ev->num_fds -= 1;
+        if (del_idx == UINT64_MAX) {
+                struct tevent_fd **listp =
+                        (struct tevent_fd **)fde->additional_data;
+
+                DLIST_REMOVE((*listp), fde);
+                goto done;
+        }
+
+        poll_ev->fdes[del_idx] = NULL;
+        poll_ev->deleted = true;
+        poll_event_wake_pollthread(poll_ev);
 done:
         return tevent_common_fd_destructor(fde);
+}
+
+static void poll_event_schedule_immediate(struct tevent_immediate *im,
+                                          struct tevent_context *ev,
+                                          tevent_immediate_handler_t handler,
+                                          void *private_data,
+                                          const char *handler_name,
+                                          const char *location)
+{
+        struct poll_event_context *poll_ev = talloc_get_type_abort(
+                ev->additional_data, struct poll_event_context);
+
+        tevent_common_schedule_immediate(im, ev, handler, private_data,
+                                         handler_name, location);
+        poll_event_wake_pollthread(poll_ev);
+}
+
+/*
+  Private function called by "standard" backend fallback.
+  Note this only allows fallback to "poll" backend, not "poll-mt".
+*/
+_PRIVATE_ void tevent_poll_event_add_fd_internal(struct tevent_context *ev,
+                                                 struct tevent_fd *fde)
+{
+        struct poll_event_context *poll_ev = talloc_get_type_abort(
+                ev->additional_data, struct poll_event_context);
+        struct tevent_fd **listp;
+
+        if (fde->flags != 0) {
+                listp = &poll_ev->fresh;
+        } else {
+                listp = &poll_ev->disabled;
+        }
+
+        fde->additional_flags   = UINT64_MAX;
+        fde->additional_data    = listp;
+
+        DLIST_ADD((*listp), fde);
+        talloc_set_destructor(fde, poll_event_fd_destructor);
 }
 
@@ -98 +298 @@
         struct poll_event_context *poll_ev = talloc_get_type_abort(
                 ev->additional_data, struct poll_event_context);
-        struct pollfd *pfd;
         struct tevent_fd *fde;
 
-        fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
-                                   handler, private_data,
-                                   handler_name, location);
+        if (fd < 0) {
+                return NULL;
+        }
+
+        fde = talloc(mem_ctx ? mem_ctx : ev, struct tevent_fd);
         if (fde == NULL) {
                 return NULL;
         }
-
-        /* we allocate 16 slots to avoid a lot of reallocations */
-        if (talloc_array_length(poll_ev->fds) == poll_ev->num_fds) {
-                struct pollfd *tmp_fds;
-                struct tevent_fd **tmp_fd_events;
-                tmp_fds = talloc_realloc(
-                        poll_ev, poll_ev->fds, struct pollfd,
-                        poll_ev->num_fds + 16);
-                if (tmp_fds == NULL) {
-                        TALLOC_FREE(fde);
-                        return NULL;
-                }
-                poll_ev->fds = tmp_fds;
-
-                tmp_fd_events = talloc_realloc(
-                        poll_ev, poll_ev->fd_events, struct tevent_fd *,
-                        poll_ev->num_fds + 16);
-                if (tmp_fd_events == NULL) {
-                        TALLOC_FREE(fde);
-                        return NULL;
-                }
-                poll_ev->fd_events = tmp_fd_events;
-        }
-
-        pfd = &poll_ev->fds[poll_ev->num_fds];
-
-        pfd->fd = fd;
-
-        pfd->events = 0;
-        pfd->revents = 0;
-
-        if (flags & TEVENT_FD_READ) {
-                pfd->events |= (POLLIN|POLLHUP);
-        }
-        if (flags & TEVENT_FD_WRITE) {
-                pfd->events |= (POLLOUT);
-        }
-
-        fde->additional_flags = poll_ev->num_fds;
-        poll_ev->fd_events[poll_ev->num_fds] = fde;
-
-        poll_ev->num_fds += 1;
-
-        talloc_set_destructor(fde, poll_event_fd_destructor);
-
+        fde->event_ctx          = ev;
+        fde->fd                 = fd;
+        fde->flags              = flags;
+        fde->handler            = handler;
+        fde->close_fn           = NULL;
+        fde->private_data       = private_data;
+        fde->handler_name       = handler_name;
+        fde->location           = location;
+        fde->additional_flags   = UINT64_MAX;
+        fde->additional_data    = NULL;
+
+        tevent_poll_event_add_fd_internal(ev, fde);
+        poll_event_wake_pollthread(poll_ev);
+
+        /*
+         * poll_event_loop_poll will take care of the rest in
+         * poll_event_setup_fresh
+         */
         return fde;
 }
@@ -160 +334 @@
 static void poll_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
 {
-        struct poll_event_context *poll_ev = talloc_get_type_abort(
-                fde->event_ctx->additional_data, struct poll_event_context);
+        struct tevent_context *ev = fde->event_ctx;
+        struct poll_event_context *poll_ev;
         uint64_t idx = fde->additional_flags;
-        uint16_t pollflags = 0;
+        uint16_t pollflags;
+
+        if (ev == NULL) {
+                return;
+        }
+        poll_ev = talloc_get_type_abort(
+                ev->additional_data, struct poll_event_context);
+
+        fde->flags = flags;
+
+        if (idx == UINT64_MAX) {
+                struct tevent_fd **listp =
+                        (struct tevent_fd **)fde->additional_data;
+
+                /*
+                 * We move it between the fresh and disabled lists.
+                 */
+                DLIST_REMOVE((*listp), fde);
+                tevent_poll_event_add_fd_internal(ev, fde);
+                poll_event_wake_pollthread(poll_ev);
+                return;
+        }
+
+        if (fde->flags == 0) {
+                /*
+                 * We need to remove it from the array
+                 * and move it to the disabled list.
+                 */
+                poll_ev->fdes[idx] = NULL;
+                poll_ev->deleted = true;
+                DLIST_REMOVE(ev->fd_events, fde);
+                tevent_poll_event_add_fd_internal(ev, fde);
+                poll_event_wake_pollthread(poll_ev);
+                return;
+        }
+
+        pollflags = 0;
 
         if (flags & TEVENT_FD_READ) {
@@ -171 +381 @@
                 pollflags |= (POLLOUT);
         }
-
         poll_ev->fds[idx].events = pollflags;
 
-        fde->flags = flags;
+        poll_event_wake_pollthread(poll_ev);
+}
+
+static bool poll_event_setup_fresh(struct tevent_context *ev,
+                                   struct poll_event_context *poll_ev)
+{
+        struct tevent_fd *fde, *next;
+        unsigned num_fresh, num_fds;
+
+        if (poll_ev->deleted) {
+                unsigned first_fd = (poll_ev->signal_fd != -1) ? 1 : 0;
+                unsigned i;
+
+                for (i=first_fd; i < poll_ev->num_fds;) {
+                        fde = poll_ev->fdes[i];
+                        if (fde != NULL) {
+                                i++;
+                                continue;
+                        }
+
+                        /*
+                         * This fde was talloc_free()'ed. Delete it
+                         * from the arrays
+                         */
+                        poll_ev->num_fds -= 1;
+                        if (poll_ev->num_fds == i) {
+                                break;
+                        }
+                        poll_ev->fds[i] = poll_ev->fds[poll_ev->num_fds];
+                        poll_ev->fdes[i] = poll_ev->fdes[poll_ev->num_fds];
+                        if (poll_ev->fdes[i] != NULL) {
+                                poll_ev->fdes[i]->additional_flags = i;
+                        }
+                }
+                poll_ev->deleted = false;
+        }
+
+        if (poll_ev->fresh == NULL) {
+                return true;
+        }
+
+        num_fresh = 0;
+        for (fde = poll_ev->fresh; fde; fde = fde->next) {
+                num_fresh += 1;
+        }
+        num_fds = poll_ev->num_fds + num_fresh;
+
+        /*
+         * We check the length of fdes here. It is the last one
+         * enlarged, so if the realloc for poll_fd->fdes fails,
+         * poll_fd->fds will have at least the size of poll_fd->fdes
+         */
+
+        if (num_fds >= talloc_array_length(poll_ev->fdes)) {
+                struct pollfd *tmp_fds;
+                struct tevent_fd **tmp_fdes;
+                unsigned array_length;
+
+                array_length = (num_fds + 15) & ~15; /* round up to 16 */
+
+                tmp_fds = talloc_realloc(
+                        poll_ev, poll_ev->fds, struct pollfd, array_length);
+                if (tmp_fds == NULL) {
+                        return false;
+                }
+                poll_ev->fds = tmp_fds;
+
+                tmp_fdes = talloc_realloc(
+                        poll_ev, poll_ev->fdes, struct tevent_fd *,
+                        array_length);
+                if (tmp_fdes == NULL) {
+                        return false;
+                }
+                poll_ev->fdes = tmp_fdes;
+        }
+
+        for (fde = poll_ev->fresh; fde; fde = next) {
+                struct pollfd *pfd;
+
+                pfd = &poll_ev->fds[poll_ev->num_fds];
+
+                pfd->fd = fde->fd;
+                pfd->events = 0;
+                pfd->revents = 0;
+
+                if (fde->flags & TEVENT_FD_READ) {
+                        pfd->events |= (POLLIN|POLLHUP);
+                }
+                if (fde->flags & TEVENT_FD_WRITE) {
+                        pfd->events |= (POLLOUT);
+                }
+
+                fde->additional_flags = poll_ev->num_fds;
+                poll_ev->fdes[poll_ev->num_fds] = fde;
+
+                next = fde->next;
+                DLIST_REMOVE(poll_ev->fresh, fde);
+                DLIST_ADD(ev->fd_events, fde);
+
+                poll_ev->num_fds += 1;
+        }
+        return true;
 }
 
 /*
-  event loop handling using select()
+  event loop handling using poll()
 */
 static int poll_event_loop_poll(struct tevent_context *ev,
@@ -185 +495 @@
         struct poll_event_context *poll_ev = talloc_get_type_abort(
                 ev->additional_data, struct poll_event_context);
-        struct tevent_fd *fde;
         int pollrtn;
         int timeout = -1;
+        int poll_errno;
+        struct tevent_fd *fde = NULL;
+        struct tevent_fd *next = NULL;
+        unsigned i;
 
         if (ev->signal_events && tevent_common_check_signal(ev)) {
@@ -198 +511 @@
         }
 
+        poll_event_drain_signal_fd(poll_ev);
+
+        if (!poll_event_setup_fresh(ev, poll_ev)) {
+                return -1;
+        }
+
+        tevent_trace_point_callback(poll_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
         pollrtn = poll(poll_ev->fds, poll_ev->num_fds, timeout);
-
-        if (pollrtn == -1 && errno == EINTR && ev->signal_events) {
+        poll_errno = errno;
+        tevent_trace_point_callback(poll_ev->ev, TEVENT_TRACE_AFTER_WAIT);
+
+        if (pollrtn == -1 && poll_errno == EINTR && ev->signal_events) {
                 tevent_common_check_signal(ev);
                 return 0;
-        }
-
-        if (pollrtn == -1 && errno == EBADF) {
-                /* the socket is dead! this should never
-                   happen as the socket should have first been
-                   made readable and that should have removed
-                   the event, so this must be a bug. This is a
-                   fatal error. */
-                tevent_debug(ev, TEVENT_DEBUG_FATAL,
-                             "ERROR: EBADF on poll_event_loop_once\n");
-                poll_ev->exit_code = EBADF;
-                return -1;
         }
 
@@ -223 +533 @@
         }
 
-        if (pollrtn > 0) {
-                /* at least one file descriptor is ready - check
-                   which ones and call the handler, being careful to allow
-                   the handler to remove itself when called */
-                for (fde = ev->fd_events; fde; fde = fde->next) {
-                        struct pollfd *pfd;
-                        uint64_t pfd_idx = fde->additional_flags;
-                        uint16_t flags = 0;
-
-                        pfd = &poll_ev->fds[pfd_idx];
-
-                        if (pfd->revents & (POLLHUP|POLLERR)) {
-                                /* If we only wait for TEVENT_FD_WRITE, we
-                                   should not tell the event handler about it,
-                                   and remove the writable flag, as we only
-                                   report errors when waiting for read events
-                                   to match the select behavior. */
-                                if (!(fde->flags & TEVENT_FD_READ)) {
-                                        TEVENT_FD_NOT_WRITEABLE(fde);
-                                        continue;
-                                }
-                                flags |= TEVENT_FD_READ;
+        if (pollrtn <= 0) {
+                /*
+                 * No fd's ready
+                 */
+                return 0;
+        }
+
+        /* at least one file descriptor is ready - check
+           which ones and call the handler, being careful to allow
+           the handler to remove itself when called */
+
+        for (fde = ev->fd_events; fde; fde = next) {
+                uint64_t idx = fde->additional_flags;
+                struct pollfd *pfd;
+                uint16_t flags = 0;
+
+                next = fde->next;
+
+                if (idx == UINT64_MAX) {
+                        continue;
+                }
+
+                pfd = &poll_ev->fds[idx];
+
+                if (pfd->revents & POLLNVAL) {
+                        /*
+                         * the socket is dead! this should never
+                         * happen as the socket should have first been
+                         * made readable and that should have removed
+                         * the event, so this must be a bug.
+                         *
+                         * We ignore it here to match the epoll
+                         * behavior.
+                         */
+                        tevent_debug(ev, TEVENT_DEBUG_ERROR,
+                                     "POLLNVAL on fde[%p] fd[%d] - disabling\n",
+                                     fde, pfd->fd);
+                        poll_ev->fdes[idx] = NULL;
+                        poll_ev->deleted = true;
+                        DLIST_REMOVE(ev->fd_events, fde);
+                        fde->event_ctx = NULL;
+                        continue;
+                }
+
+                if (pfd->revents & (POLLHUP|POLLERR)) {
+                        /* If we only wait for TEVENT_FD_WRITE, we
+                           should not tell the event handler about it,
+                           and remove the writable flag, as we only
+                           report errors when waiting for read events
+                           to match the select behavior. */
+                        if (!(fde->flags & TEVENT_FD_READ)) {
+                                TEVENT_FD_NOT_WRITEABLE(fde);
+                                continue;
                         }
-                        if (pfd->revents & POLLIN) {
-                                flags |= TEVENT_FD_READ;
-                        }
-                        if (pfd->revents & POLLOUT) {
-                                flags |= TEVENT_FD_WRITE;
-                        }
-                        if (flags != 0) {
-                                fde->handler(ev, fde, flags,
-                                             fde->private_data);
-                                break;
+                        flags |= TEVENT_FD_READ;
+                }
+                if (pfd->revents & POLLIN) {
+                        flags |= TEVENT_FD_READ;
+                }
+                if (pfd->revents & POLLOUT) {
+                        flags |= TEVENT_FD_WRITE;
+                }
+                /*
+                 * Note that fde->flags could be changed when using
+                 * the poll_mt backend together with threads,
+                 * that why we need to check pfd->revents and fde->flags
+                 */
+                flags &= fde->flags;
+                if (flags != 0) {
+                        DLIST_DEMOTE(ev->fd_events, fde);
+                        fde->handler(ev, fde, flags, fde->private_data);
+                        return 0;
+                }
+        }
+
+        for (i = 0; i < poll_ev->num_fds; i++) {
+                if (poll_ev->fds[i].revents & POLLNVAL) {
+                        /*
+                         * the socket is dead! this should never
+                         * happen as the socket should have first been
+                         * made readable and that should have removed
+                         * the event, so this must be a bug or
+                         * a race in the poll_mt usage.
+                         */
+                        fde = poll_ev->fdes[i];
+                        tevent_debug(ev, TEVENT_DEBUG_WARNING,
+                                     "POLLNVAL on dangling fd[%d] fde[%p] - disabling\n",
+                                     poll_ev->fds[i].fd, fde);
+                        poll_ev->fdes[i] = NULL;
+                        poll_ev->deleted = true;
+                        if (fde != NULL) {
+                                DLIST_REMOVE(ev->fd_events, fde);
+                                fde->event_ctx = NULL;
                         }
                 }
@@ -287 +657 @@
 
         return poll_event_loop_poll(ev, &tval);
+}
+
+static int poll_event_loop_wait(struct tevent_context *ev,
+                                const char *location)
+{
+        struct poll_event_context *poll_ev = talloc_get_type_abort(
+                ev->additional_data, struct poll_event_context);
+
+        /*
+         * loop as long as we have events pending
+         */
+        while (ev->fd_events ||
+               ev->timer_events ||
+               ev->immediate_events ||
+               ev->signal_events ||
+               poll_ev->fresh ||
+               poll_ev->disabled) {
+                int ret;
+                ret = _tevent_loop_once(ev, location);
+                if (ret != 0) {
+                        tevent_debug(ev, TEVENT_DEBUG_FATAL,
+                                     "_tevent_loop_once() failed: %d - %s\n",
+                                     ret, strerror(errno));
+                        return ret;
+                }
+        }
+
+        tevent_debug(ev, TEVENT_DEBUG_WARNING,
+                     "poll_event_loop_wait() out of events\n");
+        return 0;
 }
 
@@ -295 +695 @@
         .get_fd_flags           = tevent_common_fd_get_flags,
         .set_fd_flags           = poll_event_set_fd_flags,
-        .add_timer              = tevent_common_add_timer,
+        .add_timer              = tevent_common_add_timer_v2,
         .schedule_immediate     = tevent_common_schedule_immediate,
         .add_signal             = tevent_common_add_signal,
         .loop_once              = poll_event_loop_once,
-        .loop_wait              = tevent_common_loop_wait,
+        .loop_wait              = poll_event_loop_wait,
 };
 
@@ -306 +706 @@
         return tevent_register_backend("poll", &poll_event_ops);
 }
+
+static const struct tevent_ops poll_event_mt_ops = {
+        .context_init           = poll_event_context_init_mt,
+        .add_fd                 = poll_event_add_fd,
+        .set_fd_close_fn        = tevent_common_fd_set_close_fn,
+        .get_fd_flags           = tevent_common_fd_get_flags,
+        .set_fd_flags           = poll_event_set_fd_flags,
+        .add_timer              = tevent_common_add_timer_v2,
+        .schedule_immediate     = poll_event_schedule_immediate,
+        .add_signal             = tevent_common_add_signal,
+        .loop_once              = poll_event_loop_once,
+        .loop_wait              = poll_event_loop_wait,
+};
+
+_PRIVATE_ bool tevent_poll_mt_init(void)
+{
+        return tevent_register_backend("poll_mt", &poll_event_mt_ops);
+}

vendor/current/lib/tevent/tevent_queue.c

@@ -134 +134 @@
                                            void *private_data)
 {
-        struct tevent_queue *q = talloc_get_type(private_data,
-                                  struct tevent_queue);
+        struct tevent_queue *q =
+                talloc_get_type_abort(private_data,
+                struct tevent_queue);
 
         if (!q->running) {
+                return;
+        }
+
+        if (!q->list) {
                 return;
         }
@@ -143 +148 @@
         q->list->triggered = true;
         q->list->trigger(q->list->req, q->list->private_data);
+}
+
+static struct tevent_queue_entry *tevent_queue_add_internal(
+                                        struct tevent_queue *queue,
+                                        struct tevent_context *ev,
+                                        struct tevent_req *req,
+                                        tevent_queue_trigger_fn_t trigger,
+                                        void *private_data,
+                                        bool allow_direct)
+{
+        struct tevent_queue_entry *e;
+
+        e = talloc_zero(req, struct tevent_queue_entry);
+        if (e == NULL) {
+                return NULL;
+        }
+
+        e->queue = queue;
+        e->req = req;
+        e->ev = ev;
+        e->trigger = trigger;
+        e->private_data = private_data;
+
+        /*
+         * if there is no trigger, it is just a blocker
+         */
+        if (trigger == NULL) {
+                e->triggered = true;
+        }
+
+        if (queue->length > 0) {
+                /*
+                 * if there are already entries in the
+                 * queue do not optimize.
+                 */
+                allow_direct = false;
+        }
+
+        if (req->async.fn != NULL) {
+                /*
+                 * If the callers wants to optimize for the
+                 * empty queue case, call the trigger only
+                 * if there is no callback defined for the
+                 * request yet.
+                 */
+                allow_direct = false;
+        }
+
+        DLIST_ADD_END(queue->list, e);
+        queue->length++;
+        talloc_set_destructor(e, tevent_queue_entry_destructor);
+
+        if (!queue->running) {
+                return e;
+        }
+
+        if (queue->list->triggered) {
+                return e;
+        }
+
+        /*
+         * If allowed we directly call the trigger
+         * avoiding possible delays caused by
+         * an immediate event.
+         */
+        if (allow_direct) {
+                queue->list->triggered = true;
+                queue->list->trigger(queue->list->req,
+                                     queue->list->private_data);
+                return e;
+        }
+
+        tevent_schedule_immediate(queue->immediate,
+                                  queue->list->ev,
+                                  tevent_queue_immediate_trigger,
+                                  queue);
+
+        return e;
 }
 
@@ -153 +236 @@
         struct tevent_queue_entry *e;
 
-        e = talloc_zero(req, struct tevent_queue_entry);
+        e = tevent_queue_add_internal(queue, ev, req,
+                                      trigger, private_data, false);
         if (e == NULL) {
                 return false;
         }
 
-        e->queue = queue;
-        e->req = req;
-        e->ev = ev;
-        e->trigger = trigger;
-        e->private_data = private_data;
-
-        DLIST_ADD_END(queue->list, e, struct tevent_queue_entry *);
-        queue->length++;
-        talloc_set_destructor(e, tevent_queue_entry_destructor);
-
-        if (!queue->running) {
-                return true;
+        return true;
+}
+
+struct tevent_queue_entry *tevent_queue_add_entry(
+                                        struct tevent_queue *queue,
+                                        struct tevent_context *ev,
+                                        struct tevent_req *req,
+                                        tevent_queue_trigger_fn_t trigger,
+                                        void *private_data)
+{
+        return tevent_queue_add_internal(queue, ev, req,
+                                         trigger, private_data, false);
+}
+
+struct tevent_queue_entry *tevent_queue_add_optimize_empty(
+                                        struct tevent_queue *queue,
+                                        struct tevent_context *ev,
+                                        struct tevent_req *req,
+                                        tevent_queue_trigger_fn_t trigger,
+                                        void *private_data)
+{
+        return tevent_queue_add_internal(queue, ev, req,
+                                         trigger, private_data, true);
+}
+
+void tevent_queue_start(struct tevent_queue *queue)
+{
+        if (queue->running) {
+                /* already started */
+                return;
+        }
+
+        queue->running = true;
+
+        if (!queue->list) {
+                return;
         }
 
         if (queue->list->triggered) {
-                return true;
+                return;
         }
 
@@ -180 +288 @@
                                   tevent_queue_immediate_trigger,
                                   queue);
-
+}
+
+void tevent_queue_stop(struct tevent_queue *queue)
+{
+        queue->running = false;
+}
+
+size_t tevent_queue_length(struct tevent_queue *queue)
+{
+        return queue->length;
+}
+
+bool tevent_queue_running(struct tevent_queue *queue)
+{
+        return queue->running;
+}
+
+struct tevent_queue_wait_state {
+        uint8_t dummy;
+};
+
+static void tevent_queue_wait_trigger(struct tevent_req *req,
+                                      void *private_data);
+
+struct tevent_req *tevent_queue_wait_send(TALLOC_CTX *mem_ctx,
+                                          struct tevent_context *ev,
+                                          struct tevent_queue *queue)
+{
+        struct tevent_req *req;
+        struct tevent_queue_wait_state *state;
+        bool ok;
+
+        req = tevent_req_create(mem_ctx, &state,
+                                struct tevent_queue_wait_state);
+        if (req == NULL) {
+                return NULL;
+        }
+
+        ok = tevent_queue_add(queue, ev, req,
+                              tevent_queue_wait_trigger,
+                              NULL);
+        if (!ok) {
+                tevent_req_oom(req);
+                return tevent_req_post(req, ev);
+        }
+
+        return req;
+}
+
+static void tevent_queue_wait_trigger(struct tevent_req *req,
+                                         void *private_data)
+{
+        tevent_req_done(req);
+}
+
+bool tevent_queue_wait_recv(struct tevent_req *req)
+{
+        enum tevent_req_state state;
+        uint64_t err;
+
+        if (tevent_req_is_error(req, &state, &err)) {
+                tevent_req_received(req);
+                return false;
+        }
+
+        tevent_req_received(req);
         return true;
 }
-
-void tevent_queue_start(struct tevent_queue *queue)
-{
-        if (queue->running) {
-                /* already started */
-                return;
-        }
-
-        queue->running = true;
-
-        if (!queue->list) {
-                return;
-        }
-
-        if (queue->list->triggered) {
-                return;
-        }
-
-        tevent_schedule_immediate(queue->immediate,
-                                  queue->list->ev,
-                                  tevent_queue_immediate_trigger,
-                                  queue);
-}
-
-void tevent_queue_stop(struct tevent_queue *queue)
-{
-        queue->running = false;
-}
-
-size_t tevent_queue_length(struct tevent_queue *queue)
-{
-        return queue->length;
-}

vendor/current/lib/tevent/tevent_req.c

@@ -52 +52 @@
 }
 
+static int tevent_req_destructor(struct tevent_req *req);
+
 struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
                                     void *pdata,
@@ -62 +64 @@
         void *data;
 
-        req = talloc_zero(mem_ctx, struct tevent_req);
+        req = talloc_pooled_object(
+                mem_ctx, struct tevent_req, 2,
+                sizeof(struct tevent_immediate) + data_size);
         if (req == NULL) {
                 return NULL;
         }
+        ZERO_STRUCTP(req);
         req->internal.private_type      = type;
         req->internal.create_location   = location;
-        req->internal.finish_location   = NULL;
         req->internal.state             = TEVENT_REQ_IN_PROGRESS;
         req->internal.trigger           = tevent_create_immediate(req);
@@ -85 +89 @@
         req->data = data;
 
+        talloc_set_destructor(req, tevent_req_destructor);
+
         *ppdata = data;
         return req;
 }
 
+static int tevent_req_destructor(struct tevent_req *req)
+{
+        tevent_req_received(req);
+        return 0;
+}
+
 void _tevent_req_notify_callback(struct tevent_req *req, const char *location)
 {
         req->internal.finish_location = location;
+        if (req->internal.defer_callback_ev) {
+                (void)tevent_req_post(req, req->internal.defer_callback_ev);
+                req->internal.defer_callback_ev = NULL;
+                return;
+        }
         if (req->async.fn != NULL) {
                 req->async.fn(req);
         }
+}
+
+static void tevent_req_cleanup(struct tevent_req *req)
+{
+        if (req->private_cleanup.fn == NULL) {
+                return;
+        }
+
+        if (req->private_cleanup.state >= req->internal.state) {
+                /*
+                 * Don't call the cleanup_function multiple times for the same
+                 * state recursively
+                 */
+                return;
+        }
+
+        req->private_cleanup.state = req->internal.state;
+        req->private_cleanup.fn(req, req->internal.state);
 }
 
@@ -101 +136 @@
                               const char *location)
 {
+        /*
+         * make sure we do not timeout after
+         * the request was already finished
+         */
+        TALLOC_FREE(req->internal.timer);
+
         req->internal.state = state;
+        req->internal.finish_location = location;
+
+        tevent_req_cleanup(req);
+
         _tevent_req_notify_callback(req, location);
 }
@@ -124 +169 @@
 }
 
+void _tevent_req_oom(struct tevent_req *req, const char *location)
+{
+        tevent_req_finish(req, TEVENT_REQ_NO_MEMORY, location);
+}
+
 bool _tevent_req_nomem(const void *p,
                        struct tevent_req *req,
@@ -131 +181 @@
                 return false;
         }
-        tevent_req_finish(req, TEVENT_REQ_NO_MEMORY, location);
+        _tevent_req_oom(req, location);
         return true;
 }
@@ -150 +200 @@
                                void *private_data)
 {
-        struct tevent_req *req = talloc_get_type(private_data,
-                                 struct tevent_req);
+        struct tevent_req *req =
+                talloc_get_type_abort(private_data,
+                struct tevent_req);
 
         tevent_req_finish(req, req->internal.state,
@@ -165 +216 @@
 }
 
+void tevent_req_defer_callback(struct tevent_req *req,
+                               struct tevent_context *ev)
+{
+        req->internal.defer_callback_ev = ev;
+}
+
 bool tevent_req_is_in_progress(struct tevent_req *req)
 {
@@ -176 +233 @@
 void tevent_req_received(struct tevent_req *req)
 {
-        TALLOC_FREE(req->data);
+        talloc_set_destructor(req, NULL);
+
         req->private_print = NULL;
+        req->private_cancel = NULL;
 
         TALLOC_FREE(req->internal.trigger);
@@ -183 +242 @@
 
         req->internal.state = TEVENT_REQ_RECEIVED;
+
+        tevent_req_cleanup(req);
+
+        TALLOC_FREE(req->data);
 }
 
@@ -218 +281 @@
                                void *private_data)
 {
-        struct tevent_req *req = talloc_get_type(private_data,
-                                 struct tevent_req);
+        struct tevent_req *req =
+                talloc_get_type_abort(private_data,
+                struct tevent_req);
 
         TALLOC_FREE(req->internal.timer);
@@ -276 +340 @@
         return req->private_cancel(req);
 }
+
+void tevent_req_set_cleanup_fn(struct tevent_req *req, tevent_req_cleanup_fn fn)
+{
+        req->private_cleanup.state = req->internal.state;
+        req->private_cleanup.fn = fn;
+}

vendor/current/lib/tevent/tevent_select.c

@@ -36 +36 @@
         /* the maximum file descriptor number in fd_events */
         int maxfd;
-
-        /* information for exiting from the event loop */
-        int exit_code;
 };
 
@@ -47 +44 @@
 {
         struct select_event_context *select_ev;
+
+        /*
+         * We might be called during tevent_re_initialise()
+         * which means we need to free our old additional_data.
+         */
+        TALLOC_FREE(ev->additional_data);
 
         select_ev = talloc_zero(ev, struct select_event_context);
@@ -86 +89 @@
 
         if (ev) {
-                select_ev = talloc_get_type(ev->additional_data,
-                                            struct select_event_context);
+                select_ev = talloc_get_type_abort(ev->additional_data,
+                                                  struct select_event_context);
 
                 if (select_ev->maxfd == fde->fd) {
@@ -108 +111 @@
                                              const char *location)
 {
-        struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
-                                                           struct select_event_context);
+        struct select_event_context *select_ev =
+                talloc_get_type_abort(ev->additional_data,
+                struct select_event_context);
         struct tevent_fd *fde;
 
@@ -139 +143 @@
         struct tevent_fd *fde;
         int selrtn;
+        int select_errno;
 
         /* we maybe need to recalculate the maxfd */
@@ -151 +156 @@
         for (fde = select_ev->ev->fd_events; fde; fde = fde->next) {
                 if (fde->fd < 0 || fde->fd >= FD_SETSIZE) {
+                        tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
+                                     "ERROR: EBADF fd[%d] >= %d "
+                                     "select_event_loop_once\n",
+                                     fde->fd, FD_SETSIZE);
                         errno = EBADF;
                         return -1;
@@ -168 +177 @@
         }
 
+        tevent_trace_point_callback(select_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
         selrtn = select(select_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
-
-        if (selrtn == -1 && errno == EINTR && 
+        select_errno = errno;
+        tevent_trace_point_callback(select_ev->ev, TEVENT_TRACE_AFTER_WAIT);
+
+        if (selrtn == -1 && select_errno == EINTR &&
             select_ev->ev->signal_events) {
                 tevent_common_check_signal(select_ev->ev);
@@ -176 +188 @@
         }
 
-        if (selrtn == -1 && errno == EBADF) {
+        if (selrtn == -1 && select_errno == EBADF) {
                 /* the socket is dead! this should never
                    happen as the socket should have first been
@@ -184 +196 @@
                 tevent_debug(select_ev->ev, TEVENT_DEBUG_FATAL,
                              "ERROR: EBADF on select_event_loop_once\n");
-                select_ev->exit_code = EBADF;
+                errno = select_errno;
                 return -1;
         }
@@ -201 +213 @@
                         uint16_t flags = 0;
 
-                        if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
-                        if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
+                        if (FD_ISSET(fde->fd, &r_fds) && (fde->flags & TEVENT_FD_READ)) {
+                                flags |= TEVENT_FD_READ;
+                        }
+                        if (FD_ISSET(fde->fd, &w_fds) && (fde->flags & TEVENT_FD_WRITE)) {
+                                flags |= TEVENT_FD_WRITE;
+                        }
                         if (flags) {
+                                DLIST_DEMOTE(select_ev->ev->fd_events, fde);
                                 fde->handler(select_ev->ev, fde, flags, fde->private_data);
                                 break;
@@ -218 +235 @@
 static int select_event_loop_once(struct tevent_context *ev, const char *location)
 {
-        struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
-                                                           struct select_event_context);
+        struct select_event_context *select_ev =
+                talloc_get_type_abort(ev->additional_data,
+                struct select_event_context);
         struct timeval tval;
 
@@ -246 +264 @@
         .get_fd_flags           = tevent_common_fd_get_flags,
         .set_fd_flags           = tevent_common_fd_set_flags,
-        .add_timer              = tevent_common_add_timer,
+        .add_timer              = tevent_common_add_timer_v2,
         .schedule_immediate     = tevent_common_schedule_immediate,
         .add_signal             = tevent_common_add_signal,

vendor/current/lib/tevent/tevent_signal.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
 
@@ -31 +31 @@
 #include "tevent_util.h"
 
-#define TEVENT_NUM_SIGNALS 64
-
 /* maximum number of SA_SIGINFO signals to hold in the queue.
   NB. This *MUST* be a power of 2, in order for the ring buffer
@@ -38 +36 @@
   for this. */
 
-#define TEVENT_SA_INFO_QUEUE_COUNT 64
+#define TEVENT_SA_INFO_QUEUE_COUNT 256
+
+size_t tevent_num_signals(void)
+{
+        return TEVENT_NUM_SIGNALS;
+}
+
+size_t tevent_sa_info_queue_count(void)
+{
+        return TEVENT_SA_INFO_QUEUE_COUNT;
+}
 
 struct tevent_sigcounter {
@@ -45 +53 @@
 };
 
+#if defined(HAVE___SYNC_FETCH_AND_ADD)
+#define TEVENT_SIG_INCREMENT(s) __sync_fetch_and_add(&((s).count), 1)
+#elif defined(HAVE_ATOMIC_ADD_32)
+#define TEVENT_SIG_INCREMENT(s) atomic_add_32(&((s).count), 1)
+#else
 #define TEVENT_SIG_INCREMENT(s) (s).count++
+#endif
 #define TEVENT_SIG_SEEN(s, n) (s).seen += (n)
 #define TEVENT_SIG_PENDING(s) ((s).seen != (s).count)
@@ -83 +97 @@
 {
         char c = 0;
-        ssize_t res;
         struct tevent_common_signal_list *sl;
         struct tevent_context *ev = NULL;
@@ -96 +109 @@
                         ev = sl->se->event_ctx;
                         /* doesn't matter if this pipe overflows */
-                        res = write(ev->pipe_fds[1], &c, 1);
+                        (void) write(ev->pipe_fds[1], &c, 1);
                 }
         }
@@ -174 +187 @@
 static int tevent_signal_destructor(struct tevent_signal *se)
 {
-        struct tevent_common_signal_list *sl;
-        sl = talloc_get_type(se->additional_data,
-                             struct tevent_common_signal_list);
+        struct tevent_common_signal_list *sl =
+                talloc_get_type_abort(se->additional_data,
+                struct tevent_common_signal_list);
 
         if (se->event_ctx) {
-                DLIST_REMOVE(se->event_ctx->signal_events, se);
+                struct tevent_context *ev = se->event_ctx;
+
+                DLIST_REMOVE(ev->signal_events, se);
+
+                if (ev->signal_events == NULL && ev->pipe_fde != NULL) {
+                        /*
+                         * This was the last signal. Destroy the pipe.
+                         */
+                        TALLOC_FREE(ev->pipe_fde);
+
+                        close(ev->pipe_fds[0]);
+                        close(ev->pipe_fds[1]);
+                }
         }
 
@@ -188 +213 @@
                 if (sig_state->oldact[se->signum]) {
                         sigaction(se->signum, sig_state->oldact[se->signum], NULL);
+                        talloc_free(sig_state->oldact[se->signum]);
                         sig_state->oldact[se->signum] = NULL;
                 }
@@ -210 +236 @@
 {
         char c[16];
-        ssize_t res;
         /* its non-blocking, doesn't matter if we read too much */
-        res = read(fde->fd, c, sizeof(c));
+        (void) read(fde->fd, c, sizeof(c));
 }
 
@@ -316 +341 @@
                 if (sig_state->oldact[signum] == NULL) {
                         talloc_free(se);
-                        return NULL;                    
+                        return NULL;
                 }
                 if (sigaction(signum, &act, sig_state->oldact[signum]) == -1) {
+                        talloc_free(sig_state->oldact[signum]);
+                        sig_state->oldact[signum] = NULL;
                         talloc_free(se);
                         return NULL;
@@ -339 +366 @@
 }
 
+struct tevent_se_exists {
+        struct tevent_se_exists **myself;
+};
+
+static int tevent_se_exists_destructor(struct tevent_se_exists *s)
+{
+        *s->myself = NULL;
+        return 0;
+}
 
 /*
@@ -351 +387 @@
                 return 0;
         }
-        
+
         for (i=0;i<TEVENT_NUM_SIGNALS+1;i++) {
                 struct tevent_common_signal_list *sl, *next;
@@ -367 +403 @@
                 for (sl=sig_state->sig_handlers[i];sl;sl=next) {
                         struct tevent_signal *se = sl->se;
+                        struct tevent_se_exists *exists;
+
                         next = sl->next;
+
+                        /*
+                         * We have to be careful to not touch "se"
+                         * after it was deleted in its handler. Thus
+                         * we allocate a child whose destructor will
+                         * tell by nulling out itself that its parent
+                         * is gone.
+                         */
+                        exists = talloc(se, struct tevent_se_exists);
+                        if (exists == NULL) {
+                                continue;
+                        }
+                        exists->myself = &exists;
+                        talloc_set_destructor(
+                                exists, tevent_se_exists_destructor);
+
 #ifdef SA_SIGINFO
                         if (se->sa_flags & SA_SIGINFO) {
@@ -382 +436 @@
                                                 % TEVENT_SA_INFO_QUEUE_COUNT;
                                         se->handler(ev, se, i, 1,
-                                                    (void*)&sig_state->sig_info[i][ofs], 
+                                                    (void*)&sig_state->sig_info[i][ofs],
                                                     se->private_data);
+                                        if (!exists) {
+                                                break;
+                                        }
                                 }
 #ifdef SA_RESETHAND
-                                if (se->sa_flags & SA_RESETHAND) {
+                                if (exists && (se->sa_flags & SA_RESETHAND)) {
                                         talloc_free(se);
                                 }
 #endif
+                                talloc_free(exists);
                                 continue;
                         }
@@ -395 +453 @@
                         se->handler(ev, se, i, count, NULL, se->private_data);
 #ifdef SA_RESETHAND
-                        if (se->sa_flags & SA_RESETHAND) {
+                        if (exists && (se->sa_flags & SA_RESETHAND)) {
                                 talloc_free(se);
                         }
 #endif
-                }
-
-#ifdef SA_SIGINFO
-                if (clear_processed_siginfo) {
+                        talloc_free(exists);
+                }
+
+#ifdef SA_SIGINFO
+                if (clear_processed_siginfo && sig_state->sig_info[i] != NULL) {
                         uint32_t j;
                         for (j=0;j<count;j++) {
@@ -441 +500 @@
 void tevent_cleanup_pending_signal_handlers(struct tevent_signal *se)
 {
-        struct tevent_common_signal_list *sl;
-        sl = talloc_get_type(se->additional_data,
-                             struct tevent_common_signal_list);
+        struct tevent_common_signal_list *sl =
+                talloc_get_type_abort(se->additional_data,
+                struct tevent_common_signal_list);
 
         tevent_common_signal_list_destructor(sl);
@@ -450 +509 @@
                 if (sig_state->oldact[se->signum]) {
                         sigaction(se->signum, sig_state->oldact[se->signum], NULL);
+                        talloc_free(sig_state->oldact[se->signum]);
                         sig_state->oldact[se->signum] = NULL;
                 }

vendor/current/lib/tevent/tevent_standard.c

@@ -2 +2 @@
    Unix SMB/CIFS implementation.
    main select loop and event handling
-   Copyright (C) Andrew Tridgell        2003-2005
-   Copyright (C) Stefan Metzmacher      2005-2009
+   Copyright (C) Stefan Metzmacher      2013
+   Copyright (C) Jeremy Allison         2013
 
      ** NOTE! The following LGPL license applies to the tevent
@@ -27 +27 @@
 
   - we try to use epoll if configure detected support for it
-    otherwise we use select()
+    otherwise we use poll()
   - if epoll is broken on the system or the kernel doesn't support it
-    at runtime we fallback to select()
+    at runtime we fallback to poll()
 */
 
 #include "replace.h"
-#include "system/filesys.h"
-#include "system/select.h"
 #include "tevent.h"
 #include "tevent_util.h"
 #include "tevent_internal.h"
 
-struct std_event_context {
-        /* a pointer back to the generic event_context */
-        struct tevent_context *ev;
-
-        /* the maximum file descriptor number in fd_events */
-        int maxfd;
-
-        /* information for exiting from the event loop */
-        int exit_code;
-
-        /* when using epoll this is the handle from epoll_create */
-        int epoll_fd;
-
-        /* our pid at the time the epoll_fd was created */
-        pid_t pid;
+struct std_event_glue {
+        const struct tevent_ops *epoll_ops;
+        const struct tevent_ops *poll_ops;
+        struct tevent_ops *glue_ops;
+        bool fallback_replay;
 };
 
-/* use epoll if it is available */
-#if HAVE_EPOLL
+static int std_event_context_init(struct tevent_context *ev);
+
+static const struct tevent_ops std_event_ops = {
+        .context_init           = std_event_context_init,
+};
+
 /*
-  called when a epoll call fails, and we should fallback
-  to using select
-*/
-static void epoll_fallback_to_select(struct std_event_context *std_ev, const char *reason)
-{
-        tevent_debug(std_ev->ev, TEVENT_DEBUG_FATAL,
-                     "%s (%s) - falling back to select()\n",
-                     reason, strerror(errno));
-        close(std_ev->epoll_fd);
-        std_ev->epoll_fd = -1;
-        talloc_set_destructor(std_ev, NULL);
-}
-
+  If this function gets called. epoll failed at runtime.
+  Move us to using poll instead. If we return false here,
+  caller should abort().
+*/
+#ifdef HAVE_EPOLL
+static bool std_fallback_to_poll(struct tevent_context *ev, bool replay)
+{
+        void *glue_ptr = talloc_parent(ev->ops);
+        struct std_event_glue *glue =
+                talloc_get_type_abort(glue_ptr,
+                struct std_event_glue);
+        int ret;
+        struct tevent_fd *fde;
+        struct tevent_fd *fde_next;
+
+        glue->fallback_replay = replay;
+
+        /* First switch all the ops to poll. */
+        glue->epoll_ops = NULL;
+
+        /*
+         * Set custom_ops the same as poll.
+         */
+        *glue->glue_ops = *glue->poll_ops;
+        glue->glue_ops->context_init = std_event_context_init;
+
+        /* Next initialize the poll backend. */
+        ret = glue->poll_ops->context_init(ev);
+        if (ret != 0) {
+                return false;
+        }
+
+        /*
+         * Now we have to change all the existing file descriptor
+         * events from the epoll backend to the poll backend.
+         */
+        for (fde = ev->fd_events; fde; fde = fde_next) {
+                /*
+                 * We must remove this fde off the ev->fd_events list.
+                 */
+                fde_next = fde->next;
+
+                /* Remove from the ev->fd_events list. */
+                DLIST_REMOVE(ev->fd_events, fde);
+
+                /* Re-add this event as a poll backend event. */
+                tevent_poll_event_add_fd_internal(ev, fde);
+        }
+
+        return true;
+}
+#endif
+
+static int std_event_loop_once(struct tevent_context *ev, const char *location)
+{
+        void *glue_ptr = talloc_parent(ev->ops);
+        struct std_event_glue *glue =
+                talloc_get_type_abort(glue_ptr,
+                struct std_event_glue);
+        int ret;
+
+        ret = glue->epoll_ops->loop_once(ev, location);
+        if (glue->epoll_ops != NULL) {
+                /* No fallback */
+                return ret;
+        }
+
+        if (!glue->fallback_replay) {
+                /*
+                 * The problem happened while modifying an event.
+                 * An event handler was triggered in this case
+                 * and there is no need to call loop_once() again.
+                 */
+                return ret;
+        }
+
+        return glue->poll_ops->loop_once(ev, location);
+}
+
+static int std_event_loop_wait(struct tevent_context *ev, const char *location)
+{
+        void *glue_ptr = talloc_parent(ev->ops);
+        struct std_event_glue *glue =
+                talloc_get_type_abort(glue_ptr,
+                struct std_event_glue);
+        int ret;
+
+        ret = glue->epoll_ops->loop_wait(ev, location);
+        if (glue->epoll_ops != NULL) {
+                /* No fallback */
+                return ret;
+        }
+
+        return glue->poll_ops->loop_wait(ev, location);
+}
 /*
-  map from TEVENT_FD_* to EPOLLIN/EPOLLOUT
-*/
-static uint32_t epoll_map_flags(uint16_t flags)
-{
-        uint32_t ret = 0;
-        if (flags & TEVENT_FD_READ) ret |= (EPOLLIN | EPOLLERR | EPOLLHUP);
-        if (flags & TEVENT_FD_WRITE) ret |= (EPOLLOUT | EPOLLERR | EPOLLHUP);
-        return ret;
-}
-
-/*
- free the epoll fd
-*/
-static int epoll_ctx_destructor(struct std_event_context *std_ev)
-{
-        if (std_ev->epoll_fd != -1) {
-                close(std_ev->epoll_fd);
-        }
-        std_ev->epoll_fd = -1;
-        return 0;
-}
-
-/*
- init the epoll fd
-*/
-static void epoll_init_ctx(struct std_event_context *std_ev)
-{
-        std_ev->epoll_fd = epoll_create(64);
-        std_ev->pid = getpid();
-        talloc_set_destructor(std_ev, epoll_ctx_destructor);
-}
-
-static void epoll_add_event(struct std_event_context *std_ev, struct tevent_fd *fde);
-
-/*
-  reopen the epoll handle when our pid changes
-  see http://junkcode.samba.org/ftp/unpacked/junkcode/epoll_fork.c for an 
-  demonstration of why this is needed
- */
-static void epoll_check_reopen(struct std_event_context *std_ev)
-{
-        struct tevent_fd *fde;
-
-        if (std_ev->pid == getpid()) {
-                return;
-        }
-
-        close(std_ev->epoll_fd);
-        std_ev->epoll_fd = epoll_create(64);
-        if (std_ev->epoll_fd == -1) {
-                tevent_debug(std_ev->ev, TEVENT_DEBUG_FATAL,
-                             "Failed to recreate epoll handle after fork\n");
-                return;
-        }
-        std_ev->pid = getpid();
-        for (fde=std_ev->ev->fd_events;fde;fde=fde->next) {
-                epoll_add_event(std_ev, fde);
-        }
-}
-
-#define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT      (1<<0)
-#define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR   (1<<1)
-#define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR      (1<<2)
-
-/*
- add the epoll event to the given fd_event
-*/
-static void epoll_add_event(struct std_event_context *std_ev, struct tevent_fd *fde)
-{
-        struct epoll_event event;
-        if (std_ev->epoll_fd == -1) return;
-
-        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
-
-        /* if we don't want events yet, don't add an epoll_event */
-        if (fde->flags == 0) return;
-
-        ZERO_STRUCT(event);
-        event.events = epoll_map_flags(fde->flags);
-        event.data.ptr = fde;
-        if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event) != 0) {
-                epoll_fallback_to_select(std_ev, "EPOLL_CTL_ADD failed");
-        }
-        fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
-
-        /* only if we want to read we want to tell the event handler about errors */
-        if (fde->flags & TEVENT_FD_READ) {
-                fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
-        }
-}
-
-/*
- delete the epoll event for given fd_event
-*/
-static void epoll_del_event(struct std_event_context *std_ev, struct tevent_fd *fde)
-{
-        struct epoll_event event;
-        if (std_ev->epoll_fd == -1) return;
-
-        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
-
-        /* if there's no epoll_event, we don't need to delete it */
-        if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) return;
-
-        ZERO_STRUCT(event);
-        event.events = epoll_map_flags(fde->flags);
-        event.data.ptr = fde;
-        epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event);
-        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
-}
-
-/*
- change the epoll event to the given fd_event
-*/
-static void epoll_mod_event(struct std_event_context *std_ev, struct tevent_fd *fde)
-{
-        struct epoll_event event;
-        if (std_ev->epoll_fd == -1) return;
-
-        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
-
-        ZERO_STRUCT(event);
-        event.events = epoll_map_flags(fde->flags);
-        event.data.ptr = fde;
-        if (epoll_ctl(std_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
-                epoll_fallback_to_select(std_ev, "EPOLL_CTL_MOD failed");
-        }
-
-        /* only if we want to read we want to tell the event handler about errors */
-        if (fde->flags & TEVENT_FD_READ) {
-                fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
-        }
-}
-
-static void epoll_change_event(struct std_event_context *std_ev, struct tevent_fd *fde)
-{
-        bool got_error = (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
-        bool want_read = (fde->flags & TEVENT_FD_READ);
-        bool want_write= (fde->flags & TEVENT_FD_WRITE);
-
-        if (std_ev->epoll_fd == -1) return;
-
-        fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
-
-        /* there's already an event */
-        if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
-                if (want_read || (want_write && !got_error)) {
-                        epoll_mod_event(std_ev, fde);
-                        return;
-                }
-                /* 
-                 * if we want to match the select behavior, we need to remove the epoll_event
-                 * when the caller isn't interested in events.
-                 *
-                 * this is because epoll reports EPOLLERR and EPOLLHUP, even without asking for them
-                 */
-                epoll_del_event(std_ev, fde);
-                return;
-        }
-
-        /* there's no epoll_event attached to the fde */
-        if (want_read || (want_write && !got_error)) {
-                epoll_add_event(std_ev, fde);
-                return;
-        }
-}
-
-/*
-  event loop handling using epoll
-*/
-static int epoll_event_loop(struct std_event_context *std_ev, struct timeval *tvalp)
-{
-        int ret, i;
-#define MAXEVENTS 1
-        struct epoll_event events[MAXEVENTS];
-        int timeout = -1;
-
-        if (std_ev->epoll_fd == -1) return -1;
-
-        if (tvalp) {
-                /* it's better to trigger timed events a bit later than to early */
-                timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
-        }
-
-        if (std_ev->ev->signal_events &&
-            tevent_common_check_signal(std_ev->ev)) {
-                return 0;
-        }
-
-        ret = epoll_wait(std_ev->epoll_fd, events, MAXEVENTS, timeout);
-
-        if (ret == -1 && errno == EINTR && std_ev->ev->signal_events) {
-                if (tevent_common_check_signal(std_ev->ev)) {
-                        return 0;
-                }
-        }
-
-        if (ret == -1 && errno != EINTR) {
-                epoll_fallback_to_select(std_ev, "epoll_wait() failed");
-                return -1;
-        }
-
-        if (ret == 0 && tvalp) {
-                /* we don't care about a possible delay here */
-                tevent_common_loop_timer_delay(std_ev->ev);
-                return 0;
-        }
-
-        for (i=0;i<ret;i++) {
-                struct tevent_fd *fde = talloc_get_type(events[i].data.ptr, 
-                                                       struct tevent_fd);
-                uint16_t flags = 0;
-
-                if (fde == NULL) {
-                        epoll_fallback_to_select(std_ev, "epoll_wait() gave bad data");
+  Initialize the epoll backend and allow it to call a
+  switch function if epoll fails at runtime.
+*/
+static int std_event_context_init(struct tevent_context *ev)
+{
+        struct std_event_glue *glue;
+        int ret;
+
+        /*
+         * If this is the first initialization
+         * we need to set up the allocated ops
+         * pointers.
+         */
+
+        if (ev->ops == &std_event_ops) {
+                glue = talloc_zero(ev, struct std_event_glue);
+                if (glue == NULL) {
                         return -1;
                 }
-                if (events[i].events & (EPOLLHUP|EPOLLERR)) {
-                        fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
-                        /*
-                         * if we only wait for TEVENT_FD_WRITE, we should not tell the
-                         * event handler about it, and remove the epoll_event,
-                         * as we only report errors when waiting for read events,
-                         * to match the select() behavior
-                         */
-                        if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
-                                epoll_del_event(std_ev, fde);
-                                continue;
-                        }
-                        flags |= TEVENT_FD_READ;
-                }
-                if (events[i].events & EPOLLIN) flags |= TEVENT_FD_READ;
-                if (events[i].events & EPOLLOUT) flags |= TEVENT_FD_WRITE;
-                if (flags) {
-                        fde->handler(std_ev->ev, fde, flags, fde->private_data);
-                        break;
-                }
-        }
-
-        return 0;
-}
-#else
-#define epoll_init_ctx(std_ev) 
-#define epoll_add_event(std_ev,fde)
-#define epoll_del_event(std_ev,fde)
-#define epoll_change_event(std_ev,fde)
-#define epoll_event_loop(std_ev,tvalp) (-1)
-#define epoll_check_reopen(std_ev)
+
+                glue->epoll_ops = tevent_find_ops_byname("epoll");
+
+                glue->poll_ops = tevent_find_ops_byname("poll");
+                if (glue->poll_ops == NULL) {
+                        return -1;
+                }
+
+                /*
+                 * Allocate space for our custom ops.
+                 * Allocate as a child of our epoll_ops pointer
+                 * so we can easily get to it using talloc_parent.
+                 */
+                glue->glue_ops = talloc_zero(glue, struct tevent_ops);
+                if (glue->glue_ops == NULL) {
+                        talloc_free(glue);
+                        return -1;
+                }
+
+                ev->ops = glue->glue_ops;
+        } else {
+                void *glue_ptr = talloc_parent(ev->ops);
+                glue = talloc_get_type_abort(glue_ptr, struct std_event_glue);
+        }
+
+        if (glue->epoll_ops != NULL) {
+                /*
+                 * Set custom_ops the same as epoll,
+                 * except re-init using std_event_context_init()
+                 * and use std_event_loop_once() to add the
+                 * ability to fallback to a poll backend on
+                 * epoll runtime error.
+                 */
+                *glue->glue_ops = *glue->epoll_ops;
+                glue->glue_ops->context_init = std_event_context_init;
+                glue->glue_ops->loop_once = std_event_loop_once;
+                glue->glue_ops->loop_wait = std_event_loop_wait;
+
+                ret = glue->epoll_ops->context_init(ev);
+                if (ret == -1) {
+                        goto fallback;
+                }
+#ifdef HAVE_EPOLL
+                tevent_epoll_set_panic_fallback(ev, std_fallback_to_poll);
 #endif
 
-/*
-  create a std_event_context structure.
-*/
-static int std_event_context_init(struct tevent_context *ev)
-{
-        struct std_event_context *std_ev;
-
-        std_ev = talloc_zero(ev, struct std_event_context);
-        if (!std_ev) return -1;
-        std_ev->ev = ev;
-        std_ev->epoll_fd = -1;
-
-        epoll_init_ctx(std_ev);
-
-        ev->additional_data = std_ev;
-        return 0;
-}
-
-/*
-  recalculate the maxfd
-*/
-static void calc_maxfd(struct std_event_context *std_ev)
-{
-        struct tevent_fd *fde;
-
-        std_ev->maxfd = 0;
-        for (fde = std_ev->ev->fd_events; fde; fde = fde->next) {
-                if (fde->fd > std_ev->maxfd) {
-                        std_ev->maxfd = fde->fd;
-                }
-        }
-}
-
-
-/* to mark the ev->maxfd invalid
- * this means we need to recalculate it
- */
-#define EVENT_INVALID_MAXFD (-1)
-
-/*
-  destroy an fd_event
-*/
-static int std_event_fd_destructor(struct tevent_fd *fde)
-{
-        struct tevent_context *ev = fde->event_ctx;
-        struct std_event_context *std_ev = NULL;
-
-        if (ev) {
-                std_ev = talloc_get_type(ev->additional_data,
-                                         struct std_event_context);
-
-                epoll_check_reopen(std_ev);
-
-                if (std_ev->maxfd == fde->fd) {
-                        std_ev->maxfd = EVENT_INVALID_MAXFD;
-                }
-
-                epoll_del_event(std_ev, fde);
-        }
-
-        return tevent_common_fd_destructor(fde);
-}
-
-/*
-  add a fd based event
-  return NULL on failure (memory allocation error)
-*/
-static struct tevent_fd *std_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
-                                          int fd, uint16_t flags,
-                                          tevent_fd_handler_t handler,
-                                          void *private_data,
-                                          const char *handler_name,
-                                          const char *location)
-{
-        struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
-                                                           struct std_event_context);
-        struct tevent_fd *fde;
-
-        epoll_check_reopen(std_ev);
-
-        fde = tevent_common_add_fd(ev, mem_ctx, fd, flags,
-                                   handler, private_data,
-                                   handler_name, location);
-        if (!fde) return NULL;
-
-        if ((std_ev->maxfd != EVENT_INVALID_MAXFD)
-            && (fde->fd > std_ev->maxfd)) {
-                std_ev->maxfd = fde->fd;
-        }
-        talloc_set_destructor(fde, std_event_fd_destructor);
-
-        epoll_add_event(std_ev, fde);
-
-        return fde;
-}
-
-/*
-  set the fd event flags
-*/
-static void std_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
-{
-        struct tevent_context *ev;
-        struct std_event_context *std_ev;
-
-        if (fde->flags == flags) return;
-
-        ev = fde->event_ctx;
-        std_ev = talloc_get_type(ev->additional_data, struct std_event_context);
-
-        fde->flags = flags;
-
-        epoll_check_reopen(std_ev);
-
-        epoll_change_event(std_ev, fde);
-}
-
-/*
-  event loop handling using select()
-*/
-static int std_event_loop_select(struct std_event_context *std_ev, struct timeval *tvalp)
-{
-        fd_set r_fds, w_fds;
-        struct tevent_fd *fde;
-        int selrtn;
-
-        /* we maybe need to recalculate the maxfd */
-        if (std_ev->maxfd == EVENT_INVALID_MAXFD) {
-                calc_maxfd(std_ev);
-        }
-
-        FD_ZERO(&r_fds);
-        FD_ZERO(&w_fds);
-
-        /* setup any fd events */
-        for (fde = std_ev->ev->fd_events; fde; fde = fde->next) {
-                if (fde->fd < 0 || fde->fd >= FD_SETSIZE) {
-                        std_ev->exit_code = EBADF;
-                        return -1;
-                }
-                if (fde->flags & TEVENT_FD_READ) {
-                        FD_SET(fde->fd, &r_fds);
-                }
-                if (fde->flags & TEVENT_FD_WRITE) {
-                        FD_SET(fde->fd, &w_fds);
-                }
-        }
-
-        if (std_ev->ev->signal_events &&
-            tevent_common_check_signal(std_ev->ev)) {
-                return 0;
-        }
-
-        selrtn = select(std_ev->maxfd+1, &r_fds, &w_fds, NULL, tvalp);
-
-        if (selrtn == -1 && errno == EINTR && 
-            std_ev->ev->signal_events) {
-                tevent_common_check_signal(std_ev->ev);
-                return 0;
-        }
-
-        if (selrtn == -1 && errno == EBADF) {
-                /* the socket is dead! this should never
-                   happen as the socket should have first been
-                   made readable and that should have removed
-                   the event, so this must be a bug. This is a
-                   fatal error. */
-                tevent_debug(std_ev->ev, TEVENT_DEBUG_FATAL,
-                             "ERROR: EBADF on std_event_loop_once\n");
-                std_ev->exit_code = EBADF;
-                return -1;
-        }
-
-        if (selrtn == 0 && tvalp) {
-                /* we don't care about a possible delay here */
-                tevent_common_loop_timer_delay(std_ev->ev);
-                return 0;
-        }
-
-        if (selrtn > 0) {
-                /* at least one file descriptor is ready - check
-                   which ones and call the handler, being careful to allow
-                   the handler to remove itself when called */
-                for (fde = std_ev->ev->fd_events; fde; fde = fde->next) {
-                        uint16_t flags = 0;
-
-                        if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
-                        if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
-                        if (flags & fde->flags) {
-                                fde->handler(std_ev->ev, fde, flags, fde->private_data);
-                                break;
-                        }
-                }
-        }
-
-        return 0;
-}               
-
-/*
-  do a single event loop using the events defined in ev 
-*/
-static int std_event_loop_once(struct tevent_context *ev, const char *location)
-{
-        struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
-                                                           struct std_event_context);
-        struct timeval tval;
-
-        if (ev->signal_events &&
-            tevent_common_check_signal(ev)) {
-                return 0;
-        }
-
-        if (ev->immediate_events &&
-            tevent_common_loop_immediate(ev)) {
-                return 0;
-        }
-
-        tval = tevent_common_loop_timer_delay(ev);
-        if (tevent_timeval_is_zero(&tval)) {
-                return 0;
-        }
-
-        epoll_check_reopen(std_ev);
-
-        if (epoll_event_loop(std_ev, &tval) == 0) {
-                return 0;
-        }
-
-        return std_event_loop_select(std_ev, &tval);
-}
-
-static const struct tevent_ops std_event_ops = {
-        .context_init           = std_event_context_init,
-        .add_fd                 = std_event_add_fd,
-        .set_fd_close_fn        = tevent_common_fd_set_close_fn,
-        .get_fd_flags           = tevent_common_fd_get_flags,
-        .set_fd_flags           = std_event_set_fd_flags,
-        .add_timer              = tevent_common_add_timer,
-        .schedule_immediate     = tevent_common_schedule_immediate,
-        .add_signal             = tevent_common_add_signal,
-        .loop_once              = std_event_loop_once,
-        .loop_wait              = tevent_common_loop_wait,
-};
-
+                return ret;
+        }
+
+fallback:
+        glue->epoll_ops = NULL;
+
+        /*
+         * Set custom_ops the same as poll.
+         */
+        *glue->glue_ops = *glue->poll_ops;
+        glue->glue_ops->context_init = std_event_context_init;
+
+        return glue->poll_ops->context_init(ev);
+}
 
 _PRIVATE_ bool tevent_standard_init(void)
@@ -571 +231 @@
         return tevent_register_backend("standard", &std_event_ops);
 }
-

vendor/current/lib/tevent/tevent_timed.c

@@ -134 +134 @@
 static int tevent_common_timed_destructor(struct tevent_timer *te)
 {
+        if (te->event_ctx == NULL) {
+                return 0;
+        }
+
         tevent_debug(te->event_ctx, TEVENT_DEBUG_TRACE,
                      "Destroying timer event %p \"%s\"\n",
                      te, te->handler_name);
 
-        if (te->event_ctx) {
-                DLIST_REMOVE(te->event_ctx->timer_events, te);
-        }
+        if (te->event_ctx->last_zero_timer == te) {
+                te->event_ctx->last_zero_timer = DLIST_PREV(te);
+        }
+        DLIST_REMOVE(te->event_ctx->timer_events, te);
 
         return 0;
@@ -154 +159 @@
   return NULL on failure (memory allocation error)
 */
-struct tevent_timer *tevent_common_add_timer(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
-                                             struct timeval next_event,
-                                             tevent_timer_handler_t handler,
-                                             void *private_data,
-                                             const char *handler_name,
-                                             const char *location)
-{
-        struct tevent_timer *te, *last_te, *cur_te;
+static struct tevent_timer *tevent_common_add_timer_internal(
+                                        struct tevent_context *ev,
+                                        TALLOC_CTX *mem_ctx,
+                                        struct timeval next_event,
+                                        tevent_timer_handler_t handler,
+                                        void *private_data,
+                                        const char *handler_name,
+                                        const char *location,
+                                        bool optimize_zero)
+{
+        struct tevent_timer *te, *prev_te, *cur_te;
 
         te = talloc(mem_ctx?mem_ctx:ev, struct tevent_timer);
@@ -174 +182 @@
         te->additional_data     = NULL;
 
+        if (ev->timer_events == NULL) {
+                ev->last_zero_timer = NULL;
+        }
+
         /* keep the list ordered */
-        last_te = NULL;
-        for (cur_te = ev->timer_events; cur_te; cur_te = cur_te->next) {
-                /* if the new event comes before the current one break */
-                if (tevent_timeval_compare(&te->next_event, &cur_te->next_event) < 0) {
+        prev_te = NULL;
+        if (optimize_zero && tevent_timeval_is_zero(&te->next_event)) {
+                /*
+                 * Some callers use zero tevent_timer
+                 * instead of tevent_immediate events.
+                 *
+                 * As these can happen very often,
+                 * we remember the last zero timer
+                 * in the list.
+                 */
+                prev_te = ev->last_zero_timer;
+                ev->last_zero_timer = te;
+        } else {
+                /*
+                 * we traverse the list from the tail
+                 * because it's much more likely that
+                 * timers are added at the end of the list
+                 */
+                for (cur_te = DLIST_TAIL(ev->timer_events);
+                     cur_te != NULL;
+                     cur_te = DLIST_PREV(cur_te))
+                {
+                        int ret;
+
+                        /*
+                         * if the new event comes before the current
+                         * we continue searching
+                         */
+                        ret = tevent_timeval_compare(&te->next_event,
+                                                     &cur_te->next_event);
+                        if (ret < 0) {
+                                continue;
+                        }
+
                         break;
                 }
 
-                last_te = cur_te;
-        }
-
-        DLIST_ADD_AFTER(ev->timer_events, te, last_te);
+                prev_te = cur_te;
+        }
+
+        DLIST_ADD_AFTER(ev->timer_events, te, prev_te);
 
         talloc_set_destructor(te, tevent_common_timed_destructor);
@@ -193 +235 @@
                      handler_name, te);
         return te;
+}
+
+struct tevent_timer *tevent_common_add_timer(struct tevent_context *ev,
+                                             TALLOC_CTX *mem_ctx,
+                                             struct timeval next_event,
+                                             tevent_timer_handler_t handler,
+                                             void *private_data,
+                                             const char *handler_name,
+                                             const char *location)
+{
+        /*
+         * do not use optimization, there are broken Samba
+         * versions which use tevent_common_add_timer()
+         * without using tevent_common_loop_timer_delay(),
+         * it just uses DLIST_REMOVE(ev->timer_events, te)
+         * and would leave ev->last_zero_timer behind.
+         */
+        return tevent_common_add_timer_internal(ev, mem_ctx, next_event,
+                                                handler, private_data,
+                                                handler_name, location,
+                                                false);
+}
+
+struct tevent_timer *tevent_common_add_timer_v2(struct tevent_context *ev,
+                                                TALLOC_CTX *mem_ctx,
+                                                struct timeval next_event,
+                                                tevent_timer_handler_t handler,
+                                                void *private_data,
+                                                const char *handler_name,
+                                                const char *location)
+{
+        /*
+         * Here we turn on last_zero_timer optimization
+         */
+        return tevent_common_add_timer_internal(ev, mem_ctx, next_event,
+                                                handler, private_data,
+                                                handler_name, location,
+                                                true);
 }
 
@@ -243 +323 @@
          * handler because in a semi-async inner event loop called from the
          * handler we don't want to come across this event again -- vl */
+        if (ev->last_zero_timer == te) {
+                ev->last_zero_timer = DLIST_PREV(te);
+        }
         DLIST_REMOVE(ev->timer_events, te);
+
+        tevent_debug(te->event_ctx, TEVENT_DEBUG_TRACE,
+                     "Running timer event %p \"%s\"\n",
+                     te, te->handler_name);
 
         /*

vendor/current/lib/tevent/tevent_util.c

@@ -89 +89 @@
 #undef FLAG_TO_SET
 }
+
+bool ev_set_close_on_exec(int fd)
+{
+#ifdef FD_CLOEXEC
+        int val;
+
+        val = fcntl(fd, F_GETFD, 0);
+        if (val >= 0) {
+                val |= FD_CLOEXEC;
+                val = fcntl(fd, F_SETFD, val);
+                if (val != -1) {
+                        return true;
+                }
+        }
+#endif
+        return false;
+}

vendor/current/lib/tevent/tevent_util.h

@@ -54 +54 @@
   list_head->prev, which means we can add to the end of the list in
   O(1) time
-
-
-  Note that the 'type' arguments below are no longer needed, but
-  are kept for now to prevent an incompatible argument change
  */
 
@@ -132 +128 @@
 /*
    add to the end of a list.
-   Note that 'type' is ignored
 */
-#define DLIST_ADD_END(list, p, type)                    \
+#define DLIST_ADD_END(list, p) \
 do { \
         if (!(list)) { \
@@ -143 +138 @@
 } while (0)
 
-/* promote an element to the from of a list */
+/* promote an element to the front of a list */
 #define DLIST_PROMOTE(list, p) \
 do { \
@@ -152 +147 @@
 /*
    demote an element to the end of a list.
-   Note that 'type' is ignored
 */
-#define DLIST_DEMOTE(list, p, type)                     \
+#define DLIST_DEMOTE(list, p) \
 do { \
         DLIST_REMOVE(list, p); \
-        DLIST_ADD_END(list, p, NULL);           \
+        DLIST_ADD_END(list, p); \
 } while (0)
 
@@ -163 +157 @@
    concatenate two lists - putting all elements of the 2nd list at the
    end of the first list.
-   Note that 'type' is ignored
 */
-#define DLIST_CONCATENATE(list1, list2, type)   \
+#define DLIST_CONCATENATE(list1, list2) \
 do { \
         if (!(list1)) { \
@@ -184 +177 @@
 int ev_set_blocking(int fd, bool set);
 size_t ev_str_list_length(const char **list);
+bool ev_set_close_on_exec(int fd);
 
 /* Defined here so we can build against older talloc versions that don't

vendor/current/lib/tevent/tevent_wakeup.c

@@ -47 +47 @@
 
         if (!tevent_req_set_endtime(req, ev, wakeup_time)) {
-                goto post;
+                return tevent_req_post(req, ev);
         }
-
         return req;
-post:
-        return tevent_req_post(req, ev);
 }
 

vendor/current/lib/tevent/wscript

@@ -2 +2 @@
 
 APPNAME = 'tevent'
-VERSION = '0.9.11'
+VERSION = '0.9.28'
 
 blddir = 'bin'
@@ -11 +11 @@
 srcdir = '.'
 while not os.path.exists(srcdir+'/buildtools') and len(srcdir.split('/')) < 5:
-    srcdir = '../' + srcdir
+    srcdir = srcdir + '/..'
 sys.path.insert(0, srcdir + '/buildtools/wafsamba')
 
-import wafsamba, samba_dist, Options, Logs
+import wafsamba, samba_dist, samba_utils, Options, Logs
 
-samba_dist.DIST_DIRS('lib/tevent:. lib/replace:lib/replace lib/talloc:lib/talloc buildtools:buildtools')
+samba_dist.DIST_DIRS('lib/tevent:. lib/replace:lib/replace lib/talloc:lib/talloc buildtools:buildtools third_party/waf:third_party/waf')
 
 def set_options(opt):
@@ -36 +36 @@
 
     if not conf.env.standalone_tevent:
-        if conf.CHECK_BUNDLED_SYSTEM('tevent', minversion=VERSION,
+        if conf.CHECK_BUNDLED_SYSTEM_PKG('tevent', minversion=VERSION,
                                      onlyif='talloc', implied_deps='replace talloc'):
             conf.define('USING_SYSTEM_TEVENT', 1)
+            if conf.CHECK_BUNDLED_SYSTEM_PYTHON('pytevent', 'tevent', minversion=VERSION):
+                conf.define('USING_SYSTEM_PYTEVENT', 1)
 
     if conf.CHECK_FUNCS('epoll_create', headers='sys/epoll.h'):
         conf.DEFINE('HAVE_EPOLL', 1)
+
+    tevent_num_signals = 64
+    v = conf.CHECK_VALUEOF('NSIG', headers='signal.h')
+    if v is not None:
+        tevent_num_signals = max(tevent_num_signals, v)
+    v = conf.CHECK_VALUEOF('_NSIG', headers='signal.h')
+    if v is not None:
+        tevent_num_signals = max(tevent_num_signals, v)
+    v = conf.CHECK_VALUEOF('SIGRTMAX', headers='signal.h')
+    if v is not None:
+        tevent_num_signals = max(tevent_num_signals, v)
+    v = conf.CHECK_VALUEOF('SIGRTMIN', headers='signal.h')
+    if v is not None:
+        tevent_num_signals = max(tevent_num_signals, v*2)
+
+    if not conf.CONFIG_SET('USING_SYSTEM_TEVENT'):
+        conf.DEFINE('TEVENT_NUM_SIGNALS', tevent_num_signals)
 
     conf.env.disable_python = getattr(Options.options, 'disable_python', False)
@@ -47 +66 @@
     if not conf.env.disable_python:
         # also disable if we don't have the python libs installed
+        conf.find_program('python', var='PYTHON')
         conf.check_tool('python')
         conf.check_python_version((2,4,2))
@@ -56 +76 @@
     conf.SAMBA_CONFIG_H()
 
+    conf.SAMBA_CHECK_UNDEFINED_SYMBOL_FLAGS()
+
 def build(bld):
     bld.RECURSE('lib/replace')
@@ -62 +84 @@
     SRC = '''tevent.c tevent_debug.c tevent_fd.c tevent_immediate.c
              tevent_queue.c tevent_req.c tevent_select.c
-             tevent_poll.c
+             tevent_poll.c tevent_threads.c
              tevent_signal.c tevent_standard.c tevent_timed.c tevent_util.c tevent_wakeup.c'''
 
@@ -68 +90 @@
         SRC += ' tevent_epoll.c'
 
+    if bld.CONFIG_SET('HAVE_SOLARIS_PORTS'):
+        SRC += ' tevent_port.c'
+
     if bld.env.standalone_tevent:
         bld.env.PKGCONFIGDIR = '${LIBDIR}/pkgconfig'
-        bld.PKG_CONFIG_FILES('tevent.pc', vnum=VERSION)
         private_library = False
     else:
@@ -84 +108 @@
                           abi_match='tevent_* _tevent_*',
                           vnum=VERSION,
-                          public_headers='tevent.h',
+                          public_headers=('' if private_library else 'tevent.h'),
                           public_headers_install=not private_library,
+                          pc_files='tevent.pc',
                           private_library=private_library)
 
-    bld.SAMBA_PYTHON('pytevent',
-                     'pytevent.c',
-                     deps='tevent',
-                     enabled=True,
-                     realname='_tevent.so')
+    if not bld.CONFIG_SET('USING_SYSTEM_PYTEVENT') and not bld.env.disable_python:
+        for env in bld.gen_python_environments(['PKGCONFIGDIR']):
+            bld.SAMBA_PYTHON('_tevent',
+                            'pytevent.c',
+                            deps='tevent',
+                            realname='_tevent.so',
+                            cflags='-DPACKAGE_VERSION=\"%s\"' % VERSION)
+
+
+            bld.INSTALL_WILDCARD('${PYTHONARCHDIR}', 'tevent.py', flat=False)
+
+        # install out various python scripts for use by make test
+        bld.SAMBA_SCRIPT('tevent_python',
+                         pattern='tevent.py',
+                         installdir='python')
 
 
@@ -98 +133 @@
     '''test tevent'''
     print("The tevent testsuite is part of smbtorture in samba4")
+
+    samba_utils.ADD_LD_LIBRARY_PATH('bin/shared')
+    samba_utils.ADD_LD_LIBRARY_PATH('bin/shared/private')
+
+    pyret = samba_utils.RUN_PYTHON_TESTS(['bindings.py'])
+    sys.exit(pyret)