Merge lp:~epics-core/epics-base/rsrvbindiface into lp:~epics-core/epics-base/3.16

[mdavidsaver]

Updates to RSRV, mainly to allow binding to a specific network interfaces via. EPICS_CAS_INTF_ADDR_LIST. This necessitates quite a lot of work to "un-globalize" RSRV.

Along the way support for name lookup via IPv4 multicasting is added, but not enabled by default. Use by adding an mcast address to EPICS_CA_ADDR_LIST.

One potentially troublesome change is to allow osiSockDiscoverBroadcastAddresses() to find the loopback broadcast address.

[mdavidsaver (mdavidsaver)]

Needs compatibility testing

review: Needs Information

[lp:~epics-core/epics-base/rsrvbindiface]

12715. By Bjorklund, Eric A <email address hidden> on 2016-01-06

vxWorks: missing extern "C" around sysPci* prototypes

12716. By mdavidsaver on 2016-01-06

epicsMMIODef.h use static inline

'static inline' is necessary for consistent behavior with C and C++.
Plain 'inline' in C can result in multiply defined symbol
errors when linking.

12717. By mdavidsaver on 2016-01-12

rsrv: when binding to a specific interface also bind to iface bcast

An oddness of BSD sockets (not winsock) is that binding to
INADDR_ANY will receive unicast and broadcast, but binding to
a specific interface address receives only unicast. The trick
is to bind a second socket to the interface broadcast address,
which will then receive only broadcasts.

12718. By mdavidsaver on 2016-01-12

rsrv: unnecessary use of global

12719. By mdavidsaver on 2016-01-12

remove global prsrv_cast_client

12720. By mdavidsaver on 2016-01-12

rename prsrv_cast_client in cast_server()

12721. By mdavidsaver on 2016-01-12

rsrv: placeholder for cast_server thread shutdown

12722. By mdavidsaver on 2016-01-12

rsrv: more renaming

12723. By mdavidsaver on 2016-01-12

libCom/osi: osiSockDiscoverBroadcastAddresses() finds 127.255.255.255

