SWI-Prolog 8.3.18
AllApplicationManualNameSummaryHelp

All predicatesShow sourceudp_broadcast.pl -- A UDP broadcast proxy

SWI-Prolog's broadcast library provides a means that may be used to facilitate publish and subscribe communication regimes between anonymous members of a community of interest. The members of the community are however, necessarily limited to a single instance of Prolog. The UDP broadcast library removes that restriction. With this library loaded, any member on your local IP subnetwork that also has this library loaded may hear and respond to your broadcasts.

This library support three styles of networking as described below. Each of these networks have their own advantages and disadvantages. Please study the literature to understand the consequences.

broadcast
Broadcast messages are sent to the LAN subnet. The broadcast implementation uses two UDP ports: a public to address the whole group and a private one to address a specific node. Broadcasting is generally a good choice if the subnet is small and traffic is low.
unicast
Unicast sends copies of packages to known peers. Unicast networks can easily be routed. The unicast version uses a single UDP port per node. Unicast is generally a good choice for a small party, in particular if the peers are in different networks.
multicast
Multicast is like broadcast, but it can be configured to work accross networks and may work more efficiently on VLAN networks. Like the broadcast setup, two UDP ports are used. Multicasting can in general deliver the most efficient LAN and WAN networks, but requires properly configured routing between the peers.

After initialization and, in the case of a unicast network managing the set of peers, communication happens through broadcast/1, broadcast_request/1 and listen/1,2,3.

A broadcast/1 or broadcast_request/1 of the shape udp(Scope, Term) or udp(Scope, Term, TimeOut) is forwarded over the UDP network to all peers that joined the same Scope. To prevent the potential for feedback loops, only the plain Term is broadcasted locally. The timeout is optional. It specifies the amount to time to wait for replies to arrive in response to a broadcast_request/1. The default period is 0.250 seconds. The timeout is ignored for broadcasts.

An example of three separate processes cooperating in the same scope called peers:

Process A:

   ?- listen(number(X), between(1, 5, X)).
   true.

   ?-

Process B:

   ?- listen(number(X), between(7, 9, X)).
   true.

   ?-

Process C:

   ?- findall(X, broadcast_request(udp(peers, number(X))), Xs).
   Xs = [1, 2, 3, 4, 5, 7, 8, 9].

   ?-

It is also possible to carry on a private dialog with a single responder. To do this, you supply a compound of the form, Term:PortId, to a UDP scoped broadcast/1 or broadcast_request/1, where PortId is the ip-address and port-id of the intended listener. If you supply an unbound variable, PortId, to broadcast_request, it will be unified with the address of the listener that responds to Term. You may send a directed broadcast to a specific member by simply providing this address in a similarly structured compound to a UDP scoped broadcast/1. The message is sent via unicast to that member only by way of the member's broadcast listener. It is received by the listener just as any other broadcast would be. The listener does not know the difference.

For example, in order to discover who responded with a particular value:

Host B Process 1:

   ?- listen(number(X), between(1, 5, X)).
   true.

   ?-

Host A Process 1:


   ?- listen(number(X), between(7, 9, X)).
   true.

   ?-

Host A Process 2:

   ?- listen(number(X), between(1, 5, X)).
   true.

   ?- bagof(X, broadcast_request(udp(peers,number(X):From,1)), Xs).
   From = ip(192, 168, 1, 103):34855,
   Xs = [7, 8, 9] ;
   From = ip(192, 168, 1, 103):56331,
   Xs = [1, 2, 3, 4, 5] ;
   From = ip(192, 168, 1, 104):3217,
   Xs = [1, 2, 3, 4, 5].

All incomming trafic is handled by a single thread with the alias udp_inbound_proxy. This thread also performs the internal dispatching using broadcast/1 and broadcast_request/1. Future versions may provide for handling these requests in separate threads.

Caveats

While the implementation is mostly transparent, there are some important and subtle differences that must be taken into consideration:

author
- Jeffrey Rosenwald (JeffRose@acm.org), Jan Wielemaker
See also
- tipc.pl
license
- BSD-2
 udp_broadcast_service(?Scope, ?Address) is nondet[private]
provides the UDP broadcast address for a given Scope. At present, only one scope is supported, udp_subnet.
Source udp_scope(?ScopeName, ?ScopeDef)[private]
Source make_private_socket is det[private]
Create our private socket. This socket is used for messages that are directed to me. Note that we only need this for broadcast networks. If we use a unicast network we use our public port to contact this specific server.
Source make_public_socket(+ScopeData, +Scope)[private]
Create the public port Scope.
Source dispatch_inbound(+FileNos)[private]
Dispatch inbound traffic. This loop uses wait_for_input/3 to wait for one or more UDP sockets and dispatches the requests using the internal broadcast service. For an incomming broadcast request we send the reply only to the requester and therefore we must use a socket that is not in broadcast mode.
Source ld_dispatch(+PrivateSocket, +Term, +From, +Scope)[private]
Locally dispatch Term received from From. If it concerns a broadcast request, send the replies to PrivateSocket to From. The multifile hook black_list/1 can be used to ignore certain messages.
Source reload_udp_proxy[private]
Update the UDP relaying proxy service. The proxy consists of three forwarding mechanisms:
  • Listen on our scope. If any messages are received, hand them to udp_broadcast/3 to be broadcasted to scope or sent to a specific recipient.
  • Listen on the scope public port. Incomming messages are relayed to the internal broadcast mechanism and replies are sent to from our private socket.
  • Listen on our private port and reply using the same port.
Source udp_broadcast_close(+Scope)
Close a UDP broadcast scope.
Source udp_broadcast(+What, +Scope, +TimeOut)[private]
Send a broadcast request to my UDP peers in Scope. What is either of the shape Term:Address to send Term to a specific address or query the address from which term is answered or it is a plain Term.

If Term is nonground, it is considered is a request (see broadcast_request/1) and the predicate succeeds for each answer received within TimeOut seconds. If Term is ground it is considered an asynchronous broadcast and udp_broadcast/3 is deterministic.

 udp_basic_broadcast(+Term, +Dest) is multi[private]
Create a UDP private socket and use it to send Term to Address. If Address is our broadcast address, set the socket in broadcast mode.

This predicate succeeds with a choice point. Committing the choice point closes S.

Arguments:
Dest- is one of single(Target) or broadcast.
Source udp_broadcast_initialize(+IPAddress, +Options) is semidet
Initialized UDP broadcast bridge. IPAddress is the IP address on the network we want to broadcast on. IP addresses are terms ip(A,B,C,D) or an atom or string of the format A.B.C.D. Options processed:
scope(+ScopeName)
Name of the scope. Default is subnet.
subnet_mask(+SubNet)
Subnet to broadcast on. This uses the same syntax as IPAddress. Default classifies the network as class A, B or C depending on the the first octet and applies the default mask.
port(+Port)
Public port to use. Default is 20005.
method(+Method)
Method to send a message to multiple peers. One of
broadcast
Use UDP broadcast messages to the LAN. This is the default
multicast
Use UDP multicast messages. This can be used on WAN networks, provided the intermediate routers understand multicast.
unicast
Send the messages individually to all registered peers.

For compatibility reasons Options may be the subnet mask.

Source default_subnet(+IP, -NetWork)[private]
Determine the default network address from an IP address. This classifies the network as class A, B or C.
See also
- https://docs.oracle.com/cd/E19504-01/802-5753/planning3-78185/index.html
Source udp_peer_add(+Scope, +Address) is det
Source udp_peer_del(+Scope, ?Address) is det
Source udp_peer(?Scope, ?Address) is nondet
Manage and query the set of known peers for a unicast network. Address is either a term IP:Port or a plain IP address. In the latter case the default port registered with the scope is used.
Arguments:
Address- has canonical form ip(A,B,C,D):Port.
Source udp_term_string_hook(+Scope, +Term, -String) is det[multifile]
udp_term_string_hook(+Scope, -Term, +String) is semidet[multifile]
Hook for serializing the message Term. The default writes %prolog\n, followed by the Prolog term in quoted notation while ignoring operators. This hook may use alternative serialization such as fast_term_serialized/2, use library(ssl) to realise encrypted messages, etc.
Arguments:
Scope- is the scope for which the message is broadcasted. This can be used to use different serialization for different scopes.
Term- encapsulates the term broadcasted by the application as follows:
send(ApplTerm)
Is sent by broadcast(udp(Scope, ApplTerm))
request(Id, ApplTerm)
Is sent by broadcast_request/1, where Id is a unique large (64 bit) integer.
reply(Id, ApplTerm)
Is sent to reply on a broadcast_request/1 request that has been received. Arguments are the same as above.
throws
- The hook may throw udp(invalid_message) to stop processing the message.
Source udp_term_string(+Scope, +Term, -String) is det[private]
udp_term_string(+Scope, -Term, +String) is semidet[private]
Serialize an arbitrary Prolog term as a string. The string is prefixed by a magic key to ensure we only accept messages that are meant for us.

In mode (+,-), Term is written with the options ignore_ops(true) and quoted(true).

This predicate first calls udp_term_string_hook/3.

Source unicast_out_of_scope_request(+Scope, +From, +Data) is semidet[private]
Source udp_unicast_join_hook(+Scope, +From, +Data) is semidet[multifile]
This multifile hook is called if an UDP package is received on the port of the unicast network identified by Scope. From is the origin IP and port and Data is the message data that is deserialized as defined for the scope (see udp_term_string/3).

This hook is intended to initiate a new node joining the network of peers. We could in theory also omit the in-scope test and use a normal broadcast to join. Using a different channal however provides a basic level of security. A possibe implementation is below. The first fragment is a hook added to the server, the second is a predicate added to a client and the last initiates the request in the client. The excanged term (join(X)) can be used to exchange a welcome handshake.

:- multifile udp_broadcast:udp_unicast_join_hook/3.
udp_broadcast:udp_unicast_join_hook(Scope, From, join(welcome)) :-
    udp_peer_add(Scope, From),
join_request(Scope, Address, Reply) :-
    udp_peer_add(Scope, Address),
    broadcast_request(udp(Scope, join(X))).
?- join_request(myscope, "1.2.3.4":10001, Reply).
Reply = welcome.

Undocumented predicates

The following predicates are exported, but not or incorrectly documented.

Source udp_peer(Arg1, Arg2)
Source udp_peer_del(Arg1, Arg2)
ClioPatria (version V3.1.1-40-g9d9e003)