For the default implementation of osiSockDiscoverBroadcastAddresses()
allow the loopback interface to have IFF_BROADCAST set (usually isn't)
and on Linux assume that the loopback broadcast address is usable
even if IFF_BROADCAST isn't set.

12724. By mdavidsaver on 2016-01-12

rsrv: casr show multiple UDP clients

12725. By mdavidsaver on 2016-01-12

rsrv: UDP listener on more than one iface

12726. By mdavidsaver on 2016-01-12

rsrv: unglobalize IOC_sock

12727. By mdavidsaver on 2016-01-12

rsrv: no lazy init of BUCKET

12728. By mdavidsaver on 2016-01-12

rsrv: move some from req_server to rsrv_init

12729. By mdavidsaver on 2016-01-12

rsrv: redo initialization to support bind multiple interfaces.

consolidate most setup tasks in rsrv_init(),
which now spawns threads directly.
For each interface create 3-4 sockets,

* TCP listener
* UDP receiver (unicast)
* UDP receiver (broadcast optional)
* UDP beacon sender

12730. By mdavidsaver on 2016-01-12

envDefs: add envGetBoolConfigParam

12731. By mdavidsaver on 2016-01-12

libca: addAddrToChannelAccessAddressList report success

12732. By mdavidsaver on 2016-01-12

expand beacon address list when binding to wildcard

12733. By mdavidsaver on 2016-01-12

rsrv: additional fallback for interface list

12734. By mdavidsaver on 2016-01-12

rsrv: don't leak sockets when building tcp set

12735. By mdavidsaver on 2016-01-12

rsrv: multicast name lookup

12736. By mdavidsaver on 2016-01-12

libca: enable mcast loopback

12737. By Andrew Johnson on 2016-01-21

Fix build for vxWorks 5.5.2

12738. By mdavidsaver on 2016-01-21

minor

fix typo
expand error message
skip redundant (and misleading) print of beacon address list

12739. By mdavidsaver on 2016-01-21

rsrv: fixup beacon address list handling

should be based on client interface list,
not server.

12740. By mdavidsaver on 2016-01-21

rsrv: loopback mcast beacons

12741. By mdavidsaver on 2016-01-21

don't use EPICS_CA_ADDR_LIST for server interface list

keep existing behavior, and server binds wildcard
when only client address list is specified.

12742. By mdavidsaver on 2016-01-21

update release notes

12743. By mdavidsaver on 2016-01-21

pcas: listen for mcast search request

12744. By Andrew Johnson on 2016-01-21

Fix build for vxWorks 5.5.2 (again)

12745. By mdavidsaver on 2016-01-21

rsrv: beaconCounter not updated

12746. By mdavidsaver on 2016-01-23

rsrv: fix wildcard check ordering

filter out mcast addresses before wildcard uniqueness check.

12747. By mdavidsaver on 2016-01-23

rsrv: oops

improper rebase

12748. By mdavidsaver on 2016-01-23

rsrv: more beacon address fixups

should really be based on *server* config
as beacons should be sent to clients attempting
to connect to the server.

By default send beacons to bcast addresses
from the interface address list.

12749. By Andrew Johnson on 2016-01-27

Improve casr() output

12750. By mdavidsaver on 2016-01-29

rsrv: decouple some client/server config

the automatic beacon address list should follow
the server interface address list, and not be
effected by any client config.

Also, don't populate the interface address list
from EPICS_CAS_BEACON_ADDR_LIST as this will
almost never contain local interface addresses.

12751. By mdavidsaver on 2016-02-04

pcas: no fallbacks for beacon address list

Don't mix client and server configuration
by defaulting the server beacon list to use
the client address list.

12752. By mdavidsaver on 2016-02-04

ca: update CAref.html with changes to beacon address list

Note that server beacon address list will no longer
consider client address list as a fallback.

12753. By mdavidsaver on 2016-02-04

update release notes

12754. By mdavidsaver on 2016-02-04

rsrv: EPICS_CAS_IGNORE_ADDR_LIST

12755. By mdavidsaver on 2016-02-04

libCom: fix debug print formats in osiSockDiscoverBroadcastAddresses()

12756. By mdavidsaver on 2016-02-04

rsrv: "casr 1" shows ignore list

12757. By mdavidsaver on 2016-02-05

update release notes

12758. By Andrew Johnson on 2016-02-08

Show UDP name server status in casr 2+ output

12759. By mdavidsaver on 2016-02-16

pcas: don't send beacons w/ connect()d socket

use sendto() and leave the origin field to 0.0.0.0
so it will be filled in by the receiving repeater

12760. By Ralph Lange on 2016-02-24

pcas: fix compilation on MSC Windows

12761. By Andrew Johnson on 2016-02-24

Report UDP client status on Windows

12762. By Ralph Lange on 2016-02-25

rsrv: populate the server list - also on Windows builds

12763. By mdavidsaver on 2016-02-25

win32: include ws2tcpip.h from osdSock.h

Needed to get some additional definitions
including IP_ADD_MEMBERSHIP

12764. By mdavidsaver on 2016-02-25

cygwin inherits winsock broadcast behavior

12765. By mdavidsaver on 2016-02-25

rsrv: use SOCKERRNO

Must use OSI SOCKERRNO for correct handling
of errors w/ winsock

Unmerged revisions

=== modified file 'configure/CONFIG_BASE_VERSION'
--- configure/CONFIG_BASE_VERSION	2015-06-05 18:48:57 +0000
+++ configure/CONFIG_BASE_VERSION	2016-01-12 02:07:47 +0000
@@ -40,7 +40,11 @@
 EPICS_REVISION = 16
 
 # EPICS_MODIFICATION must be a number >=0 and <256 
+<<<<<<< TREE
 EPICS_MODIFICATION = 0
+=======
+EPICS_MODIFICATION = 3
+>>>>>>> MERGE-SOURCE
 
 # EPICS_PATCH_LEVEL must be a number (win32 resource file requirement)
 # Not included if zero

=== modified file 'configure/RULES_EXPAND'
--- configure/RULES_EXPAND	2014-09-25 20:49:44 +0000
+++ configure/RULES_EXPAND	2016-01-12 02:07:47 +0000
@@ -2,6 +2,9 @@
 
 vpath %@ $(USR_VPATH) $(ALL_SRC_DIRS)
 
+#---------------------------------------------------------------
+# Variable expansion
+
 # Default settings
 EXPAND_TOOL ?= $(PERL) $(TOOLS)/expandVars.pl
 
@@ -24,3 +27,39 @@
 	@$(RM) $(EXPANDED)
 
 .PHONY : expand_clean
+
+#---------------------------------------------------------------
+# Assemblies (files assembled from snippets)
+
+ASSEMBLE_TOOL ?= $(PERL) $(TOOLS)/assembleSnippets.pl
+
+define COMMON_ASSEMBLY_template
+$1_SNIPPETS += $$(foreach dir, .. $$(SRC_DIRS), \
+    $$(wildcard $$(dir)/$$($1_PATTERN)))
+$(COMMON_DIR)/$1: $$($1_SNIPPETS)
+	$(ECHO) "Assembling common file $$@ from snippets"
+	@$(RM) $1
+	$(ASSEMBLE_TOOL) -o $1 $$^
+	@$(MV) $1 $$@
+endef
+$(foreach asy, $(COMMON_ASSEMBLIES), \
+    $(eval $(call COMMON_ASSEMBLY_template,$(strip $(asy)))))
+
+define ASSEMBLY_template
+$1_SNIPPETS += $$(foreach dir, .. $$(SRC_DIRS), \
+    $$(wildcard $$(dir)/$$($1_PATTERN)))
+$1: $$($1_SNIPPETS)
+	$(ECHO) "Assembling file $$@ from snippets"
+	@$(RM) $$@
+	$(ASSEMBLE_TOOL) -o $$@ $$^
+endef
+$(foreach asy, $(ASSEMBLIES), \
+    $(eval $(call ASSEMBLY_template,$(strip $(asy)))))
+
+define ASSEMBLY_DEP_template
+$1$(DEP):
+	@echo $1: > $$@
+endef
+$(foreach asy, $(sort $(COMMON_ASSEMBLIES) $(ASSEMBLIES)), \
+    $(eval $(call ASSEMBLY_DEP_template,$(strip $(asy)))))
+

=== modified file 'documentation/KnownProblems.html'
--- documentation/KnownProblems.html	2015-06-05 18:48:57 +0000
+++ documentation/KnownProblems.html	2016-01-12 02:07:47 +0000
@@ -22,10 +22,29 @@
 
 <ul>
 
+<<<<<<< TREE
 <!--
   <li>YYYY-MM-DD: Description of problem
     ...</li>
 -->
+=======
+  <li>See LaunchPad bug
+    <a href="https://bugs.launchpad.net/epics-base/+bug/1466129">#1466129</a>:
+    The feature that allows an IOC to bind to a single network interface is not
+    working correctly. The bug mentioned above contains a patch that has been
+    tested on Linux-64, a complete fix is expected for 3.15.4. Note that Windows
+    systems are not affected by this bug.</li>
+
+  <li>Parallel builds ("make -j") on native Windows are not working properly.
+    Builds tend to hang (saturating one core); interrupting and running make
+    again usually finishes the build. Limiting the number of parallel jobs using
+    something like "make -j8" also helps prevent this problem. Sequential builds
+    always work and are recommended for automated build environments.</li>
+
+  <li>64-bit Windows builds of the CAS library may not work with some compilers.
+    The code in <tt>src/legacy/gdd</tt> is currently incompatible with the LLP64
+    model that Windows uses for its 64-bit ABI.</li>
+>>>>>>> MERGE-SOURCE
 
 </ul>
 

=== modified file 'documentation/RELEASE_NOTES.html'
--- documentation/RELEASE_NOTES.html	2015-09-07 19:23:04 +0000
+++ documentation/RELEASE_NOTES.html	2016-01-12 02:07:47 +0000
@@ -11,6 +11,7 @@
 
 <p style="color:red">This version of EPICS Base has not been released yet.</p>
 
+<<<<<<< TREE
 <h2 align="center">Changes between 3.15.x and 3.16.0</h2>
 <!-- Insert new items immediately below this template ...
 
@@ -85,6 +86,1167 @@
 <p>Added a new macro <tt>callbackGetPriority(prio, callback)</tt> to the
 callback.h header and removed the need for dbScan.c to reach into the internals
 of its CALLBACK objects.</p>
+=======
+<h2 align="center">Changes between 3.15.2 and 3.15.3</h2>
+<!-- Insert new items immediately below here ... -->
+
+<h3>Make the NTP Time provider optional on VxWorks</h3>
+
+<p>Recent versions of VxWorks (sometime after VxWorks 6) provide facilities for
+automatically synchronizing the OS clock time with an NTP server. The EPICS time
+system used to assume that it had to provide time synchronization on VxWorks,
+but now it tests for the existance of either of the two OS synchronization
+threads before starting the NTP time provider. It is still possible to force the
+NTP provider to be started even if the OS synchronization is running by defining
+the environment variable <tt>EPICS_TS_FORCE_NTPTIME</tt> in the startup script
+before loading the IOC's .munch file. Forcing may be necessary if the VxWorks
+image is not correctly configured with the IP address of a local NTP server.</p>
+
+<h3>Assembling files from numbered snippets</h3>
+
+<p>A tool has been added that assembles file snippets specified on the
+command line into a single output file, with sorting and replacing/adding of
+snippets done based on their file names. The build system integration requires
+the output file to be specified setting COMMON_ASSEMBLIES (arch independent)
+or ASSEMBLIES (created by arch), then defining the snippets for each assembly
+setting *_SNIPPETS (explicitly) or *_PATTERN (searched relative to all source
+directories).
+</p>
+
+<h3>Clean up after GNU readline()</h3>
+
+<p>If EPICS Base is built with readline support, any IOC that calls epicsExit()
+from a thread other than the main thread is likely to leave the user's terminal
+in a weird state, requiring the user to run something like 'stty sane' to clean
+it up. This release patches the readline support code to clean up automatically
+by registering an epicsAtExit() routine.</p>
+
+<h3>Removed the last vestiges of RSET::get_value()</h3>
+
+<p>The IOC has not called the get_value() routine in the RSET for a very long
+time, but there was still one implementation left in the event record support
+code, and a structure definition for one of the original arguments to that
+routine was defined in recGbl.h. Both of these have now been removed.</p>
+
+<h2 align="center">Changes between 3.15.1 and 3.15.2</h2>
+
+<h3>Raised limit on link field length in database files</h3>
+
+<p>The length of INP/OUT link fields in database files was limited to 79 chars
+by an internal buffer size in the db file parser. This limitation will go away
+completely in 3.16, and has been statically raised to 255 chars for the 3.15
+series.</p>
+
+<h3>aoRecord raw conversion overflows</h3>
+
+<p>The ao record type now checks converted raw values and limits them to the
+32-bit integer range before writing them to the RVAL field. Previously value
+overflows relied on Undefined Behaviour which could give different results on
+different platforms. The ROFF fields of the ao and ai record types are now
+DBF_ULONG to allow an ROFF setting of 0x80000000 to work properly.</p>
+
+<h3>Changes to &lt;top&gt;/cfg/* files</h3>
+
+<p>The order in which cfg/CONFIG* and cfg/RULES* files are included from support
+applications listed in the configure/RELEASE* files has been changed. Previously
+these files were included in the order in which the top areas are listed in the
+RELEASE file, but it makes more sense to load them in reverse order since later
+entries override earlier ones in Makefiles but the release file order is
+supposed to allow earlier entries to take precedence over later ones. The same
+change has been made to the inclusion of the &lt;top&gt;/configure/RULES_BUILD
+files.</p>
+
+<p>Two new file types can also be provided in a module's cfg directory. Files
+named TOP_RULES* will be included by the top-level Makefile of other modules
+that refer to this module; files name DIR_RULES* will be included by all
+Makefiles that merely descend into lower-level directories. The cfg/RULES* files
+are only included when make is building code inside the O.&lt;arch&gt;
+directories.</p>
+
+<p>The new cfg/DIR_RULES* file inclusion was designed to permit new recursive
+make actions to be implemented by appending the name of the new action to the
+ACTIONS variable. There must be a matching rule in one of the cfg/RULES* files
+when doing this. Similar rules may also be defined in the cfg/TOP_RULES* and/or
+cfg/DIR_RULES* files, but these should only state prerequisites and not directly
+provide commands to be executed.</p>
+
+<h3>Build rules for RTEMS GESYS modules</h3>
+
+<p>RTEMS target builds can now be configured to make GESYS modules by changing
+the <CODE>USE_GESYS=NO</code> setting in the file
+configure/os/CONFIG_SITE.Common.RTEMS to <code>YES</code>.</p>
+
+<h3>Added Make variables for command-line use</h3>
+
+<p>The following variables are now used during the build process, reserved for
+setting on the command-line only (Makefiles should continue to use the
+<code>USR_</code> equivalents):</p>
+
+<ul>
+<li>CMD_INCLUDES</li>
+<li>CMD_CPPFLAGS</li>
+<li>CMD_CFLAGS</li>
+<li>CMD_CXXFLAGS</li>
+<li>CMD_LDFLAGS</li>
+<li>CMD_DBFLAGS</li>
+<li>CMD_DBDFLAGS</li>
+<li>CMD_REGRDDFLAGS</li>
+<li>CMD_ARFLAGS</li>
+</ul>
+
+<p>For example:</p>
+
+<blockquote><pre>
+make CMD_INCLUDES=/opt/local/include CMD_LDFLAGS=-L/opt/local/lib
+</pre></blockquote>
+
+<h3>Enhanced API for asTrapWrite listeners</h3>
+
+<p>External software such as the CA Put Logging module that registers a listener
+with the asTrapWrite subsystem was not previously given access to the actual
+data being sent by the CA client. In most cases this was not a problem as the
+listener can look at the field being modified both before and after the
+operation, but if the put processes the record which immediately overwrites the
+new value, the client's value cannot be observed.</p>
+
+<p>This release adds three fields to the asTrapWriteMessage structure that is
+passed to the listener routines. These new fields provide the CA data type, the
+number of array elements, and a pointer to the source data buffer. This change
+is completely backwards compatible with listener code written against the
+original API. The new API can be detected at compile-time as follows:</p>
+
+<blockquote><pre>
+#include "asLib.h"
+
+/* ... */
+
+#ifdef asTrapWriteWithData
+    /* Enhanced API */
+#endif
+</pre></blockquote>
+
+<h3>Use of PATH_FILTER in Makefiles deprecated</h3>
+
+<p>The PATH_FILTER variable was being called to convert forward shashes
+<tt><b>/</b></tt> in file paths into pairs of backward slashes
+<tt><b>\\</b></tt> on Windows architectures. This has never been strictly
+necessary, and was added about 10 years ago to get around some short-comings in
+Windows tools at the time. All uses of PATH_FILTER in Base have now been
+removed; the definition is still present, but will result in a warning being
+printed if it is ever used.</p>
+
+<h3>Using msi for dependencies</h3>
+
+<p>To reduce confusion the msi program has been modified to allow the generation
+of dependency rules by adding support for a <tt>-D</tt> option, and changing the
+commands in RULES.Db to use this option instead of the mkmf.pl script. The new
+build rules will not work with old versions of the msi program, so the command
+variable name used in the rules has been changed from MSI to MSI3_15. Sites that
+use a modified version of msi must provide support for both the <tt>-D</tt> and
+<tt>-o&nbsp;outfile</tt> options, and should then point the MSI3_15 variable in
+their applications' CONFIG_SITE files to that updated executable.</p>
+
+<h2 align="center">Changes between 3.15.0.2 and 3.15.1</h2>
+
+<h3>epicsStrnEscapedFromRaw() and epicsStrnRawFromEscaped()</h3>
+
+<p>These routines have been rewritten; the previous implementations did not
+always behave exactly as specified.</p>
+
+<h3>Shared Library Versions</h3>
+
+<p>On architectures that can support it, the shared library version number for
+libraries provided with Base has had the third component of the EPICS version
+number added to it, thus libCom.so.3.15.1 instead of libCom.so.3.15. Windows
+can only support two components to its internal product version number, and the
+Darwin bug that external shared libraries were being built using the EPICS
+version number has been fixed.</p>
+
+<h3>Hooking into dbLoadRecords</h3>
+
+<p>A function pointer hook has been added to the dbLoadRecords() routine, to
+allow external modules such as autosave to be notified when new records have
+been loaded during IOC initialization. The hook is called dbLoadRecordsHook and
+follows the model of the recGblAlarmHook pointer in that modules that wish to
+use it must save the current value of the pointer before installing their own
+function pointer, and must call the original function from their own
+routine.</p>
+
+<p>The hook is activiated from the dbLoadRecords() routine and gets called only
+after a database instance file has been read in without error. Note that the
+dbLoadTemplates() routine directly calls dbLoadRecords() so this hook also
+provides information about instantiated database templates. It is still possible
+to load record instances using dbLoadDatabase() though, and doing this will not
+result in the hook routines being called.</p>
+
+<p>Code to use this hook should look something like this:</p>
+
+<blockquote><pre>
+#include "dbAccessDefs.h"
+
+static DB_LOAD_RECORDS_HOOK_ROUTINE previousHook;
+
+static void myRoutine(const char* file, const char* subs) {
+    if (previousHook)
+        previousHook(file, subs);
+
+    /* Do whatever ... */
+}
+
+void myInit(void) {
+    static int done = 0;
+
+    if (!done) {
+        previousHook = dbLoadRecordsHook;
+        dbLoadRecordsHook = myRoutine;
+        done = 1;
+    }
+}
+</pre></blockquote>
+
+<p>As with many other parts of the static database access library there is no
+mutex to protect the function pointer. Initialization is expected to take place
+in the context of the IOC's main thread, from either a static C++ constructor or
+an EPICS registrar routine.</p>
+
+
+<h2 align="center">Changes between 3.15.0.1 and 3.15.0.2</h2>
+
+<h3>New iocshLoad command</h3>
+
+<p>A new command <tt>iocshLoad</tt> has been added to iocsh which executes a
+named iocsh script and can also set one or more shell macro variables at the
+same time, the values of which will be forgotten immediately after the named
+script finishes executing. The following example shows the syntax:</p>
+
+<blockquote><pre>
+iocshLoad "serial.cmd", "DEV=/dev/ttyS0,PORT=com1,TYPE=RS485"
+iocshLoad "radmon.cmd", "PORT=com1,ADDR=0"
+</pre></blockquote>
+
+<h3>Support routines for 64-bit integers</h3>
+
+<p>The libCom library now provides support for 64-bit integer types on all
+supported architectures. The epicsTypes.h header file defines epicsInt64 and
+epicsUInt64 type definitions for both C and C++ code. The epicsStdlib.h header
+also declares the following for parsing strings into the relevent sized integer
+variables: Functions epicsParseLLong(), epicsParseULLong() with related macros
+epicsScanLLong() and epicsScanULLong(), and the functions epicsParseInt64()
+and epicsParseUInt64(). Use the first two functions and the macros for long long
+and unsigned long long integer types, and the last two functions for the
+epicsInt64 and epicsUInt64 types. Note that the latter can map to the types long
+and unsigned long on some 64-bit architectures such as linux-x86_64, not to the
+two long long types.</p>
+
+<p>This version does not provide the ability to define 64-bit record fields, the
+use of the 64-bit types in the IOC database will come in a later release of
+EPICS Base.</p>
+
+<h3>Full support for loadable support modules</h3>
+
+<p>Apparently later versions of Base 3.14 permitted support modules to be loaded
+from a shared library at runtime without the IOC having been linked against that
+shared library; the registerRecordDeviceDriver.pl program would accept a partial
+DBD file containing just the entries needed for the library and generate the
+appropriate registration code. In 3.15 however the registerRecordDeviceDriver.pl
+program was replaced by one using the new DBD file parser, and in this a device
+support entry would only be accepted after first loading the record type that it
+depended on.</p>
+
+<p>The parser has been modified to accept device entries without having seen the
+record type first, although a warning is given when that happens. To remove the
+warning the DBD file can provide a record type declaration instead (no fields
+can be defined, so the braces must be empty), before the device() entry. The
+result will generate the correct registration code for the device entry without
+including anything for any merely declared record types. The generated code can
+be linked into a shared library and loaded by an IOC at runtime using dlload.
+</p>
+
+<h3>Parallel callback threads</h3>
+
+<p>The general purpose callback facility can run multiple parallel callback
+threads per priority level. This makes better use of SMP architectures (e.g.
+processors with multiple cores), as callback work - which includes second
+stage processing of records with asynchronuous device support and I/O
+scanned processing - can be distributed over the available CPUs.</p>
+
+<p>Note that by using parallel callback threads the order of scan callback
+requests in the queue is not retained. If a device support needs to be
+informed when scanIoRequest processing has finished, it should use the new
+scanIoSetComplete() feature to add a user function that will be called after
+the scanIoRequest record processing has finished.</p>
+
+<p>Parallel callback threads have to be explicitly configured, by default
+the IOC keeps the old behavior of running one callback thread per priority.</p>
+
+<h3>Merge MMIO API from devLib2</h3>
+
+<p>Added calls to handle 8, 16, and 32 bit Memory Mapped I/O reads and writes.
+The calls added include <tt><i>X</i>_iowrite<i>Y</i>()</tt> and
+<tt><i>X</i>_ioread<i>Y</i>()</tt>
+where <tt><i>X</i></tt> is <tt>nat</tt> (native), <tt>be</tt> or <tt>le</tt>,
+and <tt><i>Y</i></tt> is <tt>16</tt> or <tt>32</tt>.
+Also added are <tt>ioread8()</tt> and <tt>iowrite8()</tt>.</p>
+
+<h3>Added optional dbServer API to database</h3>
+
+<p>A server layer that sits on top of the IOC database may now register itself
+as such by calling <tt>dbRegisterServer()</tt> and providing optional routines
+that other components can use. The initial purpose of this API allows the Trace
+Processing implementation in <tt>dbProcess()</tt> to identify a client that
+causes a record to process when TPRO is set.</p>
+
+<p>To support the client idenfication, the server provides a routine that
+returns that identity string when called by one of its own processing
+threads.</p>
+
+<h3>Concatenated database definition files</h3>
+
+<p>A series of database definition (dbd) files can now be concatenated during
+the build process into a newly-created dbd file with result being installed into
+$(INSTALL_LOCATION)/dbd without expanding it.</p>
+
+<p>The following lines in an EPICS Makefile will create a file name.dbd in the
+O.Common build directory containing the contents of file1.dbd followed by
+file2.dbd then file3.dbd. The new file will then be installed into
+$(INSTALL_LOCATION)/dbd without expanding any of its include statements.</p>
+
+<blockquote><pre>
+DBDCAT += name.dbd
+name_DBD += file1.dbd file2.dbd file3.dbd
+</pre></blockquote>
+
+<p>The source files file1.dbd, file2.dbd and file3.dbd may be created by the
+current Makefile, be located in the parent directory or any other directory in
+the SRC_DIRS list, be specified by their full pathname, exist in the install dbd
+directory, or be found in any dbd directory linked from the application's
+RELEASE files.</p>
+
+<h3>Posix: Drop SCHED_FIFO before exec() in child process</h3>
+
+<p>If Base is compiled with <tt>USE_POSIX_THREAD_PRIORITY_SCHEDULING = YES</tt>
+in configure/CONFIG_SITE or related files, the Posix implementation of the
+libCom <tt>osiSpawnDetachedProcess()</tt> routine will switch the child process
+to use the normal SCHED_OTHER (non real-time) scheduler before executing the
+named executable program. If it needs to use the real-time scheduler the new
+program can request that for itself.</p>
+
+<h3>Posix: Lock all memory when running with FIFO scheduler</h3>
+
+<p>On Posix systems, an IOC application's ability to meet timing deadlines is
+often dependent on its ability to lock part or all of the process's virtual
+address space into RAM, preventing that memory from being paged to the swap
+area. This change will attempt to lock the process's virtual address space into
+RAM if the process has the ability to run threads with different priorities. If
+unsuccessful, it prints an message to stderr and continues.</p>
+
+<p>On Linux, one can grant a process the ability to run threads with different
+priorities by using the command <code>ulimit -r unlimited</code>. To use the
+FIFO scheduler for an IOC, use a command like this:</p>
+
+<blockquote><pre>chrt -f 1 softIoc -d test.db</pre></blockquote>
+
+<p>On Linux, one can grant a process the ability to lock itself into memory
+using the command <code>ulimit -l unlimited</code>. These limits can also be
+configured on a per user/per group basis by changing /etc/security/limits.conf
+or its equivalent.</p>
+
+<p>A child process created via fork() normally inherits its parent's resource
+limits, so a child of a real-time soft-IOC will get its parent's real-time
+priority and memlock limits. The memory locks themselves however are not
+inherited by child processes.</p>
+
+<h3>Implement EPICS_CAS_INTF_ADDR_LIST in rsrv</h3>
+
+<p>The IOC server can now bind to a single IP address (and optional port number)
+read from the standard environment parameter EPICS_CAS_INTF_ADDR_LIST.
+Additional addresses included in that parameter after the first will be ignored
+and a warning message displayed at iocInit time.</p>
+
+<h3>alarmString.h deprecated again</h3>
+
+<p>The string arrays that provide string versions of the alarm status and
+severity values have been moved into libCom and the header file that used to
+instanciate them is no longer required, although a copy is still provided for
+backwards compatibility reasons. Only the alarm.h header needs to be included
+now to declare the epicsAlarmSeverityStrings and epicsAlarmConditionStrings
+arrays.</p>
+
+<h3>General purpose thread pool</h3>
+
+<p>
+A general purpose threaded work queue API epicsThreadPool is added.
+Multiple pools can be created with controlable priority and number
+of worker threads.  Lazy worker startup is supported.</p>
+
+<h3>Database field setting updates</h3>
+
+<p>A database (.db) file loaded by an IOC does not have to repeat the record
+type of a record that has already been loaded. It may replace the first
+parameter of the <tt>record(type, name)</tt> statement with an asterisk
+character inside double-quotes, <tt>"*"</tt> instead. Thus the following is a
+legal database file:</p>
+
+<blockquote><pre>record(ao, "ao1") {}
+record("*", "ao1") {
+    field(VAL, 10)
+}</pre></blockquote>
+
+<p>Note that database configuration tools will not be expected to have to
+understand this syntax, which is provided for scripted and hand-coded database
+and template instantiation only. Setting the IOC's <tt>dbRecordsOnceOnly</tt>
+flag also makes this syntax illegal, since its purpose is to prevent
+multiply-defined records from being collapsed into a single instance.</p>
+
+<h3>Added echo command to iocsh</h3>
+
+<p>The single argument string may contain escaped characters, which will be
+translated to their raw form before being printed (enclose the string in quotes
+to avoid double-translation). A newline is always appended to the output, and
+output stream redirection is supported.</p>
+
+<h3>Added macro EPICS_UNUSED to compilerDependencies.h</h3>
+
+<p>To prevent the compiler from warning about a known-unused variable, mark it
+with the macro EPICS_UNUSED. On gcc and clang this will expand to
+<tt>__attribute__((unused))</tt> to prevent the warning.</p>
+
+<h3>User specified db substitution file suffix</h3>
+
+<p>Per Dirk Zimoch's suggestion, a user specified db substitution file suffix is
+now allowed by setting the variable SUBST_SUFFIX in a configuration directory
+CONFIG_SITE file or in a Makefile before the include $(TOP)/configure/RULES
+line. The default for SUBST_SUFFIX is <tt>.substitutions</tt></p>
+
+<h3>NTP Time Provider adjusts to OS tick rate changes</h3>
+
+<p>Dirk Zimoch provided code that allows the NTP Time provider (used on VxWorks
+and RTEMS only) to adapt to changes in the OS clock tick rate after the provider
+has been initialized. Note that changing the tick rate after iocInit() is not
+advisable, and that other software might still misbehave if initialized before
+an OS tick rate change.</p>
+
+<h3>Added newEpicsMutex macro</h3>
+
+<p>Internal C++ uses of <tt>new epicsMutex()</tt> have been replaced with a new
+macro which calls a new constructor, passing it the file name and line number of
+the mutex creation code. C code that creates mutexes has been using a similar
+macro for a long time, but there was no equivalent constructor for the C++
+wrapper class, so identifying a specific mutex was much harder to do.</p>
+
+<h3>Post DBE_PROPERTY events automatically</h3>
+
+<p>A new record field attribute "prop(YES)" has been added to identify fields
+holding meta-data. External changes to these fields will cause a CA monitor
+event to be sent to all record subscribers who have asked for DBE_PROPERTY
+updates. Meta-data fields have been marked for all Base record types.</p>
+
+<h3>errlogRemoveListener() routine changed</h3>
+
+<p>Code that calls <tt>errlogRemoveListener(myfunc)</tt> must be modified to use
+the new, safer routine <tt>errlogRemoveListeners(myfunc, &amp;pvt)</tt> instead.
+The replacement routine takes a second argument which must be the same private
+pointer that was passed to <tt>errlogAddListener()</tt> when adding that
+listener. It also deletes all matching listeners (hence the new plural name) and
+returns how many were actually deleted, whereas the previous routine only
+removed the first listener that matched.</p>
+
+<h3>Simplified generation of .dbd files</h3>
+
+<p>The Perl script <tt>makeIncludeDbd.pl</tt> has been removed and the rules
+that created an intermediate <tt><i>xxx</i>Include.dbd</tt> file from the
+Makefile variable <tt>xxx_DBD</tt> have been modified to generate the target
+<tt><i>xxx</i>.dbd</tt> file directly. This should simplify applications that
+might have had to provide dependency rules for the intermediate files in 3.15.
+Applications which provide their own <tt><i>xxx</i>Include.dbd</tt> source file
+will continue to have it expanded as before.</p>
+
+<h3>New Undefined Severity field UDFS</h3>
+
+<p>A new field has been added to dbCommon which configures the alarm severity
+associated with the record being undefined (when UDF=TRUE). The default value is
+INVALID so old databases will not be affected, but now individual records can be
+configured to have a lower severity or even no alarm when undefined. Be careful
+when changing this on applications where the IVOA field of output records is
+used, IVOA still requires an INVALID severity to trigger value replacement.</p>
+
+<h3>New build target <q>tapfiles</q></h3>
+
+<p>This new make target runs the same tests as the <q>runtests</q> target, but
+instead of summarizing or displaying the output for each test script it creates
+a <q>.tap</q> file inside the architecture build directory which contains the
+detailed test output. The output file can be parsed by continuous integration
+packages such as <a href="http://www.jenkins-ci.org/">Jenkins</a> to show the
+test results.</p>
+
+<h3>Array field double-buffering</h3>
+
+<p>Array data can now be moved, without copying, into and out of the VAL field
+of the waveform, aai, and aao record types by replacing the pointer in BPTR.
+The basic rules which device support must follow are:</p>
+
+<ol>
+    <li>BPTR, and the memory it is currently pointing to, can only be accessed
+      while the record is locked.</li>
+    <li>NELM may not be changed; NORD should be updated whenever the number of
+      valid data elements changes.</li>
+    <li>When BPTR is replaced it must always point to a block of memory large
+      enough to hold the maximum number of elements, as given by the NELM and
+      FTVL fields.</li>
+</ol>
+
+<h3>Spin-locks API added</h3>
+
+<p>The new header file epicsSpin.h adds a portable spin-locks API which is
+intended for locking very short sections of code (typically one or two lines of
+C or C++) to provide a critical section that protects against race conditions.
+On Posix platforms this uses the pthread_spinlock_t type if it's available and
+the build is not configured to use Posix thread priorities, but otherwise it
+falls back to a pthread_mutex_t. On the UP VxWorks and RTEMS platforms the
+implementations lock out CPU interrupts and disable task preemption while a
+spin-lock is held. The default implementation (used when no other implementation
+is provided) uses an epicsMutex. Spin-locks may not be taken recursively, and
+the code inside the critical section should be short and deterministic.</p>
+
+<h3>Improvements to aToIPAddr()</h3>
+
+<p>The libCom routine aToIPAddr() and the vxWorks implementation of the
+associated hostToIPAddr() function have been modified to be able to look up
+hostnames that begin with one or more digits. The epicsSockResolveTest program
+was added to check this functionality.</p>
+
+<h3>mbboDirect and mbbiDirect records</h3>
+
+<p>These record types have undergone some significant rework, and will behave
+slightly differently than they did in their 3.14 versions. The externally
+visible changes are as follows:</p>
+
+<h5>mbbiDirect</h5>
+
+<ul>
+  <li>If the MASK field is set in a database file, it will not be over-written
+    when the record is initialized. This allows non-contiguous masks to be set,
+    although only the device support actually uses the MASK field.</li>
+  <li>If process() finds the UDF field to be set, the record will raise a
+    UDF/INVALID alarm.</li>
+</ul>
+
+<h5>mbboDirect</h5>
+
+<ul>
+  <li>If the MASK field is set in a database file, it will not be over-written
+    when the record is initialized. This allows non-contiguous masks to be set,
+    although only the device support actually uses the MASK field.</li>
+  <li>After the device support's init_record() routine returns during record
+    initialization, if OMSL is <q>supervisory</q> and UDF is clear the fields
+    B0-BF will be set from the current VAL field.</li>
+  <li>When a put to the OMSL field sets it to <q>supervisory</q>, the fields
+    B0-BF will be set from the current VAL field. This did not used to happen,
+    the individual bit fields were previously never modified by the record.
+    Note that this change may require some databases to be modified, if they
+    were designed to take advantage of the previous behavior.</li>
+</ul>
+
+<h3>Redirection of the errlog console stream</h3>
+
+<p>A new routine has been added to the errlog facility which allows the console
+error message stream to be redirected from stderr to some other already open
+file stream:</p>
+
+<blockquote><pre>int errlogSetConsole(FILE *stream);
+</pre></blockquote>
+
+<p>The stream argument must be a FILE* pointer as returned by fopen() that is
+open for output. If NULL is passed in, the errlog thread's stderr output stream
+will be used instead. Note that messages to the console can be disabled and
+re-enabled using the eltc routine which is also an iocsh command, but there is
+no iocsh command currently provided for calling errlogSetConsole.</p>
+
+<h3>Add cleanup subroutine to aSub record</h3>
+
+<p>An aSub routine may set the CADR field with a function pointer which will be
+run before a new routine in the event that a change to the SNAM field changes
+the record's process subroutine.</p>
+
+<p>This can be used to free any resources the routine needs to allocate. It can
+also be used to determine if this is the first time this routine has been called
+by this record instance. The CADR field is set to NULL immediately after the
+routine it points to is called.</p>
+
+<p>Example:</p>
+
+<blockquote><pre>void cleanup(aSubRecord* prec) {
+    free(prec-&gt;dpvt);
+    prec-&gt;dpvt = NULL;
+}
+
+long myAsubRoutine(aSubRecord* prec) {
+    if (!prec-&gt;cadr) {
+        /* check types of inputs and outputs */
+        if (prec-&gt;ftva != menuFtypeDOUBLE)
+            return 1; /* oops */
+
+        dpvt = malloc(42);
+        prec-&gt;cadr = &amp;cleanup;
+    }
+
+    /* normal processing */
+}
+epicsRegisterFunction(myAsubRoutine);
+</pre></blockquote>
+
+<h3>Sequence record enhancements</h3>
+
+<p>The sequence record type now has 16 link groups numbered 0 through 9 and A
+through F, instead of the previous 10 groups numbered 1 through 9 and A. The
+changes to this record are directly equivalent to those described below for the
+fanout record. The fields OFFS and SHFT have been added and operate on the SELN
+value exactly the same way. The result is backwards compatible with the 3.14
+version of the sequence record as long as none of the new fields are modified
+and the application does not rely on the SOFT/INVALID alarm that was generated
+when the selection number exceeded 10. The record also now posts monitors on the
+SELN field at the end of the sequence if its value changed when read through the
+SELL link.
+
+<h3>Fanout record enhancements</h3>
+
+<p>The fanout record type now has 16 output links LNK0-LNK9 and LNKA-LNKF, plus
+two additional fields which make the result backwards compatible with 3.14
+databases, but also allow the link selection to be shifted without having to
+process the SELN value through a calc or calcout record first.</p>
+
+<p>Previously there was no LNK0 field, so when SELM is <q>Mask</q> bit 0 of SELN
+controls whether the LNK1 link field was activated; bit 1 controls LNK2 and so
+on. When SELM is <q>Specified</q> and SELN is zero no output link would be
+activated at all; LNK1 gets activated when SELN is 1 and so on. Only 6 links
+were provided, LNK1 through LNK6. The updated record type maintains the original
+behavior when the new fields are not configured, except that the SOFT/INVALID
+alarm is not generated when SELN is 7 through 15.</p>
+
+<p>The update involved adding a LNK0 field, as well as fields LNK7 through LNK9
+and LNKA through LNKF. To add flexibility and maintain backwards compatibility,
+two additional fields have been added:</p>
+
+<dl>
+<dt><b>OFFS</b></dt>
+
+<dd>This field holds a signed offset which is added to SELN to select which link
+to activate when SELM is <q>Specified</q>. If the resulting value is outside the
+range 0 .. 15 the record will go into a SOFT/INVALID alarm state. The default
+value of OFFS is zero, so if it is not explicitly set and SELN is 1 the LNK1
+link will be activated.</dd>
+
+<dt><b>SHFT</b></dt>
+
+<dd>When SELM is <q>Mask</q> the signed field SHFT is used to shift the SELN
+value by SHFT bits (positive means right-wards, values outside the range -15 ..
+15 will result in a SOFT/INVALID alarm), before using the resulting bit-pattern
+to control which links to activate. The default value is -1, so if SHFT is not
+explicitly set bit 0 of SELN will be used to control whether LNK1 gets
+activated.</dd>
+
+</dl>
+
+<p>The record also now posts monitors on the SELN field if it changes as a
+result of record processing (i.e. when read through the SELL link).</p>
+
+<h3>Deleted Java build rules</h3>
+
+<p>Java has its own build systems now, so we've deleted the rules and associated
+variables from Base, although they might get added to the Extensions build rules
+for a while in case anyone still needs them.</p>
+
+<h2 align="center">Changes between 3.14.x and 3.15.0.1</h2>
+
+<h3>Application clean rules</h3>
+
+<p>The <tt>clean</tt> Makefile target has changed between a single-colon rule
+and a double-colon rule more than once in the life of the EPICS build rules, and
+it just changed back to a single-colon rule, but now we recommend that
+applications that wish to provide a Makefile that is backwards compatible with
+the 3.14 build rules use the construct shown below.  The 3.15 rules now support
+a variable called <tt>CLEANS</tt> to which a Makefile can add a list of files to
+be deleted when the user does a <tt>make clean</tt> like this:</p>
+
+<blockquote><pre>CLEANS += &lt;list of files to be cleaned&gt;
+
+ifndef BASE_3_15
+clean::
+	$(RM) $(CLEANS)
+endif</pre></blockquote>
+
+<p>The conditional rule provides compatibility for use with the 3.14 build
+system.</p>
+
+<h3>MSI included with Base</h3>
+
+<p>An enhanced version of the Macro Substitution and Include program <q>msi</q>
+has been included with Base. Both this new version of msi and the IOC's
+<tt>dbLoadTemplates</tt> command now support setting global macros in
+substitution files, and <tt>dbLoadTemplates</tt> can now take a list of global
+macro settings as the second argument on its command line. The substitution file
+syntax is documented in the Application Developers Guide.</p>
+
+<h3>Cross-builds targeting win32-x86-mingw</h3>
+
+<p>Some Linux distributions now package the MinGW cross-compiler which makes it
+possible to cross-build the win32-x86-mingw target from a linux-x86 host. Build
+configuration files for this combination are now included; adjust the settings
+in configure/os/CONFIG_SITE.linux-x86.win32-x86-mingw and add win32-x86-mingw to
+the CROSS_COMPILER_TARGET_ARCHS variable in configure/CONFIG_SITE or in
+configure/os/CONFIG_SITE.linux-x86.Common.</p>
+
+<h3>Architecture win32-x86-cygwin Removed</h3>
+
+<p>The ability to compile non-cygwin binaries using the Cygwin build tools is no
+longer supported by current versions of Cygwin, so this architecture has been
+removed. Use the MinWG tools and the win32-x86-mingw architecture instead.</p>
+
+<h3>RTEMS and VxWorks Test Harnesses</h3>
+
+<p>The original libCom test harness has been renamed <tt>libComTestHarness</tt>,
+and two additional test harnesses have been created <tt>dbTestHarness</tt> and
+<tt>filterTestHarness</tt> which are all built for RTEMS and vxWorks targets.
+The new ones include tests in src/ioc/db/test and src/std/filters/test.</p>
+
+<p>Running the new tests requires additional .db and .dbd files to be loaded at
+runtime, which can be found in the relevant source directory or its O.Common
+subdirectory. If the target can access the Base source tree directly it may be
+simplest to cd to the relevant source directory before running the test. If not,
+the files needed are listed in the generated 'testspec' file found in the
+associated build (O.<i>arch</i>) directory.</p>
+
+<p>For RTEMS users the current directory is determined in a BSP specific way.
+See rtems_init.c and setBootConfigFromNVRAM.c in src/libCom/RTEMS.</p>
+
+<h3>New API to hook into thread creation</h3>
+
+<p>A hook API has been added allowing user-supplied functions to be called
+whenever a thread starts. The calls are made from the thread's context,
+and can be used to control additional thread properties not handled inside
+EPICS base, e.g. setting the scheduling policy or CPU affinity (on SMP
+systems).</p>
+
+<p>The API also supports a mapping operation, calling a user-supplied function
+for every thread that is currently running.</p>
+
+<h3>New scan rate units</h3>
+
+<p>Scan rates defined in the menuScan.dbd file may now be specified in seconds,
+minutes, hours or Hertz, and plural time units will also be accepted (seconds
+are used if no unit is mentioned in the choice string). At <tt>iocInit</tt> each
+scan rate is compared with the OS's clock tick and a warning printed if the
+rate is too fast or likely to be more than 10% different to the requested rate.
+For example the rates given below are all valid, although non-standard (the
+default menuScan choices that come with Base have not been changed):</p>
+
+<blockquote>
+<pre>menu(menuScan) {
+    choice(menuScanPassive,     "Passive")
+    choice(menuScanEvent,       "Event")
+    choice(menuScanI_O_Intr,    "I/O Intr")
+    choice(menuScan1_hour,      "1 hour")
+    choice(menuScan0_5_hours, "0.5 hours")
+    choice(menuScan15_minutes, "15 minutes")
+    choice(menuScan5_minutes,   "5 minutes")
+    choice(menuScan1_minute,    "1 minute")
+    choice(menuScan10_seconds, "10 seconds")
+    choice(menuScan5_seconds,   "5 seconds")
+    choice(menuScan2_seconds,   "2 seconds")
+    choice(menuScan1_second,    "1 second")
+    choice(menuScan2_Hertz,     "2 Hertz")
+    choice(menuScan5_Hertz,     "5 Hertz")
+    choice(menuScan10_Hertz,   "10 Hz")
+}</pre></blockquote>
+
+<h3>Alarm filtering added to input record types</h3>
+
+<p>The record types ai, calc, longin and mbbi have a new alarm filter added to
+them. This provides a low-pass filter that can be used to delay the reporting of
+alarms caused by the input level passing the HIGH, HIHI, LOW or LOLO values. The
+filter is controlled with a new AFTC field that sets the filter's time constant.
+The default value for this field is zero, which keeps the record's original
+alarm behaviour.</p>
+
+<p>The record must be scanned often enough for the filtering action to work
+effectively and the alarm severity can only change when the record is processed,
+but that processing does not have to be regular; the filter uses the time since
+the record last processed in its calculation. Setting AFTC to a positive number
+of seconds will delay the record going into or out of a minor alarm severity or
+from minor to major severity until the input signal has been in that range for
+that number of seconds.</p>
+
+<h3>Post events on Waveform record's NORD field</h3>
+
+<p>When the record type or device support modify the NORD field of a waveform
+record, the record support code now posts DBE_VALUE and DBE_LOG events for that
+field, signalling the array length change to any client monitoring the NORD
+field.</p>
+
+<h3>Attributes of Non-VAL Fields</h3>
+
+<p>Non-VAL fields now report meaningful information for precision, units,
+graphic limits, control limits, and alarm limits instead of simply using
+PREC, EGU, HOPR, LOPR, DRVL, DRVH, HIHI, HIGH, LOW, and LOLO. All delay
+fields have a default precision of 2 digits, units "s" and control limits
+of 0 to 100,000 seconds (these precision and limit values can be changed
+for each record type as a whole at runtime by updating a registered global
+variable). Input fields like A-L of the calc record read their metadata
+from the corresponding INPn link if possible.</p>
+<h4>epicsStdioRedirect.h merged into epicsStdio.h</h4>
+
+<p>The definitions from the header file epicsStdioRedirect.h have been moved
+into epicsStdio.h so all calls to printf(), puts() and putchar() in files that
+include that OSI header will now be subject to stdout redirection.  In past
+releases (3.14.7 and later) it was necessary to request the redirection support
+by including the epicsStdioRedirect.h header file.  The header file is still
+provided, but now it just includes epicsStdio.h.</p>
+
+<h4>Named Soft Events</h4>
+
+<p>Soft events can now be given meaningful names instead of just using the
+numbers 1-255. The EVNT field is now a DBF_STRING. The <tt>post_event()</tt> API
+is now deprecated but still works. It should be replaced by code that in advance
+looks up the <tt>EVNTPVT</tt> event handle associated with the named event by
+calling <tt>eventNameToHandle(char *)</tt>, and when that event occurs passes
+that handle to the new <tt>postEvent(EVNTPVT)</tt> routine (which may be called
+from interrupt level). A new iocsh command <tt>postEvent <i>name</i></tt> will
+trigger a named event from the command-line or a startup script (on vxWorks the
+expression <tt>postEvent(eventNameToHandle("<i>name</i>"))</tt> must be used
+instead though).</p>
+
+<h4>Parallel Builds</h4>
+
+<p>
+As EPICS sites get computers with more CPUs they report additional bugs in our
+parallel build rules. Various issues have been fixed by separating out the build
+rules that generate dependency (.d) files, ensuring that they are constructed at
+the appropriate time in the build.</p>
+
+<p>
+These rule changes can cause additional warning messages to appear when building
+support modules. Where an application provides its own Makefile rules it may now
+have to add rules to construct an associated dependency file. In many cases
+though the change needed is just to replace a dependency for a
+<tt>target$(OBJ)</tt> with the <tt>target$(DEP)</tt> so this</p>
+
+<pre>
+    myLib$(OBJ): myLib_lex.c</pre>
+
+<p>
+becomes</p>
+
+<pre>
+    myLib$(DEP): myLib_lex.c</pre>
+
+<p>
+To debug build issues assocated with dependency files, use the command <tt>make
+--debug=m</tt> which tells GNUmake to display information about what it is doing
+during the first pass when it updates its makefiles.</p>
+
+<h3>
+Removed tsDefs.h</h3>
+
+<p>
+The deprecated tsDefs API was provided for 3.13 compatibility only, and has now
+been removed.  Convert any remaining code that used it to call the epicsTime API
+instead.</p>
+
+<h3>
+Changes to epicsVersion.h</h3>
+
+<p>
+The two macros <tt>EPICS_UPDATE_LEVEL</tt> and <tt>EPICS_CVS_SNAPSHOT</tt> have
+been deleted from the epicsVersion.h file; they were deprecated in R3.14 and can
+be replaced with <tt>EPICS_PATCH_LEVEL</tt> and <tt>EPICS_DEV_SNAPSHOT</tt>
+respectively.</p>
+
+<p>
+A new pair of macros has been added to make version number comparisons easier.
+Code that will not work with a version of Base before 3.15.0 can now be
+written like this to prevent it from compiling:</p>
+
+<pre style="margin: 0 2em;">
+#if defined(VERSION_INT) &amp;&amp; EPICS_VERSION_INT &lt; VERSION_INT(3,15,0,0)
+#  error EPICS Base R3.15.0 or later is required
+#endif
+</pre>
+
+<h3>
+Added support for iocLogPrefix</h3>
+
+<p>
+Added a <code>iocLogPrefix</code> command to <code>iocsh</code>. This adds a
+prefix to all messages from this IOC (or other log client) as they get sent to the
+iocLogServer. This lets sites use the "fac=&lt;<i>facility</i>&gt;" syntax for
+displaying the facility, process name etc. in log viewers like the
+<code>cmlogviewer</code>.</p>
+
+<h3>
+Reworked the epicsEvent C &amp; C++ APIs</h3>
+
+<ul>
+  <li>Renamed the enum epicsEventWaitStatus to epicsEventStatus</li>
+  <li>Defined epicsEventWaitStatus as a macro for epicsEventStatus</li>
+  <li>Renamed epicsEventWaitOk to epicsEventOk</li>
+  <li>Renamed epicsEventWaitError to epicsEventError</li>
+  <li>Defined epicsEventWaitOK and epicsEventWaitError as macros</li>
+  <li>Added epicsEventTrigger(id) which triggers an event and returns OK or an
+    error status if the underlying OS primitives report an error</li>
+  <li>Added epicsEventMustTrigger(id) which halts on error</li>
+  <li>Defined epicsEventSignal(id) as a macro for epicsEventMustTrigger(id)</li>
+  <li>Added a new C++ method epicsEvent::trigger() which throws an
+    epicsEvent::invalidSemaphore in the event of an error</li>
+  <li>epicsEvent::signal() makes an inline call to epicsEvent::trigger()</li>
+  <li>epicsEventWait() and epicsEventWaitWithTimeout() now return an error
+    status if the underlying OS primitives report an error</li>
+  <li>All the epicsEventMust...() routines are now implemented in the common
+    libCom/osi/epicsEvent.cpp source file, and call cantProceed() instead of
+    mis-using assert()</li>
+  <li>Implemented epicsEventShow() on Posix</li>
+  <li>Win32: Removed all epicsShareAPI decorations</li>
+</ul>
+
+<h3>
+Enabled histogram record type</h3>
+
+<p>
+The histogram record was not included in the base.dbd file in any 3.14 release,
+but has now been added along with its associated soft device support. The build
+system now generates the list of all the record.dbd files in base automatically
+in src/std/rec/Makefile.</p>
+
+<h3>
+Reorganization of src/</h3>
+
+<p>Reorganization of subdirectories of src/ to better represent the relation
+between different parts as described in the following table.</p>
+
+<p>This change also allows the number of libraries built to be reduced to:
+libCap5.so,  libca.so,   libdbCore.so,    libdbStaticHost.so,
+libCom.so,   libcas.so,  libdbRecStd.so, and  libgdd.so</p>
+
+<table border="1"><tbody>
+<tr>
+ <th>Component</th>
+ <th>Dependency</th>
+ <th>Library name</th>
+ <th>Description</th>
+</tr>
+<tr>
+ <td>src/tools</td>
+ <td></td>
+ <td></td>
+ <td>Build system scripts</td>
+</tr>
+<tr>
+ <td>src/libCom</td>
+ <td>src/tools</td>
+ <td>Com</td>
+ <td>Utility routines and OS-independant API</td>
+</tr>
+<tr>
+ <td>src/template</td>
+ <td>src/tools</td>
+ <td></td>
+ <td>User application templates (e.g. makeBaseApp)</td>
+</tr>
+<tr>
+ <td>src/ca/client</td>
+ <td>src/libCom</td>
+ <td>ca</td>
+ <td>Channel Access client</td>
+</tr>
+<tr>
+ <td>src/ca/legacy/gdd</td>
+ <td>src/ca/client</td>
+ <td>gdd</td>
+ <td>Generic data layer for PCAS</td>
+</tr>
+<tr>
+ <td>src/ca/legacy/pcas</td>
+ <td>src/ca/legacy/gdd</td>
+ <td>cas</td>
+ <td>Portable Channel Access Server</td>
+</tr>
+<tr>
+ <td>src/ioc</td>
+ <td>src/ca</td>
+ <td>dbCore</td>
+ <td>Core database processing functions</td>
+</tr>
+<tr>
+ <td>src/std</td>
+ <td>src/ioc</td>
+ <td>dbRecStd</td>
+ <td>Standard records, soft device support and the softIoc </td>
+</tr>
+</tbody></table>
+
+<p>
+In order to better reflect these relations the following
+directories and files were moved as described:</p>
+
+<table border="1"><tbody>
+<tr>
+  <th colspan="2">Relocations</th>
+</tr>
+<tr>
+  <th>Previous</th><th>New</th>
+</tr>
+<tr>
+  <th colspan="2">libCom</th>
+</tr>
+<tr>
+  <td>src/RTEMS</td>
+  <td>src/libCom/RTEMS</td>
+</tr>
+<tr>
+  <td>src/toolsComm/flex</td>
+  <td>src/libCom/flex</td>
+</tr>
+<tr>
+  <td>src/toolsComm/antelope</td>
+  <td>src/libCom/yacc</td>
+</tr>
+<tr>
+  <td align="right">src/dbStatic/alarm.h<br>.../alarmString.h</td>
+  <td>src/libCom/misc/</td>
+</tr>
+<tr>
+  <th colspan="2">IOC Core Components</th>
+</tr>
+<tr>
+  <td>src/bpt</td>
+  <td>src/ioc/bpt</td>
+</tr>
+<tr>
+  <td>src/db</td>
+  <td>src/ioc/db</td>
+</tr>
+<tr>
+  <td>src/dbStatic</td>
+  <td>src/ioc/dbStatic</td>
+</tr>
+<tr>
+  <td>src/dbtools</td>
+  <td>src/ioc/dbtemplate</td>
+</tr>
+<tr>
+  <td>src/misc</td>
+  <td>src/ioc/misc</td>
+</tr>
+<tr>
+  <td>src/registry</td>
+  <td>src/ioc/registry</td>
+</tr>
+<tr>
+  <td>src/rsrv</td>
+  <td>src/ioc/rsrv <a href="#rsrv">1</a></td>
+</tr>
+<tr>
+  <th colspan="2">Standard Record Definitions</th>
+</tr>
+<tr>
+  <td>src/dev/softDev</td>
+  <td>src/std/dev</td>
+</tr>
+<tr>
+  <td>src/rec</td>
+  <td>src/std/rec</td>
+</tr>
+<tr>
+  <td>src/softIoc</td>
+  <td>src/std/softIoc</td>
+</tr>
+<tr>
+  <th colspan="2">Channel Access</th>
+</tr>
+<tr>
+  <td>src/ca</td>
+  <td>src/ca/client</td>
+</tr>
+<tr>
+  <td>src/catools</td>
+  <td>src/ca/client/tools</td>
+</tr>
+<tr>
+  <td>src/cap5</td>
+  <td>src/ca/client/perl</td>
+</tr>
+<tr>
+  <td>src/gdd</td>
+  <td>src/ca/legacy/gdd</td>
+</tr>
+<tr>
+  <td>src/cas</td>
+  <td>src/ca/legacy/pcas</td>
+</tr>
+<tr>
+  <td>src/excas</td>
+  <td>src/ca/legacy/pcas/ex</td>
+</tr>
+<tr>
+  <th colspan="2">User Templates</th>
+</tr>
+<tr>
+  <td>src/makeBaseApp</td>
+  <td>src/template/base</td>
+</tr>
+<tr>
+  <td>src/makeBaseExt</td>
+  <td>src/template/ext</td>
+</tr>
+<tr>
+  <th colspan="2">Dispersed</th>
+</tr>
+<tr>
+  <td rowspan="3">src/util <a href="#util">2</a></td>
+  <td>src/ca/client</td>
+</tr>
+<tr>
+  <td>src/ca/client/test</td>
+</tr>
+<tr>
+  <td>src/libCom/log</td>
+</tr>
+<tr>
+  <td rowspan="2">src/as <a href="#as">3</a></td>
+  <td>src/libCom/as</td>
+</tr>
+<tr>
+  <td>src/ioc/as</td>
+</tr>
+</tbody></table>
+
+<p><a name="rsrv">1</a>
+RSRV is built as part of dbCore due to its tight (bidirectional) coupling
+with the other database code.</p>
+
+<p><a name="util">2</a>
+The contents for src/util/ moved to three locations.  The caRepeater init script
+was moved to src/ca/client/.  ca_test is now in src/ca/client/test/.
+The iocLogServer was moved into the same directory (src/libCom/log) as
+the log client code.</p>
+
+<p><a name="as">3</a>
+The Access Security code has been divided, with the parts not related to the 
+database (lexer/parser and trap registration) becoming part of libCom.
+The remaining components are included in the dbCore library</p>
+
+<h3>
+Moved src/RTEMS/base directory</h3>
+
+<p>
+These files are now found under src/RTEMS.</p>
+
+<h3>
+Removed 3.13 compatibility</h3>
+
+<p>
+Removed the 3.13 &lt;top&gt;/config directory and build compatibility rules and
+variables, and various conversion documents.</p>
+>>>>>>> MERGE-SOURCE
 
 </body>
 </html>

=== modified file 'src/ca/client/addrList.h'
--- src/ca/client/addrList.h	2008-09-19 23:27:52 +0000
+++ src/ca/client/addrList.h	2016-01-12 02:07:47 +0000
@@ -22,7 +22,7 @@
 epicsShareFunc void epicsShareAPI configureChannelAccessAddressList 
     ( struct ELLLIST *pList, SOCKET sock, unsigned short port );
 
-epicsShareFunc void epicsShareAPI addAddrToChannelAccessAddressList 
+epicsShareFunc int epicsShareAPI addAddrToChannelAccessAddressList
     ( struct ELLLIST *pList, const ENV_PARAM *pEnv, 
     unsigned short port, int ignoreNonDefaultPort );
 

=== modified file 'src/ca/client/iocinf.cpp'
--- src/ca/client/iocinf.cpp	2013-12-17 18:54:04 +0000
+++ src/ca/client/iocinf.cpp	2016-01-12 02:07:47 +0000
@@ -73,7 +73,7 @@
 /*
  * addAddrToChannelAccessAddressList ()
  */
-extern "C" void epicsShareAPI addAddrToChannelAccessAddressList 
+extern "C" int epicsShareAPI addAddrToChannelAccessAddressList
     ( ELLLIST *pList, const ENV_PARAM *pEnv, 
     unsigned short port, int ignoreNonDefaultPort )
 {
@@ -82,11 +82,11 @@
     const char *pToken;
     struct sockaddr_in addr;
     char buf[32u]; /* large enough to hold an IP address */
-    int status;
+    int status, ret = -1;
 
     pStr = envGetConfigParamPtr (pEnv);
     if (!pStr) {
-        return;
+        return ret;
     }
 
     while ( ( pToken = getToken (&pStr, buf, sizeof (buf) ) ) ) {
@@ -104,7 +104,7 @@
         pNewNode = (osiSockAddrNode *) calloc (1, sizeof(*pNewNode));
         if (pNewNode==NULL) {
             fprintf ( stderr, "addAddrToChannelAccessAddressList(): no memory available for configuration\n");
-            return;
+            break;
         }
 
         pNewNode->addr.ia = addr;
@@ -113,9 +113,10 @@
 		 * LOCK applied externally
 		 */
         ellAdd (pList, &pNewNode->node);
+        ret = 0; /* success if anything is added to the list */
     }
 
-    return;
+    return ret;
 }
 
 /*

=== modified file 'src/ca/client/udpiiu.cpp'
--- src/ca/client/udpiiu.cpp	2015-08-18 18:33:44 +0000
+++ src/ca/client/udpiiu.cpp	2016-01-12 02:07:47 +0000
@@ -163,6 +163,19 @@
         throwWithLocation ( noSocket () );
     }
 
+#ifdef IP_ADD_MEMBERSHIP
+    {
+        int flag = 1;
+        if(setsockopt(this->sock, IPPROTO_IP, IP_MULTICAST_LOOP, &flag, sizeof(flag))==-1)
+        {
+            char sockErrBuf[64];
+            epicsSocketConvertErrnoToString (
+                sockErrBuf, sizeof ( sockErrBuf ) );
+            errlogPrintf("CAC: failed to set mcast loopback\n");
+        }
+    }
+#endif
+
     int boolValue = true;
     int status = setsockopt ( this->sock, SOL_SOCKET, SO_BROADCAST, 
                 (char *) &boolValue, sizeof ( boolValue ) );

=== modified file 'src/ioc/dbStatic/dbLex.l'
--- src/ioc/dbStatic/dbLex.l	2009-01-09 18:00:00 +0000
+++ src/ioc/dbStatic/dbLex.l	2016-01-12 02:07:47 +0000
@@ -73,15 +73,20 @@
 {whitespace}	;
 
 {doublequote}({stringchar}|{escape})*{newline} { /* bad string */
-	yyerror("Newline in string, closing quote missing");
+	yyerrorAbort("Newline in string, closing quote missing");
 }
 
 .	{
 	char message[40];
 	YY_BUFFER_STATE *dummy=0;
 
-	sprintf(message,"Invalid character '%c'",yytext[0]);
-	yyerror(message);
+	if (isprint((int) yytext[0])) {
+	    sprintf(message, "Invalid character '%c'", yytext[0]);
+	}
+	else {
+	    sprintf(message, "Invalid character 0x%2.2x", yytext[0]);
+	}
+	yyerrorAbort(message);
 	/*The following suppresses compiler warning messages*/
 	if(FALSE) yyunput('c',(unsigned char *) message);
 	if(FALSE) yy_switch_to_buffer(*dummy);

=== modified file 'src/ioc/dbStatic/dbLexRoutines.c'
--- src/ioc/dbStatic/dbLexRoutines.c	2015-04-08 22:37:12 +0000
+++ src/ioc/dbStatic/dbLexRoutines.c	2016-01-12 02:07:47 +0000
@@ -12,6 +12,7 @@
 
 /*The routines in this module are serially reusable NOT reentrant*/
 
+#include <ctype.h>
 #include <epicsStdlib.h>
 #include <stddef.h>
 #include <stdio.h>

=== modified file 'src/ioc/dbStatic/dbStaticLib.c'
--- src/ioc/dbStatic/dbStaticLib.c	2015-08-20 16:24:07 +0000
+++ src/ioc/dbStatic/dbStaticLib.c	2016-01-12 02:07:47 +0000
@@ -477,7 +477,10 @@
 
 void dbFreeEntry(DBENTRY *pdbentry)
 {
-    if(pdbentry->message) free((void *)pdbentry->message);
+    if (!pdbentry)
+        return;
+    if (pdbentry->message)
+        free((void *)pdbentry->message);
     dbmfFree(pdbentry);
 }
 

=== modified file 'src/ioc/rsrv/camessage.c'
--- src/ioc/rsrv/camessage.c	2015-04-22 21:51:31 +0000
+++ src/ioc/rsrv/camessage.c	2016-01-12 02:07:47 +0000
@@ -1126,7 +1126,7 @@
     pclient = pciu->client;
     assert(pclient);
 
-    if(pclient == prsrv_cast_client){
+    if(pclient->proto==IPPROTO_UDP){
         return;
     }
 
@@ -1193,7 +1193,7 @@
     int             v41;
     int             status;
 
-    assert ( pciu->client != prsrv_cast_client );
+    assert ( pciu->client->proto!=IPPROTO_UDP );
 
     /*
      * noop if this is an old client
@@ -1321,7 +1321,7 @@
         }
     }
     else {
-        epicsMutexMustLock(prsrv_cast_client->chanListLock);
+        epicsMutexMustLock(client->chanListLock);
         /*
          * clients which dont claim their
          * channel in use block prior to
@@ -1331,7 +1331,7 @@
         if(!pciu){
             errlogPrintf("CAS: client timeout disconnect id=%d\n",
                 mp->m_cid);
-            epicsMutexUnlock(prsrv_cast_client->chanListLock);
+            epicsMutexUnlock(client->chanListLock);
             SEND_LOCK(client);
             send_err(
                 mp,
@@ -1343,33 +1343,15 @@
         }
 
         /*
-         * duplicate claim message are unacceptable
-         * (so we disconnect the client)
-         */
-        if (pciu->client!=prsrv_cast_client) {
-            errlogPrintf("CAS: duplicate claim disconnect id=%d\n",
-                mp->m_cid);
-            epicsMutexUnlock(prsrv_cast_client->chanListLock);
-            SEND_LOCK(client);
-            send_err(
-                mp,
-                ECA_INTERNAL,
-                client,
-                "duplicate claim in old connect protocol");
-            SEND_UNLOCK(client);
-            return RSRV_ERROR;
-        }
-
-        /*
          * remove channel in use block from
          * the UDP client where it could time
          * out and place it on the client
          * who is claiming it
          */
         ellDelete(
-            &prsrv_cast_client->chanList,
+            &client->chanList,
             &pciu->node);
-        epicsMutexUnlock(prsrv_cast_client->chanListLock);
+        epicsMutexUnlock(client->chanListLock);
 
         epicsMutexMustLock(client->chanListLock);
         pciu->state = rsrvCS_pendConnectResp;
@@ -2515,12 +2497,7 @@
     unsigned bytes_left;
     int status = RSRV_ERROR;
 
-    if ( ! pCaBucket ) {
-        pCaBucket = bucketCreate(CAS_HASH_TABLE_SIZE);
-        if(!pCaBucket){
-            return RSRV_ERROR;
-        }
-    }
+    assert(pCaBucket);
 
     /* drain remnents of large messages that will not fit */
     if ( client->recvBytesToDrain ) {
@@ -2623,7 +2600,7 @@
         if ( CASDEBUG > 2 )
             log_header (NULL, client, &msg, pBody, nmsg);
 
-        if ( client == prsrv_cast_client ) {
+        if ( client->proto==IPPROTO_UDP ) {
             if ( msg.m_cmmd < NELEMENTS ( udpJumpTable ) ) {
                 status = ( *udpJumpTable[msg.m_cmmd] )( &msg, pBody, client );
                 if (status!=RSRV_OK) {

=== modified file 'src/ioc/rsrv/caserverio.c'
--- src/ioc/rsrv/caserverio.c	2015-02-28 00:11:37 +0000
+++ src/ioc/rsrv/caserverio.c	2016-01-12 02:07:47 +0000
@@ -222,7 +222,7 @@
     /*
      * add placeholder for the first version message should it be needed
      */
-    rsrv_version_reply ( prsrv_cast_client );
+    rsrv_version_reply ( pclient );
 
     SEND_UNLOCK(pclient);
 

=== modified file 'src/ioc/rsrv/caservertask.c'
--- src/ioc/rsrv/caservertask.c	2015-02-28 00:11:37 +0000
+++ src/ioc/rsrv/caservertask.c	2016-01-12 02:07:47 +0000
@@ -32,6 +32,7 @@
 #include "osiPoolStatus.h"
 #include "osiSock.h"
 #include "taskwd.h"
+#include "cantProceed.h"
 
 #define epicsExportSharedSymbols
 #include "dbChannel.h"
@@ -58,113 +59,12 @@
  */
 static void req_server (void *pParm)
 {
-    unsigned priorityOfSelf = epicsThreadGetPrioritySelf ();
-    unsigned priorityOfBeacons;
-    epicsThreadBooleanStatus tbs;
-    osiSockAddrNode *pNode;
-    struct sockaddr_in serverAddr;  /* server's address */
-    osiSocklen_t addrSize = (osiSocklen_t) sizeof(struct sockaddr_in);
-    int status;
-    SOCKET clientSock;
-    epicsThreadId tid;
-    int portChange;
-
-    epicsSignalInstallSigPipeIgnore ();
+    rsrv_iface_config *conf = pParm;
+    SOCKET IOC_sock;
 
     taskwdInsert ( epicsThreadGetIdSelf (), NULL, NULL );
 
-    rsrvCurrentClient = epicsThreadPrivateCreate ();
-
-    if ( envGetConfigParamPtr ( &EPICS_CAS_SERVER_PORT ) ) {
-        ca_server_port = envGetInetPortConfigParam ( &EPICS_CAS_SERVER_PORT,
-            (unsigned short) CA_SERVER_PORT );
-    }
-    else {
-        ca_server_port = envGetInetPortConfigParam ( &EPICS_CA_SERVER_PORT,
-            (unsigned short) CA_SERVER_PORT );
-    }
-
-    addAddrToChannelAccessAddressList ( &casIntfAddrList,
-        &EPICS_CAS_INTF_ADDR_LIST, ca_server_port, 0 );
-    if (ellCount(&casIntfAddrList) == 0) {
-        pNode = (osiSockAddrNode *) calloc ( 1, sizeof(*pNode) );
-        pNode->addr.ia.sin_family = AF_INET;
-        pNode->addr.ia.sin_addr.s_addr = htonl ( INADDR_ANY );
-        pNode->addr.ia.sin_port = htons ( ca_server_port );
-        ellAdd ( &casIntfAddrList, &pNode->node );
-    }
-    else {
-        if (ellCount ( &casIntfAddrList ) > 1)
-            epicsPrintf ("CAS: Multiple entries in EPICS_CAS_INTF_ADDR_LIST, "
-                "only the first will be used.\n");
-        pNode = (osiSockAddrNode *) ellFirst ( &casIntfAddrList );
-    }
-
-    memcpy ( &serverAddr, &pNode->addr.ia, addrSize );
-
-    if (IOC_sock != 0 && IOC_sock != INVALID_SOCKET) {
-        epicsSocketDestroy ( IOC_sock );
-    }
-
-    /*
-     * Open the socket. Use ARPA Internet address format and stream
-     * sockets. Format described in <sys/socket.h>.
-     */
-    if ( ( IOC_sock = epicsSocketCreate (AF_INET, SOCK_STREAM, 0) ) == INVALID_SOCKET ) {
-        errlogPrintf ("CAS: Socket creation error\n");
-        epicsThreadSuspendSelf ();
-    }
-
-    epicsSocketEnableAddressReuseDuringTimeWaitState ( IOC_sock );
-
-    /* get server's Internet address */
-
-    status = bind(IOC_sock, (struct sockaddr *) &serverAddr, addrSize);
-    if ( status < 0 ) {
-        if ( SOCKERRNO == SOCK_EADDRINUSE ) {
-            /*
-             * enable assignment of a default port
-             * (so the getsockname() call below will
-             * work correctly)
-             */
-            serverAddr.sin_port = ntohs (0);
-            status = bind(IOC_sock, (struct sockaddr *) &serverAddr, addrSize);
-        }
-        if ( status < 0 ) {
-            char sockErrBuf[64];
-            epicsSocketConvertErrnoToString (
-                sockErrBuf, sizeof ( sockErrBuf ) );
-            errlogPrintf ( "CAS: Socket bind error was \"%s\"\n",
-                sockErrBuf );
-            epicsThreadSuspendSelf ();
-        }
-        portChange = 1;
-    }
-    else {
-        portChange = 0;
-    }
-
-    status = getsockname ( IOC_sock,
-            (struct sockaddr *)&serverAddr, &addrSize);
-    if ( status ) {
-        char sockErrBuf[64];
-        epicsSocketConvertErrnoToString (
-            sockErrBuf, sizeof ( sockErrBuf ) );
-        errlogPrintf ( "CAS: getsockname() error %s\n",
-            sockErrBuf );
-        epicsThreadSuspendSelf ();
-    }
-
-    ca_server_port = ntohs (serverAddr.sin_port);
-
-    if ( portChange ) {
-        errlogPrintf ( "cas warning: Configured TCP port was unavailable.\n");
-        errlogPrintf ( "cas warning: Using dynamically assigned TCP port %hu,\n",
-            ca_server_port );
-        errlogPrintf ( "cas warning: but now two or more servers share the same UDP port.\n");
-        errlogPrintf ( "cas warning: Depending on your IP kernel this server may not be\n" );
-        errlogPrintf ( "cas warning: reachable with UDP unicast (a host's IP in EPICS_CA_ADDR_LIST)\n" );
-    }
+    IOC_sock = conf->tcp;
 
     /* listen and accept new connections */
     if ( listen ( IOC_sock, 20 ) < 0 ) {
@@ -177,25 +77,10 @@
         epicsThreadSuspendSelf ();
     }
 
-    tbs  = epicsThreadHighestPriorityLevelBelow ( priorityOfSelf, &priorityOfBeacons );
-    if ( tbs != epicsThreadBooleanStatusSuccess ) {
-        priorityOfBeacons = priorityOfSelf;
-    }
-
-    beacon_startStopEvent = epicsEventMustCreate(epicsEventEmpty);
-    beacon_ctl = ctlPause;
-
-    tid = epicsThreadCreate ( "CAS-beacon", priorityOfBeacons,
-        epicsThreadGetStackSize (epicsThreadStackSmall),
-        rsrv_online_notify_task, 0 );
-    if ( tid == 0 ) {
-        epicsPrintf ( "CAS: unable to start beacon thread\n" );
-    }
-
-    epicsEventMustWait(beacon_startStopEvent);
     epicsEventSignal(castcp_startStopEvent);
 
     while (TRUE) {
+        SOCKET clientSock;
         struct sockaddr     sockAddr;
         osiSocklen_t        addLen = sizeof(sockAddr);
 
@@ -244,6 +129,275 @@
     }
 }
 
+static
+int tryBind(SOCKET sock, const osiSockAddr* addr, const char *name)
+{
+    if(bind(sock, &addr->ia, sizeof(*addr))<0) {
+        char sockErrBuf[64];
+        if(errno!=SOCK_EADDRINUSE)
+        {
+            epicsSocketConvertErrnoToString (
+                        sockErrBuf, sizeof ( sockErrBuf ) );
+            errlogPrintf ( "CAS: %s bind error: \"%s\"\n",
+                           name, sockErrBuf );
+            epicsThreadSuspendSelf ();
+        }
+        return -1;
+    } else
+        return 0;
+}
+
+/* need to collect a set of TCP sockets, one for each interface,
+ * which are bound to the same TCP port number.
+ * Needed to avoid the complications and confusion of different TCP
+ * ports for each interface (name server and beacon sender would need
+ * to know this).
+ */
+static
+SOCKET* rsrv_grap_tcp(unsigned short *port)
+{
+    SOCKET *socks;
+    osiSockAddr scratch;
+    unsigned i;
+
+    socks = mallocMustSucceed(ellCount(&casIntfAddrList)*sizeof(*socks), "rsrv_grap_tcp");
+    for(i=0; i<ellCount(&casIntfAddrList); i++)
+        socks[i] = INVALID_SOCKET;
+
+    /* start with preferred port */
+    memset(&scratch, 0, sizeof(scratch));
+    scratch.ia.sin_family = AF_INET;
+    scratch.ia.sin_port = htons(*port);
+
+    while(ellCount(&casIntfAddrList)>0) {
+        ELLNODE *cur, *next;
+        unsigned ok = 1;
+
+        for(i=0; i<ellCount(&casIntfAddrList); i++) {
+            if(socks[i] != INVALID_SOCKET)
+                epicsSocketDestroy(socks[i]);
+            socks[i] = INVALID_SOCKET;
+        }
+
+        for (i=0, cur=ellFirst(&casIntfAddrList), next = cur ? ellNext(cur) : NULL;
+             cur;
+             i++, cur=next, next=next ? ellNext(next) : NULL)
+        {
+            SOCKET tcpsock;
+            osiSockAddr ifaceAddr = ((osiSockAddrNode *)cur)->addr;
+
+            scratch.ia.sin_addr = ifaceAddr.ia.sin_addr;
+
+            tcpsock = socks[i] = epicsSocketCreate (AF_INET, SOCK_STREAM, 0);
+            if(tcpsock==INVALID_SOCKET)
+                cantProceed("rsrv ran out of sockets during initialization");
+
+            epicsSocketEnableAddressReuseDuringTimeWaitState ( tcpsock );
+
+            if(bind(tcpsock, &scratch.sa, sizeof(scratch))==0) {
+                if(scratch.ia.sin_port==0) {
+                    /* use first socket to pick a random port */
+                    assert(i==0);
+                    osiSocklen_t alen = sizeof(ifaceAddr);
+                    if(getsockname(tcpsock, &ifaceAddr.sa, &alen)) {
+                        char sockErrBuf[64];
+                        epicsSocketConvertErrnoToString (
+                            sockErrBuf, sizeof ( sockErrBuf ) );
+                        errlogPrintf ( "CAS: getsockname error was \"%s\"\n",
+                            sockErrBuf );
+                        epicsThreadSuspendSelf ();
+                        ok = 0;
+                        break;
+                    }
+                    scratch.ia.sin_port = ifaceAddr.ia.sin_port;
+                    assert(scratch.ia.sin_port!=0);
+                }
+            } else {
+                /* bind fails.  React harshly to unexpected errors to avoid an infinite loop */
+                if(errno==SOCK_EADDRNOTAVAIL) {
+                    /* this is not a bind()able address. */
+                    int j;
+                    char name[40];
+                    ipAddrToDottedIP(&scratch.ia, name, sizeof(name));
+                    printf("Skipping %s which is not an interface address\n", name);
+
+                    for(j=0; j<=i; j++) {
+                        epicsSocketDestroy(socks[j]);
+                        socks[j] = INVALID_SOCKET;
+                    }
+
+                    ellDelete(&casIntfAddrList, cur);
+                    free(cur);
+                    ok = 0;
+                    break;
+                }
+                /* if SOCK_EADDRINUSE then try again with a different port number.
+                 * otherwise, fail hard
+                 */
+                if(errno!=SOCK_EADDRINUSE && errno!=SOCK_EADDRNOTAVAIL) {
+                    char name[40];
+                    char sockErrBuf[64];
+                    epicsSocketConvertErrnoToString (
+                        sockErrBuf, sizeof ( sockErrBuf ) );
+                    ipAddrToDottedIP(&scratch.ia, name, sizeof(name));
+                    cantProceed( "CAS: Socket bind %s error was \"%s\"\n",
+                        name, sockErrBuf );
+                }
+                ok = 0;
+                break;
+            }
+        }
+
+        if (ok) {
+            assert(scratch.ia.sin_port!=0);
+            *port = ntohs(scratch.ia.sin_port);
+
+            break;
+        } else {
+
+            for(i=0; i<ellCount(&casIntfAddrList); i++) {
+                /* cleanup any ports actually bound */
+                if(socks[i]!=INVALID_SOCKET) {
+                    epicsSocketDestroy(socks[i]);
+                    socks[i] = INVALID_SOCKET;
+                }
+            }
+
+            scratch.ia.sin_port=0; /* next iteration starts with a random port */
+        }
+    }
+
+    if(ellCount(&casIntfAddrList)==0)
+        cantProceed("RSRV has empty interface list\n");
+
+    return socks;
+}
+
+static
+void rsrv_build_addr_lists(void)
+{
+    ELLLIST beacon_list = ELLLIST_INIT;
+    /* expandbcast==0 - add bcast addresses corresponding to the provided interface addresses.
+     * expandbcast==1 - binding to wildcard.  Fill beaconAddrList with all local addresses
+     */
+    int expandbcast = 0, autobeaconlist = 1;
+
+    /* the UDP ports are known at this point, but the TCP port is not */
+    assert(ca_beacon_port!=0);
+    assert(ca_udp_port!=0);
+
+    envGetBoolConfigParam(&EPICS_CAS_AUTO_BEACON_ADDR_LIST, &autobeaconlist);
+
+    ellInit ( &casIntfAddrList );
+    ellInit ( &beaconAddrList );
+    ellInit ( &casMCastAddrList );
+
+    {
+        ELLLIST temp = ELLLIST_INIT;
+        /* use the first parameter which is set. */
+        if(addAddrToChannelAccessAddressList ( &temp, &EPICS_CAS_INTF_ADDR_LIST, ca_udp_port, 0 ))
+            if(addAddrToChannelAccessAddressList ( &temp, &EPICS_CAS_BEACON_ADDR_LIST, ca_udp_port, 0 ))
+                addAddrToChannelAccessAddressList ( &temp, &EPICS_CA_ADDR_LIST, ca_udp_port, 1 );
+
+        removeDuplicateAddresses(&casIntfAddrList, &temp, 0);
+    }
+
+    {
+        /* check user provided list */
+        osiSockAddrNode *pNode, *pNext;
+        for(pNode = (osiSockAddrNode*)ellFirst(&casIntfAddrList),
+            pNext = pNode ? (osiSockAddrNode*)ellNext(&pNode->node) : NULL;
+            pNode;
+            pNode = pNext,
+            pNext = pNext ? (osiSockAddrNode*)ellNext(&pNext->node) : NULL)
+        {
+            epicsUInt32 top = ntohl(pNode->addr.ia.sin_addr.s_addr)>>24;
+
+            if(pNode->addr.ia.sin_family==AF_INET && pNode->addr.ia.sin_addr.s_addr==htonl(INADDR_ANY))
+            {
+                if (ellCount(&casIntfAddrList) != 1) {
+                    fprintf(stderr, "CAS address list can not contain 0.0.0.0 and other addresses, ignoring...\n");
+                    ellDelete(&casIntfAddrList, &pNode->node);
+                    free(pNode);
+                } else {
+                    expandbcast = 1;
+                }
+
+            } else if(pNode->addr.ia.sin_family==AF_INET && top>=224 && top<=239) {
+                /* This is a multi-cast address */
+                ellDelete(&casIntfAddrList, &pNode->node);
+                ellAdd(&casMCastAddrList, &pNode->node);
+            }
+        }
+    }
+
+    if (ellCount(&casIntfAddrList) == 0) {
+        /* default to wildcard 0.0.0.0 */
+        osiSockAddrNode *pNode = (osiSockAddrNode *) callocMustSucceed( 1, sizeof(*pNode), "rsrv_init" );
+        pNode->addr.ia.sin_family = AF_INET;
+        pNode->addr.ia.sin_addr.s_addr = htonl ( INADDR_ANY );
+        pNode->addr.ia.sin_port = 0;
+        ellAdd ( &casIntfAddrList, &pNode->node );
+        expandbcast = 1;
+    }
+
+    addAddrToChannelAccessAddressList ( &beaconAddrList,
+        &EPICS_CAS_BEACON_ADDR_LIST, ca_beacon_port, 0 );
+
+    beaconSocket = epicsSocketCreate(AF_INET, SOCK_DGRAM, 0);
+    if (beaconSocket==INVALID_SOCKET)
+        cantProceed("socket allocation failed during address list expansion");
+
+
+    {
+        int intTrue = 1;
+        if (setsockopt (beaconSocket, SOL_SOCKET, SO_BROADCAST,
+                        (char *)&intTrue, sizeof(intTrue))<0) {
+            cantProceed("CAS: online socket set up error\n");
+        }
+    }
+
+    if (!autobeaconlist) {
+        /* only user provided addresses */
+    } else if (expandbcast) {
+        /* add bcast addresses of all local interfaces */
+        osiSockAddr match;
+        memset(&match, 0, sizeof(match));
+        match.ia.sin_family = AF_INET;
+        match.ia.sin_addr.s_addr = htonl(INADDR_ANY);
+        match.ia.sin_port = htons(ca_beacon_port);
+
+        osiSockDiscoverBroadcastAddresses(&beacon_list, beaconSocket, &match);
+
+    } else {
+        /* add bcast addresses of only specified interfaces */
+        osiSockAddrNode *pNode;
+
+        for(pNode = (osiSockAddrNode*)ellFirst(&casIntfAddrList);
+            pNode;
+            pNode = (osiSockAddrNode*)ellNext(&pNode->node))
+        {
+            osiSockDiscoverBroadcastAddresses(&beacon_list, beaconSocket, &pNode->addr);
+        }
+    }
+
+    {
+        /* set the port for any automatically discovered destinations. */
+        osiSockAddrNode *pNode;
+        for(pNode = (osiSockAddrNode*)ellFirst(&beacon_list);
+            pNode;
+            pNode = (osiSockAddrNode*)ellNext(&pNode->node))
+        {
+            pNode->addr.ia.sin_port = htons(ca_beacon_port);
+        }
+    }
+
+    ellConcat(&beaconAddrList, &beacon_list);
+
+    if (ellCount(&beaconAddrList)==0)
+        fprintf(stderr, "Warning: RSRV has empty beacon address list\n");
+}
+
 static dbServer rsrv_server = {
     ELLNODE_INIT,
     "rsrv",
@@ -257,11 +411,9 @@
  */
 int rsrv_init (void)
 {
-    epicsThreadBooleanStatus tbs;
-    unsigned priorityOfConnectDaemon;
-    epicsThreadId tid;
     long maxBytesAsALong;
     long status;
+    SOCKET *socks;
 
     clientQlock = epicsMutexMustCreate();
 
@@ -272,8 +424,31 @@
     freeListInitPvt ( &rsrvSmallBufFreeListTCP, MAX_TCP, 16 );
     initializePutNotifyFreeList ();
 
+    epicsSignalInstallSigPipeIgnore ();
+
+    rsrvCurrentClient = epicsThreadPrivateCreate ();
+
     dbRegisterServer(&rsrv_server);
 
+    if ( envGetConfigParamPtr ( &EPICS_CAS_SERVER_PORT ) ) {
+        ca_server_port = envGetInetPortConfigParam ( &EPICS_CAS_SERVER_PORT,
+            (unsigned short) CA_SERVER_PORT );
+    }
+    else {
+        ca_server_port = envGetInetPortConfigParam ( &EPICS_CA_SERVER_PORT,
+            (unsigned short) CA_SERVER_PORT );
+    }
+    ca_udp_port = ca_server_port;
+
+    if (envGetConfigParamPtr(&EPICS_CAS_BEACON_PORT)) {
+        ca_beacon_port = envGetInetPortConfigParam (&EPICS_CAS_BEACON_PORT,
+            (unsigned short) CA_REPEATER_PORT );
+    }
+    else {
+        ca_beacon_port = envGetInetPortConfigParam (&EPICS_CA_REPEATER_PORT,
+            (unsigned short) CA_REPEATER_PORT );
+    }
+
     status =  envGetLongConfigParam ( &EPICS_CA_MAX_ARRAY_BYTES, &maxBytesAsALong );
     if ( status || maxBytesAsALong < 0 ) {
         errlogPrintf ( "CAS: EPICS_CA_MAX_ARRAY_BYTES was not a positive integer\n" );
@@ -298,41 +473,223 @@
         }
     }
     freeListInitPvt ( &rsrvLargeBufFreeListTCP, rsrvSizeofLargeBufTCP, 1 );
-    ellInit ( &casIntfAddrList );
-    ellInit ( &beaconAddrList );
-    prsrv_cast_client = NULL;
-    pCaBucket = NULL;
+    pCaBucket = bucketCreate(CAS_HASH_TABLE_SIZE);
+    if (!pCaBucket)
+        cantProceed("RSRV failed to allocate ID lookup table\n");
+
+    rsrv_build_addr_lists();
 
     castcp_startStopEvent = epicsEventMustCreate(epicsEventEmpty);
+    casudp_startStopEvent = epicsEventMustCreate(epicsEventEmpty);
+    beacon_startStopEvent = epicsEventMustCreate(epicsEventEmpty);
     castcp_ctl = ctlPause;
 
-    /*
-     * go down two levels so that we are below
-     * the TCP and event threads started on behalf
-     * of individual clients
-     */
-    tbs  = epicsThreadHighestPriorityLevelBelow (
-        epicsThreadPriorityCAServerLow, &priorityOfConnectDaemon );
-    if ( tbs == epicsThreadBooleanStatusSuccess ) {
-        tbs  = epicsThreadHighestPriorityLevelBelow (
-            priorityOfConnectDaemon, &priorityOfConnectDaemon );
-        if ( tbs != epicsThreadBooleanStatusSuccess ) {
-            priorityOfConnectDaemon = epicsThreadPriorityCAServerLow;
-        }
-    }
-    else {
-        priorityOfConnectDaemon = epicsThreadPriorityCAServerLow;
-    }
-
-    tid = epicsThreadCreate ( "CAS-TCP",
-        priorityOfConnectDaemon,
-        epicsThreadGetStackSize(epicsThreadStackMedium),
-        req_server, 0);
-    if ( tid == 0 ) {
-        epicsPrintf ( "CAS: unable to start connection request thread\n" );
-    }
-
-    epicsEventMustWait(castcp_startStopEvent);
+    /* Thread priorites
+     * Now starting per interface
+     *  TCP Listener: epicsThreadPriorityCAServerLow-2
+     *  Name receiver: epicsThreadPriorityCAServerLow-4
+     * Now starting global
+     *  Beacon sender: epicsThreadPriorityCAServerLow-3
+     * Started later per TCP client
+     *  TCP receiver: epicsThreadPriorityCAServerLow
+     *  TCP sender : epicsThreadPriorityCAServerLow-1
+     */
+    {
+        unsigned i;
+        threadPrios[0] = epicsThreadPriorityCAServerLow;
+
+        for(i=1; i<NELEMENTS(threadPrios); i++)
+        {
+            if(epicsThreadBooleanStatusSuccess!=epicsThreadHighestPriorityLevelBelow(
+                        threadPrios[i-1], &threadPrios[i]))
+            {
+                /* on failure use the lowest known */
+                threadPrios[i] = threadPrios[i-1];
+            }
+        }
+    }
+
+    {
+        unsigned short sport = ca_server_port;
+        socks = rsrv_grap_tcp(&sport);
+
+        if ( sport != ca_server_port ) {
+            ca_server_port = sport;
+            errlogPrintf ( "cas warning: Configured TCP port was unavailable.\n");
+            errlogPrintf ( "cas warning: Using dynamically assigned TCP port %hu,\n",
+                ca_server_port );
+            errlogPrintf ( "cas warning: but now two or more servers share the same UDP port.\n");
+            errlogPrintf ( "cas warning: Depending on your IP kernel this server may not be\n" );
+            errlogPrintf ( "cas warning: reachable with UDP unicast (a host's IP in EPICS_CA_ADDR_LIST)\n" );
+        }
+    }
+
+    /* start servers (TCP and UDP(s) for each interface.
+     */
+    {
+        int havesometcp = 0;
+        ELLNODE *cur;
+        int i;
+
+        for (i=0, cur=ellFirst(&casIntfAddrList); cur; i++, cur=ellNext(cur))
+        {
+            char ifaceName[40];
+            rsrv_iface_config *conf;
+
+            conf = callocMustSucceed(1, sizeof(*conf), "rsrv_init");
+
+            conf->tcpAddr = ((osiSockAddrNode *)cur)->addr;
+            conf->tcpAddr.ia.sin_port = htons(ca_server_port);
+            conf->tcp = socks[i];
+            socks[i] = INVALID_SOCKET;
+
+            ipAddrToDottedIP (&conf->tcpAddr.ia, ifaceName, sizeof(ifaceName));
+
+            conf->udp = conf->udpbcast = INVALID_SOCKET;
+
+            /* create and bind UDP name receiver socket(s) */
+
+            conf->udp = epicsSocketCreate(AF_INET, SOCK_DGRAM, 0);
+            if(conf->udp==INVALID_SOCKET)
+                cantProceed("rsrv_init ran out of udp sockets");
+
+            conf->udpAddr = conf->tcpAddr;
+            conf->udpAddr.ia.sin_port = htons(ca_udp_port);
+
+            epicsSocketEnableAddressUseForDatagramFanout ( conf->udp );
+
+            if(tryBind(conf->udp, &conf->udpAddr, "UDP unicast socket"))
+                goto cleanup;
+
+#ifdef IP_ADD_MEMBERSHIP
+            /* join UDP socket to any multicast groups */
+            {
+                osiSockAddrNode *pNode;
+
+                for(pNode = (osiSockAddrNode*)ellFirst(&casMCastAddrList);
+                    pNode;
+                    pNode = (osiSockAddrNode*)ellNext(&pNode->node))
+                {
+                    struct ip_mreq mreq;
+
+                    memset(&mreq, 0, sizeof(mreq));
+                    mreq.imr_multiaddr = pNode->addr.ia.sin_addr;
+                    mreq.imr_interface.s_addr = conf->udpAddr.ia.sin_addr.s_addr;
+
+                    if(setsockopt(conf->udp, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq))!=0)
+                    {
+                        struct sockaddr_in temp;
+                        char name[40];
+                        char sockErrBuf[64];
+                        temp.sin_family = AF_INET;
+                        temp.sin_addr = mreq.imr_multiaddr;
+                        temp.sin_port = conf->udpAddr.ia.sin_port;
+                        epicsSocketConvertErrnoToString (
+                            sockErrBuf, sizeof ( sockErrBuf ) );
+                        ipAddrToDottedIP (&temp, name, sizeof(name));
+                        fprintf(stderr, "CAS: Socket mcast join %s to %s failed with \"%s\"\n",
+                            ifaceName, name, sockErrBuf );
+                    }
+                }
+            }
+#else
+            if(ellCount(&casMCastAddrList)){
+                fprintf(stderr, "IPv4 Multicast name lookup not supported by this target\n");
+            }
+#endif
+
+#if !defined(_WIN32)
+            /* An oddness of BSD sockets (not winsock) is that binding to
+             * INADDR_ANY will receive unicast and broadcast, but binding to
+             * a specific interface address receives only unicast.  The trick
+             * is to bind a second socket to the interface broadcast address,
+             * which will then receive only broadcasts.
+             */
+            if(conf->udpAddr.ia.sin_addr.s_addr!=htonl(INADDR_ANY)) {
+                /* find interface broadcast address */
+                ELLLIST bcastList = ELLLIST_INIT;
+                osiSockAddrNode *pNode;
+
+                osiSockDiscoverBroadcastAddresses (&bcastList,
+                                                   conf->udp, &conf->udpAddr); // match addr
+
+                if(ellCount(&bcastList)==0) {
+                    fprintf(stderr, "Warning: Can't find broadcast address of interface %s\n"
+                                    "         Name lookup may not work on this interface\n", ifaceName);
+                } else {
+                    if(ellCount(&bcastList)>1 && conf->udpAddr.ia.sin_addr.s_addr!=htonl(INADDR_ANY))
+                        printf("Interface %s has more than one broadcast address?\n", ifaceName);
+
+                    pNode = (osiSockAddrNode*)ellFirst(&bcastList);
+
+                    conf->udpbcast = epicsSocketCreate(AF_INET, SOCK_DGRAM, 0);
+                    if(conf->udpbcast==INVALID_SOCKET)
+                        cantProceed("rsrv_init ran out of udp sockets for bcast");
+
+                    epicsSocketEnableAddressUseForDatagramFanout ( conf->udpbcast );
+
+                    conf->udpbcastAddr = conf->udpAddr;
+                    conf->udpbcastAddr.ia.sin_addr.s_addr = pNode->addr.ia.sin_addr.s_addr;
+
+                    if(tryBind(conf->udpbcast, &conf->udpbcastAddr, "UDP Socket bcast"))
+                        goto cleanup;
+                }
+
+                ellFree(&bcastList);
+            }
+
+            ellAdd(&servers, &conf->node);
+
+#endif /* !defined(_WIN32) */
+
+            /* have all sockets, time to start some threads */
+
+            epicsThreadMustCreate("CAS-TCP", threadPrios[2],
+                    epicsThreadGetStackSize(epicsThreadStackMedium),
+                    &req_server, conf);
+
+            epicsEventMustWait(castcp_startStopEvent);
+
+            epicsThreadMustCreate("CAS-UDP", threadPrios[4],
+                    epicsThreadGetStackSize(epicsThreadStackMedium),
+                    &cast_server, conf);
+
+            epicsEventMustWait(casudp_startStopEvent);
+
+#if !defined(_WIN32)
+            if(conf->udpbcast != INVALID_SOCKET) {
+                conf->startbcast = 1;
+
+                epicsThreadMustCreate("CAS-UDP2", threadPrios[4],
+                        epicsThreadGetStackSize(epicsThreadStackMedium),
+                        &cast_server, conf);
+
+                epicsEventMustWait(casudp_startStopEvent);
+
+                conf->startbcast = 0;
+            }
+#endif /* !defined(_WIN32) */
+
+            havesometcp = 1;
+            continue;
+        cleanup:
+            epicsSocketDestroy(conf->tcp);
+            if(conf->udp!=INVALID_SOCKET) epicsSocketDestroy(conf->udp);
+            if(conf->udpbcast!=INVALID_SOCKET) epicsSocketDestroy(conf->udpbcast);
+            free(conf);
+        }
+
+        if(!havesometcp)
+            cantProceed("CAS: No TCP server started\n");
+    }
+
+    /* servers list is considered read-only from this point */
+
+    epicsThreadMustCreate("CAS-beacon", threadPrios[3],
+            epicsThreadGetStackSize(epicsThreadStackSmall),
+            &rsrv_online_notify_task, NULL);
+
+    epicsEventMustWait(beacon_startStopEvent);
 
     return RSRV_OK;
 }
@@ -499,11 +856,49 @@
         log_one_client(client, level);
         client = (struct client *) ellNext(&client->node);
     }
+
+    if (level>=2) {
+        rsrv_iface_config *client = (rsrv_iface_config *) ellFirst ( &servers );
+        while (client) {
+            char    buf[40];
+
+            ipAddrToDottedIP (&client->tcpAddr.ia, buf, sizeof(buf));
+            printf("Server interface %s\n", buf);
+
+            ipAddrToDottedIP (&client->udpAddr.ia, buf, sizeof(buf));
+            printf(" UDP receiver 1 %s\n", buf);
+
+#if !defined(_WIN32)
+            if(client->udpbcast!=INVALID_SOCKET) {
+                ipAddrToDottedIP (&client->udpbcastAddr.ia, buf, sizeof(buf));
+                printf(" UDP receiver 2 %s\n", buf);
+            }
+#endif
+
+            client = (rsrv_iface_config *) ellNext(&client->node);
+        }
+    }
     UNLOCK_CLIENTQ
-
-    if (level>=2 && prsrv_cast_client) {
-        printf( "UDP Server:\n" );
-        log_one_client(prsrv_cast_client, level);
+    if (level>=2) {
+        osiSockAddrNode * pAddr;
+        for(pAddr = (osiSockAddrNode*)ellFirst(&casMCastAddrList);
+            pAddr;
+            pAddr = (osiSockAddrNode*)ellNext(&pAddr->node))
+        {
+            char    buf[40];
+
+            ipAddrToDottedIP (&pAddr->addr.ia, buf, sizeof(buf));
+            printf("MCast destination %s\n", buf);
+        }
+        for(pAddr = (osiSockAddrNode*)ellFirst(&beaconAddrList);
+            pAddr;
+            pAddr = (osiSockAddrNode*)ellNext(&pAddr->node))
+        {
+            char    buf[40];
+
+            ipAddrToDottedIP (&pAddr->addr.ia, buf, sizeof(buf));
+            printf("Beacon destination %s\n", buf);
+        }
     }
 
     if (level>=2u) {
@@ -532,12 +927,10 @@
             MAX_TCP,
             (unsigned int) freeListItemsAvail ( rsrvLargeBufFreeListTCP ),
             rsrvSizeofLargeBufTCP );
-        if(pCaBucket){
-            printf( "The server's resource id conversion table:\n");
-            LOCK_CLIENTQ;
-            bucketShow (pCaBucket);
-            UNLOCK_CLIENTQ;
-        }
+        printf( "The server's resource id conversion table:\n");
+        LOCK_CLIENTQ;
+        bucketShow (pCaBucket);
+        UNLOCK_CLIENTQ;
         printf ( "The server's array size limit is %u bytes max\n",
             rsrvSizeofLargeBufTCP );
 

=== modified file 'src/ioc/rsrv/cast_server.c'
--- src/ioc/rsrv/cast_server.c	2014-10-06 05:57:02 +0000
+++ src/ioc/rsrv/cast_server.c	2016-01-12 02:07:47 +0000
@@ -54,7 +54,7 @@
 /*
  * clean_addrq
  */
-static void clean_addrq(void)
+static void clean_addrq(struct client *client)
 {
     struct channel_in_use * pciu;
     struct channel_in_use * pnextciu;
@@ -67,9 +67,9 @@
 
     epicsTimeGetCurrent ( &current );
 
-    epicsMutexMustLock ( prsrv_cast_client->chanListLock );
+    epicsMutexMustLock ( client->chanListLock );
     pnextciu = (struct channel_in_use *) 
-            prsrv_cast_client->chanList.node.next;
+            client->chanList.node.next;
 
     while( (pciu = pnextciu) ) {
         pnextciu = (struct channel_in_use *)pciu->node.next;
@@ -77,7 +77,7 @@
         delay = epicsTimeDiffInSeconds(&current,&pciu->time_at_creation);
         if (delay > timeout) {
 
-            ellDelete(&prsrv_cast_client->chanList, &pciu->node);
+            ellDelete(&client->chanList, &pciu->node);
             LOCK_CLIENTQ;
             s = bucketRemoveItemUnsignedId (
                 pCaBucket,
@@ -96,7 +96,7 @@
             if(delay>maxdelay) maxdelay = delay;
         }
     }
-    epicsMutexUnlock ( prsrv_cast_client->chanListLock );
+    epicsMutexUnlock ( client->chanListLock );
 
 #   ifdef DEBUG
     if(ndelete){
@@ -115,70 +115,23 @@
  */
 void cast_server(void *pParm)
 {
-    osiSockAddrNode     *paddrNode;
-    struct sockaddr_in  sin;
+    rsrv_iface_config *conf = pParm;
     int                 status;
     int                 count=0;
+    int                 mysocket=0;
     struct sockaddr_in  new_recv_addr;
     osiSocklen_t        recv_addr_size;
     osiSockIoctl_t      nchars;
+    SOCKET              recv_sock, reply_sock;
+    struct client      *client;
 
     recv_addr_size = sizeof(new_recv_addr);
 
-    if( IOC_cast_sock!=0 && IOC_cast_sock!=INVALID_SOCKET ) {
-        epicsSocketDestroy ( IOC_cast_sock );
-    }
-
-    /* 
-     *  Open the socket.
-     *  Use ARPA Internet address format and datagram socket.
-     */
-
-    if ( ( IOC_cast_sock = epicsSocketCreate (AF_INET, SOCK_DGRAM, 0) ) == INVALID_SOCKET ) {
-        epicsPrintf ("CAS: cast socket creation error\n");
-        epicsThreadSuspendSelf ();
-    }
-
-    /*
-     * some concern that vxWorks will run out of mBuf's
-     * if this change is made
-     *
-     * joh 11-10-98
-     */
-#if 0
-    {
-        /*
-         *
-         * this allows for faster connects by queuing
-         * additional incomming UDP search frames
-         *
-         * this allocates a 32k buffer
-         * (uses a power of two)
-         */
-        int size = 1u<<15u;
-        status = setsockopt (IOC_cast_sock, SOL_SOCKET,
-                        SO_RCVBUF, (char *)&size, sizeof(size));
-        if (status<0) {
-            epicsPrintf ("CAS: unable to set cast socket size\n");
-        }
-    }
-#endif
-
-    epicsSocketEnableAddressUseForDatagramFanout ( IOC_cast_sock );
-
-    paddrNode = (osiSockAddrNode *) ellFirst ( &casIntfAddrList );
-
-    memcpy(&sin, &paddrNode->addr.ia, sizeof (sin));
-
-    /* get server's Internet address */
-    if( bind(IOC_cast_sock, (struct sockaddr *)&sin, sizeof (sin)) < 0){
-        char sockErrBuf[64];
-        epicsSocketConvertErrnoToString ( 
-            sockErrBuf, sizeof ( sockErrBuf ) );
-        epicsPrintf ("CAS: UDP server port bind error was \"%s\"\n", sockErrBuf );
-        epicsSocketDestroy ( IOC_cast_sock );
-        epicsThreadSuspendSelf ();
-    }
+    reply_sock = conf->udp;
+    if(conf->startbcast)
+        recv_sock = conf->udpbcast;
+    else
+        recv_sock = conf->udp;
 
     /*
      * setup new client structure but reuse old structure if
@@ -186,27 +139,31 @@
      *
      */
     while ( TRUE ) {
-        prsrv_cast_client = create_client ( IOC_cast_sock, IPPROTO_UDP );
-        if ( prsrv_cast_client ) {
+        client = create_client ( reply_sock, IPPROTO_UDP );
+        if ( client ) {
             break;
         }
         epicsThreadSleep(300.0);
     }
+    client->udpRecv = recv_sock;
 
-    casAttachThreadToClient ( prsrv_cast_client );
+    casAttachThreadToClient ( client );
 
     /*
      * add placeholder for the first version message should it be needed
      */
-    rsrv_version_reply ( prsrv_cast_client );
+    rsrv_version_reply ( client );
+
+    /* these pointers become invalid after signaling casudp_startStopEvent */
+    conf = NULL;
 
     epicsEventSignal(casudp_startStopEvent);
 
     while (TRUE) {
         status = recvfrom (
-            IOC_cast_sock,
-            prsrv_cast_client->recv.buf,
-            prsrv_cast_client->recv.maxstk,
+            recv_sock,
+            client->recv.buf,
+            client->recv.maxstk,
             0,
             (struct sockaddr *)&new_recv_addr, 
             &recv_addr_size);
@@ -221,69 +178,69 @@
             }
         }
         else if (casudp_ctl == ctlRun) {
-            prsrv_cast_client->recv.cnt = (unsigned) status;
-            prsrv_cast_client->recv.stk = 0ul;
-            epicsTimeGetCurrent(&prsrv_cast_client->time_at_last_recv);
+            client->recv.cnt = (unsigned) status;
+            client->recv.stk = 0ul;
+            epicsTimeGetCurrent(&client->time_at_last_recv);
 
-            prsrv_cast_client->minor_version_number = 0;
-            prsrv_cast_client->seqNoOfReq = 0;
+            client->minor_version_number = 0;
+            client->seqNoOfReq = 0;
 
             /*
              * If we are talking to a new client flush to the old one 
              * in case we are holding UDP messages waiting to 
              * see if the next message is for this same client.
              */
-            if (prsrv_cast_client->send.stk>sizeof(caHdr)) {
-                status = memcmp(&prsrv_cast_client->addr, 
+            if (client->send.stk>sizeof(caHdr)) {
+                status = memcmp(&client->addr,
                     &new_recv_addr, recv_addr_size);
                 if(status){     
                     /* 
                      * if the address is different 
                      */
-                    cas_send_dg_msg(prsrv_cast_client);
-                    prsrv_cast_client->addr = new_recv_addr;
+                    cas_send_dg_msg(client);
+                    client->addr = new_recv_addr;
                 }
             }
             else {
-                prsrv_cast_client->addr = new_recv_addr;
+                client->addr = new_recv_addr;
             }
 
             if (CASDEBUG>1) {
                 char    buf[40];
     
-                ipAddrToDottedIP (&prsrv_cast_client->addr, buf, sizeof(buf));
+                ipAddrToDottedIP (&client->addr, buf, sizeof(buf));
                 errlogPrintf ("CAS: cast server msg of %d bytes from addr %s\n", 
-                    prsrv_cast_client->recv.cnt, buf);
+                    client->recv.cnt, buf);
             }
 
             if (CASDEBUG>2)
-                count = ellCount (&prsrv_cast_client->chanList);
+                count = ellCount (&client->chanList);
 
-            status = camessage ( prsrv_cast_client );
+            status = camessage ( client );
             if(status == RSRV_OK){
-                if(prsrv_cast_client->recv.cnt != 
-                    prsrv_cast_client->recv.stk){
+                if(client->recv.cnt !=
+                    client->recv.stk){
                     char buf[40];
         
-                    ipAddrToDottedIP (&prsrv_cast_client->addr, buf, sizeof(buf));
+                    ipAddrToDottedIP (&client->addr, buf, sizeof(buf));
 
                     epicsPrintf ("CAS: partial (damaged?) UDP msg of %d bytes from %s ?\n",
-                        prsrv_cast_client->recv.cnt-prsrv_cast_client->recv.stk, buf);
+                        client->recv.cnt-client->recv.stk, buf);
                 }
             }
             else {
                 char buf[40];
     
-                ipAddrToDottedIP (&prsrv_cast_client->addr, buf, sizeof(buf));
+                ipAddrToDottedIP (&client->addr, buf, sizeof(buf));
 
                 epicsPrintf ("CAS: invalid (damaged?) UDP request from %s ?\n", buf);
             }
 
             if (CASDEBUG>2) {
-                if ( ellCount (&prsrv_cast_client->chanList) ) {
+                if ( ellCount (&client->chanList) ) {
                     errlogPrintf ("CAS: Fnd %d name matches (%d tot)\n",
-                        ellCount(&prsrv_cast_client->chanList)-count,
-                        ellCount(&prsrv_cast_client->chanList));
+                        ellCount(&client->chanList)-count,
+                        ellCount(&client->chanList));
                 }
             }
         }
@@ -292,15 +249,22 @@
          * allow messages to batch up if more are comming
          */
         nchars = 0; /* supress purify warning */
-        status = socket_ioctl(IOC_cast_sock, FIONREAD, &nchars);
+        status = socket_ioctl(recv_sock, FIONREAD, &nchars);
         if (status<0) {
             errlogPrintf ("CA cast server: Unable to fetch N characters pending\n");
-            cas_send_dg_msg (prsrv_cast_client);
-            clean_addrq ();
+            cas_send_dg_msg (client);
+            clean_addrq (client);
         }
         else if (nchars == 0) {
-            cas_send_dg_msg (prsrv_cast_client);
-            clean_addrq ();
+            cas_send_dg_msg (client);
+            clean_addrq (client);
         }
     }
+
+    /* ATM never reached, just a placeholder */
+
+    if(!mysocket)
+        client->sock = INVALID_SOCKET; /* only one cast_server should destroy the reply socket */
+    destroy_client(client);
+    epicsSocketDestroy(recv_sock);
 }

=== modified file 'src/ioc/rsrv/online_notify.c'
--- src/ioc/rsrv/online_notify.c	2014-10-06 05:57:02 +0000
+++ src/ioc/rsrv/online_notify.c	2016-01-12 02:07:47 +0000
@@ -36,45 +36,18 @@
 #include "server.h"
 
 /*
- * forcePort ()
- */
-static void  forcePort (ELLLIST *pList, unsigned short port)
-{
-    osiSockAddrNode *pNode;
-
-    pNode  = (osiSockAddrNode *) ellFirst ( pList );
-    while ( pNode ) {
-        if ( pNode->addr.sa.sa_family == AF_INET ) {
-            pNode->addr.ia.sin_port = htons ( port );
-        }
-        pNode = (osiSockAddrNode *) ellNext ( &pNode->node );
-    }
-}
-
-/*
  *  RSRV_ONLINE_NOTIFY_TASK
  */
 void rsrv_online_notify_task(void *pParm)
 {
-    unsigned                    priorityOfSelf = epicsThreadGetPrioritySelf ();
-    osiSockAddrNode             *pNode;
     double                      delay;
     double                      maxdelay;
     long                        longStatus;
     double                      maxPeriod;
     caHdr                       msg;
     int                         status;
-    SOCKET                      sock;
-    int                         intTrue = TRUE;
-    unsigned short              port;
     ca_uint32_t                 beaconCounter = 0;
-    char                        * pStr;
-    int                         autoBeaconAddr;
-    ELLLIST                     autoAddrList;
     char                        buf[16];
-    unsigned                    priorityOfUDP;
-    epicsThreadBooleanStatus    tbs;
-    epicsThreadId               tid;
     
     taskwdInsert (epicsThreadGetIdSelf(),NULL,NULL);
     
@@ -94,189 +67,34 @@
     
     delay = 0.02; /* initial beacon period in sec */
     maxdelay = maxPeriod;
-    
-    /* 
-     *  Open the socket.
-     *  Use ARPA Internet address format and datagram socket.
-     *  Format described in <sys/socket.h>.
-     */
-    if ( (sock = epicsSocketCreate (AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET) {
-        errlogPrintf ("CAS: online socket creation error\n");
-        epicsThreadSuspendSelf ();
-    }
-    
-    status = setsockopt (sock, SOL_SOCKET, SO_BROADCAST, 
-                (char *)&intTrue, sizeof(intTrue));
-    if (status<0) {
-        errlogPrintf ("CAS: online socket set up error\n");
-        epicsThreadSuspendSelf ();
-    }
 
-    {
-        /*
-         * this connect is to supress a warning message on Linux
-         * when we shutdown the read side of the socket. If it
-         * fails (and it will on old ip kernels) we just ignore 
-         * the failure.
-         */
-        osiSockAddr sockAddr;
-        sockAddr.ia.sin_family = AF_UNSPEC;
-        sockAddr.ia.sin_port = htons ( 0 );
-        sockAddr.ia.sin_addr.s_addr = htonl (0);
-        connect ( sock, & sockAddr.sa, sizeof ( sockAddr.sa ) );
-        shutdown ( sock, SHUT_RD );
-    }
-    
     memset((char *)&msg, 0, sizeof msg);
     msg.m_cmmd = htons (CA_PROTO_RSRV_IS_UP);
     msg.m_count = htons (ca_server_port);
     msg.m_dataType = htons (CA_MINOR_PROTOCOL_REVISION);
-    
-    ellInit ( & beaconAddrList );
-    ellInit ( & autoAddrList );
-
-    pStr = envGetConfigParam(&EPICS_CAS_AUTO_BEACON_ADDR_LIST, sizeof(buf), buf);
-    if ( ! pStr ) {
-	    pStr = envGetConfigParam(&EPICS_CA_AUTO_ADDR_LIST, sizeof(buf), buf);
-    }
-	if (pStr) {
-		if (strstr(pStr,"no")||strstr(pStr,"NO")) {
-			autoBeaconAddr = FALSE;
-		}
-		else if (strstr(pStr,"yes")||strstr(pStr,"YES")) {
-			autoBeaconAddr = TRUE;
-		}
-		else {
-			fprintf(stderr, 
-		"CAS: EPICS_CA(S)_AUTO_ADDR_LIST = \"%s\"? Assuming \"YES\"\n", pStr);
-			autoBeaconAddr = TRUE;
-		}
-	}
-	else {
-		autoBeaconAddr = TRUE;
-	}
-
-    /*
-     * load user and auto configured
-     * broadcast address list
-     */
-    if (envGetConfigParamPtr(&EPICS_CAS_BEACON_PORT)) {
-        port = envGetInetPortConfigParam (&EPICS_CAS_BEACON_PORT, 
-            (unsigned short) CA_REPEATER_PORT );
-    }
-    else {
-        port = envGetInetPortConfigParam (&EPICS_CA_REPEATER_PORT, 
-            (unsigned short) CA_REPEATER_PORT );
-    }
-
-    /*
-     * discover beacon addresses associated with this interface
-     */
-    if ( autoBeaconAddr ) {
-        osiSockAddr addr;
-		ELLLIST tmpList;
-
-		ellInit ( &tmpList );
-        addr.ia.sin_family = AF_UNSPEC;
-        osiSockDiscoverBroadcastAddresses (&tmpList, sock, &addr); 
-        forcePort ( &tmpList, port );
-		removeDuplicateAddresses ( &autoAddrList, &tmpList, 1 );
-    }
-            
-    /*
-     * by default use EPICS_CA_ADDR_LIST for the
-     * beacon address list
-     */
-    {
-        const ENV_PARAM *pParam;
-        
-        if (envGetConfigParamPtr(&EPICS_CAS_INTF_ADDR_LIST) || 
-            envGetConfigParamPtr(&EPICS_CAS_BEACON_ADDR_LIST)) {
-            pParam = &EPICS_CAS_BEACON_ADDR_LIST;
-        }
-        else {
-            pParam = &EPICS_CA_ADDR_LIST;
-        }
-    
-        /* 
-         * add in the configured addresses
-         */
-        addAddrToChannelAccessAddressList (
-            &autoAddrList, pParam, port,  pParam == &EPICS_CA_ADDR_LIST );
-    }
- 
-    removeDuplicateAddresses ( &beaconAddrList, &autoAddrList, 0 );
-
-    if ( ellCount ( &beaconAddrList ) == 0 ) {
-        errlogPrintf ("The CA server's beacon address list was empty after initialization?\n");
-    }
-  
-#   ifdef DEBUG
-        printChannelAccessAddressList (&beaconAddrList);
-#   endif
-
-    tbs  = epicsThreadHighestPriorityLevelBelow ( priorityOfSelf, &priorityOfUDP );
-    if ( tbs != epicsThreadBooleanStatusSuccess ) {
-        priorityOfUDP = priorityOfSelf;
-    }
-
-    casudp_startStopEvent = epicsEventMustCreate(epicsEventEmpty);
-    casudp_ctl = ctlPause;
-
-    tid = epicsThreadCreate ( "CAS-UDP", priorityOfUDP,
-        epicsThreadGetStackSize (epicsThreadStackMedium),
-        cast_server, 0 );
-    if ( tid == 0 ) {
-        epicsPrintf ( "CAS: unable to start UDP daemon thread\n" );
-    }
-
-    epicsEventMustWait(casudp_startStopEvent);
+
+
     epicsEventSignal(beacon_startStopEvent);
 
     while (TRUE) {
-        pNode = (osiSockAddrNode *) ellFirst (&beaconAddrList);
-        while (pNode) {
-            char buf[64];
+        ELLNODE *cur;
 
-            status = connect (sock, &pNode->addr.sa, 
-                sizeof(pNode->addr.sa));
-            if (status<0) {
+        /* send beacon to each interface */
+        for(cur=ellFirst(&beaconAddrList); cur; cur=ellNext(cur))
+        {
+            osiSockAddrNode *pAddr = CONTAINER(cur, osiSockAddrNode, node);
+            status = sendto (beaconSocket, (char *)&msg, sizeof(msg), 0,
+                             &pAddr->addr.sa, sizeof(pAddr->addr));
+            if (status < 0) {
                 char sockErrBuf[64];
-                epicsSocketConvertErrnoToString ( 
-                    sockErrBuf, sizeof ( sockErrBuf ) );
-                ipAddrToDottedIP (&pNode->addr.ia, buf, sizeof(buf));
-                errlogPrintf ( "%s: CA beacon routing (connect to \"%s\") error was \"%s\"\n",
+                epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
+                ipAddrToDottedIP (&pAddr->addr.ia, buf, sizeof(buf));
+                errlogPrintf ( "%s: CA beacon (send to \"%s\") error was \"%s\"\n",
                     __FILE__, buf, sockErrBuf);
             }
             else {
-                struct sockaddr_in if_addr;
-
-                osiSocklen_t size = sizeof (if_addr);
-                status = getsockname (sock, (struct sockaddr *) &if_addr, &size);
-                if (status<0) {
-                    char sockErrBuf[64];
-                    epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
-                    errlogPrintf ( "%s: CA beacon routing (getsockname) error was \"%s\"\n",
-                        __FILE__, sockErrBuf);
-                }
-                else if (if_addr.sin_family==AF_INET) {
-                    msg.m_available = if_addr.sin_addr.s_addr;
-                    msg.m_cid = htonl ( beaconCounter );
-
-                    status = send (sock, (char *)&msg, sizeof(msg), 0);
-                    if (status < 0) {
-                        char sockErrBuf[64];
-                        epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
-                        ipAddrToDottedIP (&pNode->addr.ia, buf, sizeof(buf));
-                        errlogPrintf ( "%s: CA beacon (send to \"%s\") error was \"%s\"\n",
-                            __FILE__, buf, sockErrBuf);
-                    }
-                    else {
-                        assert (status == sizeof(msg));
-                    }
-                }
+                assert (status == sizeof(msg));
             }
-            pNode = (osiSockAddrNode *) pNode->node.next;
         }
 
         epicsThreadSleep(delay);

=== modified file 'src/ioc/rsrv/server.h'
--- src/ioc/rsrv/server.h	2014-03-06 21:55:13 +0000
+++ src/ioc/rsrv/server.h	2016-01-12 02:07:47 +0000
@@ -32,6 +32,7 @@
 #include "ellLib.h"
 #include "epicsTime.h"
 #include "epicsAssert.h"
+#include "osiSock.h"
 
 #ifdef rsrvRestore_epicsExportSharedSymbols
 #define epicsExportSharedSymbols
@@ -88,7 +89,7 @@
   char                  *pUserName;
   char                  *pHostName;
   epicsEventId          blockSem; /* used whenever the client blocks */
-  SOCKET                sock;
+  SOCKET                sock, udpRecv;
   int                   proto;
   epicsThreadId         tid;
   unsigned              minor_version_number;
@@ -137,6 +138,15 @@
     char                    modified;   /* mod & ev flw ctrl enbl */
 };
 
+typedef struct {
+    ELLNODE node;
+    osiSockAddr tcpAddr, /* TCP listener endpoint */
+                udpAddr, /* UDP name unicast receiver endpoint */
+                udpbcastAddr; /* UDP name broadcast receiver endpoint */
+    SOCKET tcp, udp, udpbcast;
+
+    unsigned int startbcast:1;
+} rsrv_iface_config;
 
 enum ctl {ctlInit, ctlRun, ctlPause, ctlExit};
 
@@ -160,15 +170,15 @@
 #endif
 
 GLBLTYPE int                CASDEBUG;
-GLBLTYPE SOCKET             IOC_sock;
-GLBLTYPE SOCKET             IOC_cast_sock;
-GLBLTYPE unsigned short     ca_server_port;
-GLBLTYPE ELLLIST            clientQ; /* locked by clientQlock */
+GLBLTYPE unsigned short     ca_server_port, ca_udp_port, ca_beacon_port;
+GLBLTYPE ELLLIST            clientQ; /* (TCP clients) locked by clientQlock */
+GLBLTYPE ELLLIST            clientQudp; /* locked by clientQlock */
+GLBLTYPE ELLLIST            servers; /* rsrv_iface_config::node, read-only after rsrv_init() */
 GLBLTYPE ELLLIST            beaconAddrList;
-GLBLTYPE ELLLIST            casIntfAddrList;
+GLBLTYPE SOCKET             beaconSocket;
+GLBLTYPE ELLLIST            casIntfAddrList, casMCastAddrList;
 GLBLTYPE epicsMutexId       clientQlock;
-GLBLTYPE struct client      *prsrv_cast_client;
-GLBLTYPE BUCKET             *pCaBucket;
+GLBLTYPE BUCKET             *pCaBucket; /* locked by clientQlock */
 GLBLTYPE void               *rsrvClientFreeList;
 GLBLTYPE void               *rsrvChanFreeList;
 GLBLTYPE void               *rsrvEventFreeList;
@@ -176,7 +186,7 @@
 GLBLTYPE void               *rsrvLargeBufFreeListTCP;
 GLBLTYPE unsigned           rsrvSizeofLargeBufTCP;
 GLBLTYPE void               *rsrvPutNotifyFreeList;
-GLBLTYPE unsigned           rsrvChannelCount;
+GLBLTYPE unsigned           rsrvChannelCount; /* locked by clientQlock */
 
 GLBLTYPE epicsEventId       casudp_startStopEvent;
 GLBLTYPE epicsEventId       beacon_startStopEvent;
@@ -185,6 +195,7 @@
 GLBLTYPE volatile enum ctl  beacon_ctl;
 GLBLTYPE volatile enum ctl  castcp_ctl;
 
+GLBLTYPE unsigned int       threadPrios[5];
 
 #define CAS_HASH_TABLE_SIZE 4096
 

=== modified file 'src/libCom/env/envDefs.h'
--- src/libCom/env/envDefs.h	2015-06-29 22:45:18 +0000
+++ src/libCom/env/envDefs.h	2016-01-12 02:07:47 +0000
@@ -89,6 +89,8 @@
 	envGetLongConfigParam(const ENV_PARAM *pParam, long *pLong);
 epicsShareFunc unsigned short epicsShareAPI envGetInetPortConfigParam 
         (const ENV_PARAM *pEnv, unsigned short defaultPort);
+epicsShareFunc long epicsShareAPI
+    envGetBoolConfigParam(const ENV_PARAM *pParam, int *pBool);
 epicsShareFunc long epicsShareAPI epicsPrtEnvParams(void);
 epicsShareFunc void epicsShareAPI epicsEnvSet (const char *name, const char *value);
 epicsShareFunc void epicsShareAPI epicsEnvShow (const char *name);

=== modified file 'src/libCom/env/envSubr.c'
--- src/libCom/env/envSubr.c	2012-05-03 17:19:34 +0000
+++ src/libCom/env/envSubr.c	2016-01-12 02:07:47 +0000
@@ -43,6 +43,7 @@
 #define epicsExportSharedSymbols
 #include "epicsStdlib.h"
 #include "epicsStdio.h"
+#include "epicsString.h"
 #include "errMdef.h"
 #include "errlog.h"
 #include "envDefs.h"
@@ -319,7 +320,19 @@
     }
     return -1;
 }
-

+
+
+long epicsShareAPI
+envGetBoolConfigParam(const ENV_PARAM *pParam, int *pBool)
+{
+    char text[20];
+
+    if(!envGetConfigParam(pParam, sizeof(text), text))
+        return -1;
+    *pBool = epicsStrCaseCmp(text, "yes")==0;
+    return 0;
+}
+
 /*+/subr**********************************************************************
 * NAME	envPrtConfigParam - print value of a configuration parameter
 *

=== modified file 'src/libCom/osi/Makefile'
--- src/libCom/osi/Makefile	2014-10-07 01:28:35 +0000
+++ src/libCom/osi/Makefile	2016-01-12 02:07:47 +0000
@@ -80,6 +80,10 @@
 Com_SRCS_vxWorks += osiNTPTime.c
 Com_SRCS_RTEMS += osiNTPTime.c
 
+ifeq ($(OS_CLASS),vxWorks)
+osdTime.o: USR_CXXFLAGS += -DBUILD_TIME=$(shell perl -e 'print time')
+endif
+
 Com_SRCS += osdSock.c
 Com_SRCS += osdSockAddrReuse.cpp
 Com_SRCS += osiSock.c

=== modified file 'src/libCom/osi/os/Darwin/osdSock.h'
--- src/libCom/osi/os/Darwin/osdSock.h	2011-09-09 22:14:35 +0000
+++ src/libCom/osi/os/Darwin/osdSock.h	2016-01-12 02:07:47 +0000
@@ -41,6 +41,7 @@
 #define SOCK_ECONNRESET ECONNRESET
 #define SOCK_ETIMEDOUT ETIMEDOUT
 #define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
 #define SOCK_ECONNREFUSED ECONNREFUSED
 #define SOCK_ECONNABORTED ECONNABORTED
 #define SOCK_EINPROGRESS EINPROGRESS

=== modified file 'src/libCom/osi/os/Linux/osdSock.h'
--- src/libCom/osi/os/Linux/osdSock.h	2014-09-08 22:57:18 +0000
+++ src/libCom/osi/os/Linux/osdSock.h	2016-01-12 02:07:47 +0000
@@ -43,6 +43,7 @@
 #define SOCK_ECONNRESET ECONNRESET
 #define SOCK_ETIMEDOUT ETIMEDOUT
 #define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
 #define SOCK_ECONNREFUSED ECONNREFUSED
 #define SOCK_ECONNABORTED ECONNABORTED
 #define SOCK_EINPROGRESS EINPROGRESS

=== modified file 'src/libCom/osi/os/RTEMS/osdSock.h'
--- src/libCom/osi/os/RTEMS/osdSock.h	2011-09-09 22:14:35 +0000
+++ src/libCom/osi/os/RTEMS/osdSock.h	2016-01-12 02:07:47 +0000
@@ -51,6 +51,7 @@
 #define SOCK_ECONNRESET ECONNRESET
 #define SOCK_ETIMEDOUT ETIMEDOUT
 #define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
 #define SOCK_ECONNREFUSED ECONNREFUSED
 #define SOCK_ECONNABORTED ECONNABORTED
 #define SOCK_EINPROGRESS EINPROGRESS

=== modified file 'src/libCom/osi/os/WIN32/osdSock.h'
--- src/libCom/osi/os/WIN32/osdSock.h	2011-09-09 22:14:35 +0000
+++ src/libCom/osi/os/WIN32/osdSock.h	2016-01-12 02:07:47 +0000
@@ -49,6 +49,7 @@
 #define SOCK_ECONNRESET WSAECONNRESET
 #define SOCK_ETIMEDOUT WSAETIMEDOUT
 #define SOCK_EADDRINUSE WSAEADDRINUSE
+#define SOCK_EADDRNOTAVAIL WSAEADDRNOTAVAIL
 #define SOCK_ECONNREFUSED WSAECONNREFUSED
 #define SOCK_ECONNABORTED WSAECONNABORTED
 #define SOCK_EINPROGRESS WSAEINPROGRESS

=== modified file 'src/libCom/osi/os/cygwin32/osdSock.h'
--- src/libCom/osi/os/cygwin32/osdSock.h	2015-04-29 19:01:07 +0000
+++ src/libCom/osi/os/cygwin32/osdSock.h	2016-01-12 02:07:47 +0000
@@ -50,6 +50,7 @@
 #define SOCK_ECONNRESET ECONNRESET
 #define SOCK_ETIMEDOUT ETIMEDOUT
 #define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
 #define SOCK_ECONNREFUSED ECONNREFUSED
 #define SOCK_ECONNABORTED ECONNABORTED
 #define SOCK_EINPROGRESS EINPROGRESS

=== modified file 'src/libCom/osi/os/default/epicsMMIODef.h'
--- src/libCom/osi/os/default/epicsMMIODef.h	2014-09-26 21:40:44 +0000
+++ src/libCom/osi/os/default/epicsMMIODef.h	2016-01-12 02:07:47 +0000
@@ -13,6 +13,7 @@
 
 #include <epicsTypes.h>
 #include <epicsEndian.h>
+#include <compilerSpecific.h>
 #include <shareLib.h>
 
 #ifdef __cplusplus
@@ -27,7 +28,7 @@
 
 /** @brief Read a single byte.
  */
-INLINE
+static EPICS_ALWAYS_INLINE
 epicsUInt8
 ioread8(volatile void* addr)
 {
@@ -36,7 +37,7 @@
 
 /** @brief Write a single byte.
  */
-INLINE
+static EPICS_ALWAYS_INLINE
 void
 iowrite8(volatile void* addr, epicsUInt8 val)
 {
@@ -46,7 +47,7 @@
 /** @brief Read two bytes in host order.
  * Not byte swapping
  */
-INLINE
+static EPICS_ALWAYS_INLINE
 epicsUInt16
 nat_ioread16(volatile void* addr)
 {
@@ -56,7 +57,7 @@
 /** @brief Write two byte in host order.
  * Not byte swapping
  */
-INLINE
+static EPICS_ALWAYS_INLINE
 void
 nat_iowrite16(volatile void* addr, epicsUInt16 val)
 {
@@ -66,7 +67,7 @@
 /** @brief Read four bytes in host order.
  * Not byte swapping
  */
-INLINE
+static EPICS_ALWAYS_INLINE
 epicsUInt32
 nat_ioread32(volatile void* addr)
 {
@@ -76,7 +77,7 @@
 /** @brief Write four byte in host order.
  * Not byte swapping
  */
-INLINE
+static EPICS_ALWAYS_INLINE
 void
 nat_iowrite32(volatile void* addr, epicsUInt32 val)
 {

=== modified file 'src/libCom/osi/os/default/osdNetIntf.c'
--- src/libCom/osi/os/default/osdNetIntf.c	2015-08-18 19:46:22 +0000
+++ src/libCom/osi/os/default/osdNetIntf.c	2016-01-12 02:07:47 +0000
@@ -77,21 +77,6 @@
     struct ifreq                    *pifreq;
     struct ifreq                    *pnextifreq;
     osiSockAddrNode                 *pNewNode;
-
-    if ( pMatchAddr->sa.sa_family == AF_INET  ) {
-        if ( pMatchAddr->ia.sin_addr.s_addr == htonl (INADDR_LOOPBACK) ) {
-            pNewNode = (osiSockAddrNode *) calloc (1, sizeof (*pNewNode) );
-            if ( pNewNode == NULL ) {
-                errlogPrintf ( "osiSockDiscoverBroadcastAddresses(): no memory available for configuration\n" );
-                return;
-            }
-            pNewNode->addr.ia.sin_family = AF_INET;
-            pNewNode->addr.ia.sin_port = htons ( 0 );
-            pNewNode->addr.ia.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
-            ellAdd ( pList, &pNewNode->node );
-            return;
-        }
-    }
      
     /*
      * use pool so that we avoid using too much stack space
@@ -120,6 +105,7 @@
 
     for ( pifreq = pIfreqList; pifreq <= pIfreqListEnd; pifreq = pnextifreq ) {
         uint32_t  current_ifreqsize;
+        struct sockaddr_in if_addr;
 
         /*
          * find the next ifreq
@@ -143,6 +129,7 @@
              ifDepenDebugPrintf ( ("osiSockDiscoverBroadcastAddresses(): interface \"%s\" was not AF_INET\n", pIfreqList->ifr_name) );
              continue;
         }
+        if_addr = *(struct sockaddr_in *)&pIfreqList->ifr_addr;
 
         /*
          * if it isnt a wildcarded interface then look for
@@ -153,8 +140,7 @@
                 continue;
             }
             if ( pMatchAddr->ia.sin_addr.s_addr != htonl (INADDR_ANY) ) {
-                 struct sockaddr_in *pInetAddr = (struct sockaddr_in *) &pIfreqList->ifr_addr;
-                 if ( pInetAddr->sin_addr.s_addr != pMatchAddr->ia.sin_addr.s_addr ) {
+                 if ( if_addr.sin_addr.s_addr != pMatchAddr->ia.sin_addr.s_addr ) {
                      ifDepenDebugPrintf ( ("osiSockDiscoverBroadcastAddresses(): net intf \"%s\" didnt match\n", pIfreqList->ifr_name) );
                      continue;
                  }
@@ -175,14 +161,6 @@
              continue;
         }
 
-        /*
-         * dont use the loop back interface 
-         */
-        if ( pIfreqList->ifr_flags & IFF_LOOPBACK ) {
-             ifDepenDebugPrintf ( ("osiSockDiscoverBroadcastAddresses(): ignoring loopback interface: \"%s\"\n", pIfreqList->ifr_name) );
-             continue;
-        }
-
         pNewNode = (osiSockAddrNode *) calloc (1, sizeof (*pNewNode) );
         if ( pNewNode == NULL ) {
             errlogPrintf ( "osiSockDiscoverBroadcastAddresses(): no memory available for configuration\n" );
@@ -221,6 +199,22 @@
             pNewNode->addr.sa = pIfreqList->ifr_dstaddr;
         }
 #endif
+#if defined(__linux__)
+        /* On Linux, even though the 'lo' interface doesn't set IFF_BROADCAST
+         * a broadcast route often exists.  Assume that sending to 127.255.255.255
+         * reaches all local listeners.
+         *
+         *   $ ip route show table local scope link dev lo
+         *   broadcast 127.0.0.0  proto kernel  src 127.0.0.1
+         *   broadcast 127.255.255.255  proto kernel  src 127.0.0.1
+         */
+        else if ( pIfreqList->ifr_flags & IFF_LOOPBACK && if_addr.sin_addr.s_addr == htonl(INADDR_LOOPBACK) ) {
+            memset(&pNewNode->addr.ia, 0, sizeof(pNewNode->addr.ia));
+            pNewNode->addr.ia.sin_family = AF_INET;
+            pNewNode->addr.ia.sin_addr.s_addr = htonl(0x7fffffff);
+            ifDepenDebugPrintf ( ( "assume loopback broadcast addr = %x\n", ntohl ( pNewNode->addr.ia.sin_addr.s_addr ) ) );
+        }
+#endif
         else {
             ifDepenDebugPrintf ( ( "osiSockDiscoverBroadcastAddresses(): net intf \"%s\": not point to point or bcast?\n", pIfreqList->ifr_name ) );
             free ( pNewNode );

=== modified file 'src/libCom/osi/os/freebsd/osdSock.h'
--- src/libCom/osi/os/freebsd/osdSock.h	2011-09-09 22:14:35 +0000
+++ src/libCom/osi/os/freebsd/osdSock.h	2016-01-12 02:07:47 +0000
@@ -44,6 +44,7 @@
 #define SOCK_ECONNRESET ECONNRESET
 #define SOCK_ETIMEDOUT ETIMEDOUT
 #define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
 #define SOCK_ECONNREFUSED ECONNREFUSED
 #define SOCK_ECONNABORTED ECONNABORTED
 #define SOCK_EINPROGRESS EINPROGRESS

=== modified file 'src/libCom/osi/os/iOS/osdSock.h'
--- src/libCom/osi/os/iOS/osdSock.h	2011-09-09 22:14:35 +0000
+++ src/libCom/osi/os/iOS/osdSock.h	2016-01-12 02:07:47 +0000
@@ -42,6 +42,7 @@
 #define SOCK_ECONNRESET ECONNRESET
 #define SOCK_ETIMEDOUT ETIMEDOUT
 #define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
 #define SOCK_ECONNREFUSED ECONNREFUSED
 #define SOCK_ECONNABORTED ECONNABORTED
 #define SOCK_EINPROGRESS EINPROGRESS

=== modified file 'src/libCom/osi/os/solaris/osdSock.h'
--- src/libCom/osi/os/solaris/osdSock.h	2011-09-09 22:14:35 +0000
+++ src/libCom/osi/os/solaris/osdSock.h	2016-01-12 02:07:47 +0000
@@ -52,6 +52,7 @@
 #define SOCK_ECONNRESET ECONNRESET
 #define SOCK_ETIMEDOUT ETIMEDOUT
 #define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
 #define SOCK_ECONNREFUSED ECONNREFUSED
 #define SOCK_ECONNABORTED ECONNABORTED
 #define SOCK_EINPROGRESS EINPROGRESS

=== modified file 'src/libCom/osi/os/vxWorks/epicsMMIO.h'
--- src/libCom/osi/os/vxWorks/epicsMMIO.h	2014-08-01 21:06:17 +0000
+++ src/libCom/osi/os/vxWorks/epicsMMIO.h	2016-01-12 02:07:47 +0000
@@ -83,13 +83,18 @@
  * They do *not* all implement the sys{In/Out}{Byte/Word/Long}
  * functions to do the same thing though, so we can't use them.
  */
-
+#ifdef __cplusplus
+extern "C" {
+#endif
 UINT8 sysPciInByte(UINT8 *addr);
 void sysPciOutByte(UINT8 *addr, UINT8 data);
 UINT16 sysPciInWord(UINT16 *addr);
 void sysPciOutWord(UINT16 *addr, UINT16 data);
 UINT32 sysPciInLong (UINT32 *addr);
 void sysPciOutLong (UINT32 *addr, UINT32 data);
+#ifdef __cplusplus
+}
+#endif
 
 #define ioread8(address)           sysPciInByte((UINT8 *)(address))
 #define iowrite8(address,data)     sysPciOutByte((UINT8 *)(address), (epicsUInt8)(data))

=== modified file 'src/libCom/osi/os/vxWorks/osdSock.h'
--- src/libCom/osi/os/vxWorks/osdSock.h	2011-09-20 18:07:52 +0000
+++ src/libCom/osi/os/vxWorks/osdSock.h	2016-01-12 02:07:47 +0000
@@ -73,6 +73,7 @@
 #define SOCK_ECONNRESET ECONNRESET
 #define SOCK_ETIMEDOUT ETIMEDOUT
 #define SOCK_EADDRINUSE EADDRINUSE
+#define SOCK_EADDRNOTAVAIL EADDRNOTAVAIL
 #define SOCK_ECONNREFUSED ECONNREFUSED
 #define SOCK_ECONNABORTED ECONNABORTED
 #define SOCK_EINPROGRESS EINPROGRESS

=== modified file 'src/libCom/osi/os/vxWorks/osdTime.cpp'
--- src/libCom/osi/os/vxWorks/osdTime.cpp	2013-06-07 19:35:45 +0000
+++ src/libCom/osi/os/vxWorks/osdTime.cpp	2016-01-12 02:07:47 +0000
@@ -1,5 +1,5 @@
 /*************************************************************************\
-* Copyright (c) 2008 UChicago Argonne LLC, as Operator of Argonne
+* Copyright (c) 2015 UChicago Argonne LLC, as Operator of Argonne
 *     National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 *     Operator of Los Alamos National Laboratory.
@@ -7,11 +7,14 @@
 * in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
+#define _VSB_CONFIG_FILE <../lib/h/config/vsbConfig.h>
+
 #include <vxWorks.h>
 #include <sntpcLib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <taskLib.h>
 
 #include "epicsTime.h"
 #include "osiNTPTime.h"
@@ -21,6 +24,9 @@
 
 #define NTP_REQUEST_TIMEOUT 4 /* seconds */
 
+static char sntp_sync_task[] = "ipsntps";
+static char ntp_daemon[] = "ipntpd";
+
 static const char *pserverAddr = NULL;
 extern char* sysBootLine;
 
@@ -30,18 +36,40 @@
     if (getenv("TIMEZONE") == NULL) {
         const char *timezone = envGetConfigParamPtr(&EPICS_TIMEZONE);
         if (timezone == NULL) {
-            printf("NTPTime_Init: No Time Zone Information\n");
+            printf("timeRegister: No Time Zone Information\n");
         } else {
             epicsEnvSet("TIMEZONE", timezone);
         }
     }
 
-    NTPTime_Init(100); /* init NTP first so it can be used to sync SysTime */
-    ClockTime_Init(CLOCKTIME_SYNC);
+    // Define EPICS_TS_FORCE_NTPTIME to force use of NTPTime provider
+    bool useNTP = getenv("EPICS_TS_FORCE_NTPTIME") != NULL;
+
+    if (!useNTP &&
+        (taskNameToId(sntp_sync_task) != ERROR ||
+         taskNameToId(ntp_daemon) != ERROR)) {
+        // A VxWorks 6 SNTP/NTP sync task is running
+        struct timespec clockNow;
+
+        useNTP = clock_gettime(CLOCK_REALTIME, &clockNow) != OK ||
+            clockNow.tv_sec < BUILD_TIME;
+            // Assumes VxWorks and the host OS have the same epoch
+    }
+
+    if (useNTP) {
+        // Start NTP first so it can be used to sync SysTime
+        NTPTime_Init(100);
+        ClockTime_Init(CLOCKTIME_SYNC);
+    } else {
+        ClockTime_Init(CLOCKTIME_NOSYNC);
+    }
     return 1;
 }
 static int done = timeRegister();
 
+
+// Routines for NTPTime provider
+
 int osdNTPGet(struct timespec *ts)
 {
     return sntpcTimeGet(const_cast<char *>(pserverAddr),
@@ -54,6 +82,7 @@
     if (!pserverAddr) { /* use the boot host */
         BOOT_PARAMS bootParms;
         static char host_addr[BOOT_ADDR_LEN];
+
         bootStringToStruct(sysBootLine, &bootParms);
         /* bootParms.had = host IP address */
         strncpy(host_addr, bootParms.had, BOOT_ADDR_LEN);
@@ -63,10 +92,13 @@
 
 void osdNTPReport(void)
 {
-    printf("NTP Server = %s\n", pserverAddr);
+    if (pserverAddr)
+        printf("NTP Server = %s\n", pserverAddr);
 }
 
 
+// Other Time Routines
+
 // vxWorks localtime_r returns different things in different versions.
 // It can't fail though, so we just ignore the return value.
 int epicsTime_localtime(const time_t *clock, struct tm *result)

=== modified file 'src/libCom/osi/osiClockTime.c'
--- src/libCom/osi/osiClockTime.c	2015-09-07 14:50:48 +0000
+++ src/libCom/osi/osiClockTime.c	2016-01-12 02:07:47 +0000
@@ -70,37 +70,54 @@
 
 /* Initialization */
 
-static void ClockTime_InitOnce(void *psync)
+static void ClockTime_InitOnce(void *pfirst)
 {
-    ClockTimePvt.synchronize = *(int *)psync;
+    *(int *) pfirst = 1;
+
     ClockTimePvt.loopEvent   = epicsEventMustCreate(epicsEventEmpty);
     ClockTimePvt.lock        = epicsMutexCreate();
 
-    if (ClockTimePvt.synchronize) {
-        /* Start the sync thread */
-        epicsThreadCreate("ClockTimeSync", epicsThreadPriorityHigh,
-            epicsThreadGetStackSize(epicsThreadStackSmall),
-            ClockTimeSync, NULL);
-    }
-    else {
-        ClockTimeGetCurrent(&ClockTimePvt.startTime);
-    }
-
     epicsAtExit(ClockTime_Shutdown, NULL);
 
     /* Register the iocsh commands */
     iocshRegister(&ReportFuncDef, ReportCallFunc);
-    if (ClockTimePvt.synchronize)
-        iocshRegister(&ShutdownFuncDef, ShutdownCallFunc);
+    iocshRegister(&ShutdownFuncDef, ShutdownCallFunc);
 
-    /* Finally register as a time provider */
+    /* Register as a time provider */
     generalTimeRegisterCurrentProvider("OS Clock", LAST_RESORT_PRIORITY,
         ClockTimeGetCurrent);
 }
 
 void ClockTime_Init(int synchronize)
 {
-    epicsThreadOnce(&onceId, ClockTime_InitOnce, &synchronize);
+    int firstTime = 0;
+
+    epicsThreadOnce(&onceId, ClockTime_InitOnce, &firstTime);
+
+    if (synchronize == CLOCKTIME_SYNC) {
+        if (ClockTimePvt.synchronize == CLOCKTIME_NOSYNC) {
+            /* Start synchronizing */
+            ClockTimePvt.synchronize = synchronize;
+
+            epicsThreadCreate("ClockTimeSync", epicsThreadPriorityHigh,
+                epicsThreadGetStackSize(epicsThreadStackSmall),
+                ClockTimeSync, NULL);
+        }
+        else {
+            /* No change, sync thread should already be running */
+        }
+    }
+    else {
+        if (ClockTimePvt.synchronize == CLOCKTIME_SYNC) {
+            /* Turn off synchronization thread */
+            ClockTime_Shutdown(NULL);
+        }
+        else {
+            /* No synchronization thread */
+            if (firstTime)
+                ClockTimeGetCurrent(&ClockTimePvt.startTime);
+        }
+    }
 }
 
 
@@ -108,7 +125,7 @@
 
 void ClockTime_Shutdown(void *dummy)
 {
-    ClockTimePvt.synchronize = 0;
+    ClockTimePvt.synchronize = CLOCKTIME_NOSYNC;
     epicsEventSignal(ClockTimePvt.loopEvent);
 }
 
@@ -126,7 +143,7 @@
 
     for (epicsEventWaitWithTimeout(ClockTimePvt.loopEvent,
              ClockTimeSyncInterval);
-         ClockTimePvt.synchronize;
+         ClockTimePvt.synchronize == CLOCKTIME_SYNC;
          epicsEventWaitWithTimeout(ClockTimePvt.loopEvent,
              ClockTimeSyncInterval)) {
         epicsTimeStamp timeNow;
@@ -144,8 +161,8 @@
 
             epicsMutexMustLock(ClockTimePvt.lock);
             if (!ClockTimePvt.synchronized) {
-                ClockTimePvt.startTime = timeNow;
-                ClockTimePvt.synchronized     = 1;
+                ClockTimePvt.startTime    = timeNow;
+                ClockTimePvt.synchronized = 1;
             }
             ClockTimePvt.syncFromPriority = priority;
             ClockTimePvt.syncTime         = timeNow;
@@ -200,29 +217,39 @@
 #ifdef CLOCK_REALTIME
             "initialized"
 #else
-            "included"
+            "available"
 #endif /* CLOCK_REALTIME */
             );
-    } else if (ClockTimePvt.synchronize) {
+    }
+    else if (ClockTimePvt.synchronize == CLOCKTIME_SYNC) {
+        int synchronized, syncFromPriority;
+        epicsTimeStamp startTime, syncTime;
+
         epicsMutexMustLock(ClockTimePvt.lock);
-        if (ClockTimePvt.synchronized) {
-            printf("OS Clock driver has synchronized to a priority=%d provider\n",
-                ClockTimePvt.syncFromPriority);
+        synchronized = ClockTimePvt.synchronized;
+        syncFromPriority = ClockTimePvt.syncFromPriority;
+        startTime = ClockTimePvt.startTime;
+        syncTime = ClockTimePvt.syncTime;
+        epicsMutexUnlock(ClockTimePvt.lock);
+
+        if (synchronized) {
+            printf("OS Clock driver is synchronized to a priority=%d provider\n",
+                syncFromPriority);
             if (level) {
                 epicsTimeToStrftime(timebuf, sizeof(timebuf),
-                    "%Y-%m-%d %H:%M:%S.%06f", &ClockTimePvt.startTime);
+                    "%Y-%m-%d %H:%M:%S.%06f", &startTime);
                 printf("Initial sync was at %s\n", timebuf);
                 epicsTimeToStrftime(timebuf, sizeof(timebuf),
-                    "%Y-%m-%d %H:%M:%S.%06f", &ClockTimePvt.syncTime);
+                    "%Y-%m-%d %H:%M:%S.%06f", &syncTime);
                 printf("Last successful sync was at %s\n", timebuf);
             }
             printf("Syncronization interval = %.0f seconds\n",
                 ClockTimeSyncInterval);
-        } else
-            printf("OS Clock driver has *not* yet synchronized\n");
-
-        epicsMutexUnlock(ClockTimePvt.lock);
-    } else {
+        }
+        else
+            printf("OS Clock driver is *not* synchronized\n");
+    }
+    else {
         epicsTimeToStrftime(timebuf, sizeof(timebuf),
             "%Y-%m-%d %H:%M:%S.%06f", &ClockTimePvt.startTime);
         printf("Program started at %s\n", timebuf);

=== modified file 'src/std/filters/filters.dbd.pod'
--- src/std/filters/filters.dbd.pod	2014-10-03 19:23:04 +0000
+++ src/std/filters/filters.dbd.pod	2016-01-12 02:07:47 +0000
@@ -6,13 +6,13 @@
 
 =over
 
-=item * L<TimeStamp|/"TimeStamp Filter "ts"">
-
-=item * L<Deadband|/"Deadband Filter "dbnd"">
-
-=item * L<Array|/"Array Filter "arr"">
-
-=item * L<Synchronize|/"Synchronize Filter "sync"">
+=item * L<TimeStamp|/"TimeStamp Filter ts">
+
+=item * L<Deadband|/"Deadband Filter dbnd">
+
+=item * L<Array|/"Array Filter arr">
+
+=item * L<Synchronize|/"Synchronize Filter sync">
 
 =back
 

=== modified file 'src/tools/Makefile'
--- src/tools/Makefile	2015-07-10 19:02:01 +0000
+++ src/tools/Makefile	2016-01-12 02:07:47 +0000
@@ -33,6 +33,7 @@
 PERL_MODULES += DBD/Registrar.pm
 PERL_MODULES += DBD/Variable.pm
 
+PERL_SCRIPTS += assembleSnippets.pl
 PERL_SCRIPTS += convertRelease.pl
 PERL_SCRIPTS += cvsclean.pl
 PERL_SCRIPTS += dos2unix.pl

=== added file 'src/tools/assembleSnippets.pl'
--- src/tools/assembleSnippets.pl	1970-01-01 00:00:00 +0000
+++ src/tools/assembleSnippets.pl	2016-01-12 02:07:47 +0000
@@ -0,0 +1,151 @@
+#!/usr/bin/env perl
+#*************************************************************************
+# Copyright (c) 2015 ITER Organization.
+# EPICS BASE is distributed subject to a Software License Agreement found
+# in file LICENSE that is included with this distribution.
+#*************************************************************************
+
+# $Id$
+
+use strict;
+use warnings;
+
+use Getopt::Std;
+use Sys::Hostname;
+use File::Basename;
+use Data::Dumper;
+
+our ($opt_o, $opt_d, $opt_m, $opt_i, $opt_M);
+
+$Getopt::Std::OUTPUT_HELP_VERSION = 1;
+&HELP_MESSAGE if !getopts('M:i:m:o:d') || @ARGV == 0;
+
+my $out;
+my $dep;
+my %snippets;
+my $ipattern;
+
+my $datetime = localtime();
+my $user = $ENV{LOGNAME} || $ENV{USER} || $ENV{USERNAME};
+my $host = hostname;
+my %replacements = (
+    _DATETIME_ => $datetime,
+    _USERNAME_ => $user,
+    _HOST_ => $host,
+);
+
+if ($opt_o) {
+    open $out, '>', $opt_o or
+        die "Can't create $opt_o: $!\n";
+    print STDERR "opened file $opt_o for output\n" if $opt_d;
+    $replacements{_OUTPUTFILE_} = $opt_o;
+} else {
+    open $out, '>&', STDOUT;
+    print STDERR "using STDOUT for output\n" if $opt_d;
+    $replacements{_OUTPUTFILE_} = 'STDERR';
+}
+
+if ($opt_m) {
+    foreach my $r (split /,/, $opt_m) {
+        (my $k, my $v) = split /=/, $r;
+        $replacements{$k} = $v;
+    }
+}
+
+if ($opt_M) {
+    open $dep, '>', $opt_M or
+        die "Can't create $opt_M: $!\n";
+    print STDERR "opened dependency file $opt_M for output\n" if $opt_d;
+    print $dep basename($opt_o), ":";
+}
+
+if ($opt_i) {
+    $ipattern = qr($opt_i);
+}
+
+# %snippets is a hash {rank}
+#                  of hashes {name-after-rank}
+#                      of arrays[] [files...]
+#                          of arrays[2] [filename, command]
+print STDERR "reading input files\n" if $opt_d;
+foreach (@ARGV) {
+    my $name = basename($_);
+    if ($opt_i and not $name =~ /$ipattern/) {
+        print STDERR "  snippet $_ does not match input pattern $opt_i - ignoring\n" if $opt_d;
+        next;
+    }
+    if ($name =~ /\A([ARD]?)([0-9]+)(.*[^~])\z/) {
+        print STDERR "  considering snippet $_\n" if $opt_d;
+        if (exists $snippets{$2}) {
+            my %rank = %{$snippets{$2}};
+            my @files = @{ $rank{(keys %rank)[0]} };
+            my $existcmd = $files[0]->[1];
+            if ($1 eq "D" and $existcmd ne "D") {
+                print STDERR "    ignoring 'D' default for existing rank $2\n" if $opt_d;
+                next;
+            } elsif ($1 eq "R") {
+                print STDERR "    'R' command - deleting existing rank $2 snippets\n" if $opt_d;
+                $snippets{$2} = {};
+            } elsif ($existcmd eq "D") {
+                print STDERR "    deleting existing rank $2 default snippet\n" if $opt_d;
+                $snippets{$2} = {};
+            }
+        }
+        if ($opt_d) {
+            print STDERR "    adding snippet ";
+            print STDERR "marked as default " if $1 eq "D";
+            print STDERR "to rank $2\n";
+        }
+        $snippets{$2}{$3} = () if (not exists $snippets{$2}{$3});
+        push @{$snippets{$2}{$3}}, [ $_, $1 ];
+    }
+}
+
+if ($opt_d) {
+    print STDERR "finished reading input files\n";
+    print STDERR "dumping the final snippet structure\n";
+    print STDERR Dumper(\%snippets);
+    print STDERR "dumping the macro replacements\n";
+    print STDERR Dumper(\%replacements);
+    print STDERR "creating output\n";
+}
+
+foreach my $r (sort {$a<=>$b} keys %snippets) {
+    print STDERR "  working on rank $r\n" if $opt_d;
+    foreach my $n (sort keys %{$snippets{$r}}) {
+        foreach my $s (@{$snippets{$r}{$n}}) {
+            my $in;
+            my $f = $s->[0];
+            print STDERR "    snippet $n from file $f\n" if $opt_d;
+            open $in, '<', $f or die "Can't open $f: $!\n";
+            $replacements{_SNIPPETFILE_} = $f;
+            print $dep " \\\n $f" if $opt_M;
+            while (<$in>) {
+                chomp;
+                foreach my $k (keys %replacements) {
+                    s/$k/$replacements{$k}/g;
+                }
+                print $out $_, "\n";
+            }
+            close $in;
+        }
+    }
+}
+
+print STDERR "finished creating output, closing\n" if $opt_d;
+if ($opt_M) {
+    print $dep "\n";
+    close $dep;
+}
+close $out;
+
+sub HELP_MESSAGE {
+    print STDERR "Usage: assembleSnippets.pl [options] snippets ...\n";
+    print STDERR "Options:\n";
+    print STDERR " -o file     output file [STDOUT]\n";
+    print STDERR " -d          debug mode [no]\n";
+    print STDERR " -m macros   list of macro replacements as \"key=val,key=val\"\n";
+    print STDERR " -i pattern  pattern for input files to match\n";
+    print STDERR " -M file     write file with dependency rule suitable for make\n";
+    exit 2;
+}

=== modified file 'src/tools/test/Makefile'
--- src/tools/test/Makefile	2012-03-14 20:27:40 +0000
+++ src/tools/test/Makefile	2016-01-12 02:07:47 +0000
@@ -18,6 +18,7 @@
 TESTS += Recfield
 TESTS += Recordtype
 TESTS += Registrar
+TESTS += Snippets
 TESTS += Variable
 
 TESTSCRIPTS_HOST += $(TESTS:%=%.t)

=== added file 'src/tools/test/Snippets.plt'
--- src/tools/test/Snippets.plt	1970-01-01 00:00:00 +0000
+++ src/tools/test/Snippets.plt	2016-01-12 02:07:47 +0000
@@ -0,0 +1,110 @@
+#!/usr/bin/env perl
+
+use File::Path;
+use Sys::Hostname;
+
+use Test::More tests => 29;
+
+my $user = $ENV{LOGNAME} || $ENV{USER} || $ENV{USERNAME};
+my $host = hostname;
+
+mkdir "a$$";
+mkdir "b$$";
+
+sub mksnip {
+    my ($dir, $file, $line) = @_;
+    open(my $fh, '>', "$dir$$/$file") or die "can't open $dir$$/$file : $!";
+    print $fh $line;
+    close $fh;
+}
+
+sub assemble {
+    my @cmd = ( 'perl', '../../assembleSnippets.pl', '-o', "out$$" );
+    push @cmd, @_;
+    system(@cmd);
+    open(my $fh, '<', "out$$") or die "can't open out$$ : $!";
+    chomp(my @result = <$fh>);
+    close $fh;
+    return join (' ', @result);
+}
+
+# Adding two snippets of same rank, sorting alphabetically
+mksnip('a', '10_a', '10');
+mksnip('b', '10_c', '12');
+is assemble("a$$/10_a", "b$$/10_c"), '10 12', "adding same rank; ordered";
+is assemble("b$$/10_c", "a$$/10_a"), '10 12', "adding same rank; reverse order";
+
+# Same, with 'A' cmd
+mksnip('a', 'A10_a', '10');
+mksnip('b', 'A10_c', '12');
+is assemble("a$$/10_a", "b$$/A10_c"), '10 12', "'A' add same rank; ordered";
+is assemble("b$$/10_c", "a$$/A10_a"), '10 12', "'A' add same rank; reverse order";
+
+# Same name does not create issues
+mksnip('b', '10_a', '10x');
+is assemble("a$$/10_a", "b$$/10_a"), '10 10x', "adding same name twice; order a-b";
+is assemble("b$$/10_a", "a$$/10_a"), '10x 10', "adding same name twice; order b-a";
+
+# Backup files (trailing ~) and hidden files (leading '.') get ignored
+mksnip('b', '10_c~', '12~');
+mksnip('b', '.10_c', '.12');
+is assemble("b$$/10_c", "b$$/10_c~"), '12', "backup file (trailing ~) gets ignored";
+is assemble("b$$/10_c", "b$$/.10_c"), '12', "hidden file (leading .) gets ignored";
+
+# Non-numeric filenames get ignored
+mksnip('a', 'foo10_a', 'foo10');
+is assemble("b$$/10_c", "a$$/foo10_a"), '12', "file starting with [^ADR0-9] gets ignored";
+
+# 'R' command replaces existing snippets of same rank
+mksnip('a', 'R10_b', '11');
+is assemble("a$$/10_a", "b$$/10_c", "a$$/R10_b"), '11', "'R' cmd; replace all";
+is assemble("a$$/10_a", "a$$/R10_b", "b$$/10_c"), '11 12', "'R' cmd; replace one (ordered)";
+is assemble("b$$/10_c", "a$$/R10_b", "a$$/10_a"), '10 11', "'R' cmd; replace one (reverse order)";
+
+# 'D' command establishes default that gets overwritten or ignored
+mksnip('a', 'D10_a', 'D10');
+mksnip('b', 'D10_c', 'D12');
+is assemble("a$$/D10_a", "b$$/10_c"),  '12',  "'D' default; replaced by regular";
+is assemble("a$$/D10_a", "b$$/D10_c"), 'D12', "'D' default; replaced by new default (ordered)";
+is assemble("b$$/D10_c", "a$$/D10_a"), 'D10', "'D' default; replaced by new default (reverse order)";
+is assemble("a$$/D10_a", "a$$/R10_b"), '11',  "'D' default; replaced by 'R' cmd";
+is assemble("b$$/10_c", "a$$/D10_a"),  '12',  "'D' default; ignored when regular exists";
+
+# Ranks are sorted numerically
+mksnip('b', '09_a', '09');
+mksnip('a', '15_a', '15');
+mksnip('b', '2_a', '2');
+is assemble("a$$/10_a", "b$$/2_a", "a$$/15_a", "b$$/09_a"), '2 09 10 15',  "ranks are sorted numerically";
+
+# Builtin macros
+mksnip('a', '30_a', '_USERNAME_');
+mksnip('a', '30_b', '_OUTPUTFILE_');
+mksnip('a', '30_c', '_SNIPPETFILE_');
+mksnip('a', '30_d', '_HOST_');
+is assemble("a$$/30_a"), "$user", "builtin macro _USERNAME_";
+is assemble("a$$/30_b"), "out$$", "builtin macro _OUTPUTFILE_";
+is assemble("a$$/30_c"), "a$$/30_c", "builtin macro _SNIPPETFILE_";
+is assemble("a$$/30_d"), "$host", "builtin macro _HOST_";
+
+# User macros
+mksnip('b', '35_a', 'Line _M1_');
+mksnip('b', '35_b', 'Line _M1_ with _M2_');
+mksnip('b', '35_c', 'Line _M2_ with _M2_');
+is assemble("-m", "_M1_=REP1", "b$$/35_a"), "Line REP1", "single user macro; single occurrence";
+is assemble("-m", "_M1_=REP1,_M2_=REP2", "b$$/35_b"), "Line REP1 with REP2", "multiple user macros";
+is assemble("-m", "_M2_=REP2", "b$$/35_c"), "Line REP2 with REP2", "single user macro; multiple occurrences";
+
+# Input pattern
+mksnip('a', '10_a.cmd', '10cmd');
+is assemble("-i", "\.cmd", "a$$/10_a", "b$$/10_c", "a$$/R10_b", "a$$/10_a.cmd"), '10cmd', "input pattern";
+
+# Dependency file generation
+assemble("-M", "./dep$$", "a$$/10_a", "b$$/10_c");
+open(my $fh, '<', "dep$$") or die "can't open dep$$ : $!";
+chomp(my @result = <$fh>);
+close $fh;
+is "$result[0]", "out$$: \\", "dependency file (line 1)";
+is "$result[1]", " a$$/10_a \\", "dependency file (line 2)";
+is "$result[2]", " b$$/10_c", "dependency file (line 3)";
+
+rmtree([ "a$$", "b$$", "out$$", "dep$$" ]);