laag-libczmq 4.1.0.0

data/vendor/github.com/zeromq/czmq/doc/mkman

@@ -0,0 +1,217 @@
+#! /usr/bin/perl
+#
+#   mkman - Generates man pages from C source and header files.
+#
+#   Syntax: './mkman srcname [outp rootsrcdir]'
+#   Must be executed in doc/ subdirectory under build workspace root.
+#     srcname - basename of .c or .cc source file located directly in the
+#               $rootsrcdir/src/ directory. For classes (MAN3) also implies
+#               a header (.h) file located directly in $rootsrcdir/include/.
+#     outp    - (optional) filename without extension (will be chopped if
+#               provided) of the resulting TXT and DOC files; may be a
+#               slash-separated path e.g. for out-of-tree builds (distcheck).
+#               Defaults to: "$srcname"
+#     rootsrcdir - (optional) location of project source root (may differ
+#               from build root) where to look for input source-code files.
+#               Defaults to: ".." (good for in-tree builds)
+#
+#   Copyright (c) 1996-2016 iMatix Corporation
+#   Copyright (c) 2016-2017 zproject community
+#
+#   This is free software; you can redistribute it and/or modify it under the
+#   terms of the GNU General Public License as published by the Free Software
+#   Foundation; either version 3 of the License, or (at your option) any later
+#   version.
+#
+#   This software is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABIL-
+#   ITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+#   License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+use File::Basename;
+use Cwd;
+
+sub pull {
+    local ($_) = @_;
+    if (/^(.*)(@[a-zA-Z0-9]+)(,(\w*)\s*)?/) {
+        $file = $1;
+        $tag = $2;
+        $opts = $4;
+        $text = "";
+        $ext = (fileparse("$file", qr/[^.]*/))[2];
+        die "Can't read '$file': $!"
+            unless open (SOURCE, $file);
+
+        while (<SOURCE>) {
+            if (/$tag/) {
+                while (<SOURCE>) {
+                    last if /\@discuss/ || /\@end/ || /\@ignore/ || /\@header/;
+                    $_ = "    $_" if ($opts eq "code");
+                    s/^    // if ($opts eq "left");
+                    $_ = "    $_" if ($opts eq "test");
+                    s/^        /    / if ($opts eq "test");
+                    $text .= $_;
+                }
+            }
+        }
+        close (SOURCE);
+        # Add code fences for markdown highlighting
+        $text = "```$ext\n$text```\n" if (length $text) and ($opts eq "code" or $opts eq "test");
+
+        $text = "Please add '$tag' section in '$file'.\n" unless $text;
+        return $text;
+    }
+    else {
+        print "E: bad pull request: $_\n";
+    }
+}
+
+sub generate_manpage {
+    local ($name, $outp, $rootsrcdir) = @_;
+    $name = $1 if $name =~ /(\w+)\.\w+/; # Chop off extensions
+    $outp = $1 if $outp =~ /^(.+)\.[^\.\/]+$/;
+    $outp_basename = basename ($outp);
+    $outp_basename = $2 if $outp =~ /^(.*\/)?(\w+)$/;
+
+    if ($ENV{"V"} == "1") {
+        printf "D: generate_manpage() got name='$name' outp='$outp' outp_basename='$outp_basename' rootsrcdir='$rootsrcdir'\n";
+    }
+
+    #   Check if we're making the man page for a main program, or a class
+    $cat = 0;           #   Unknown category
+    $cat_text = "";
+    die "Can't open '" . cwd() . "/Makefile'"
+        unless open (MAKEFILE, "Makefile");
+    while (<MAKEFILE>) {
+        if (/MAN1.*$outp_basename\.1/) {
+            $source = "$rootsrcdir/src/$name.c";
+            $header = "$rootsrcdir/src/$name.c";
+            $cat = 1;
+            $cat_text = "Program for ";
+            last;
+        }
+        elsif (/MAN3.*$name\.3/) {
+            $source = "$rootsrcdir/src/$name.c";
+            $header = "$rootsrcdir/include/$name.h";
+            $cat = 3;
+            $cat_text = "Class for ";
+            last;
+        }
+    }
+    close MAKEFILE;
+
+    die "The Makefile defined no manpage category for $outp_basename.1 or $name.3"
+        unless ($source ne "");
+
+    #   Look for class title in 2nd line of source
+    #   If there's no class file, leave hand-written man page alone
+    if (! open (SOURCE, $source)) {
+        # Support mixed-source projects (named C in config,
+        # but having both .c and .cc files in reality)
+        printf "Can't open C '$source', retry for C++\n";
+        if ($header eq $source) {
+            $header .= "c";
+        }
+        $source .= "c"; # Retry for a *.cc filename
+    }
+    die "Can't open '$source'"
+        unless open (SOURCE, $source);
+    # NOTE: This duplication of lines is needed for proper work:
+    $_ = <SOURCE>;
+    $_ = <SOURCE>;
+    $title = "no title found";
+    $title = $1 if (/    \w+ - (.*)/);
+    close (SOURCE);
+
+    printf "  MKMAN[txt]\t$source ";
+    if ($source ne $header) {
+        printf "+ $header ";
+    }
+    printf "\t=> $outp.txt\n";
+    #   Open output file
+    die "Can't create '$outp.txt': $!"
+        unless open (OUTPUT, ">$outp.txt");
+
+    $underline = "=" x (length ($name) + 3);
+
+    $template = <<"END";
+$name($cat)
+$underline
+
+NAME
+----
+$outp_basename - $cat_text$title
+
+SYNOPSIS
+--------
+----
+pull $header\@interface
+pull $source\@interface,left
+----
+
+DESCRIPTION
+-----------
+
+pull $source\@header,left
+
+pull $source\@discuss,left
+
+EXAMPLE
+-------
+.From $name\_test method
+----
+pull $source\@selftest,left
+----
+END
+
+    #   Now process template
+    for (split /^/, $template) {
+        if (/^pull (.*)$/) {
+            print OUTPUT pull ($1);
+        }
+        else {
+            print OUTPUT $_;
+        }
+    }
+    close OUTPUT;
+
+    #   Generate a simple text documentation for README.txt
+    printf "  MKMAN[doc]\t$source ";
+    if ($source ne $header) {
+        printf "+ $header ";
+    }
+    printf "\t=> $outp.doc\n";
+
+    die "Can't create '$outp.doc': $!"
+        unless open (OUTPUT, ">$outp.doc");
+
+    print OUTPUT "#### $outp_basename - $title\n\n";
+    print OUTPUT pull ("$source\@header,left");
+    print OUTPUT "\n";
+    print OUTPUT pull ("$source\@discuss,left");
+    print OUTPUT "\nThis is the class interface:\n\n";
+    print OUTPUT pull ("$header\@interface,code");
+    print OUTPUT pull ("$source\@interface,left");
+    print OUTPUT "\nThis is the class self test code:\n\n";
+    print OUTPUT pull ("$source\@selftest,test");
+    print OUTPUT "\n";
+    close OUTPUT;
+}
+
+$name = shift (@ARGV);
+$outp = shift (@ARGV);
+if (!$outp) {
+    $outp=$name;
+}
+$rootsrcdir = shift (@ARGV);
+if (!$rootsrcdir) {
+    $rootsrcdir="..";
+}
+
+if ($ENV{"V"} == "1") {
+    printf "D: got name='$name' outp='$outp' rootsrcdir='$rootsrcdir' from the start\n";
+}
+generate_manpage ($name, $outp, $rootsrcdir);

data/vendor/github.com/zeromq/czmq/doc/mkmans

@@ -0,0 +1,15 @@
+#! /bin/bash
+#
+#   mkmans - rebuild man page sources from classes
+#
+#   Author: Pieter Hintjens <ph@imatix.com>
+#   License: public domain
+#
+#   syntax: mkmans
+#
+
+rm -f *.xml    #   Makefile does not detect version differences for XML
+for FILE in z*.txt; do 
+    ./mkman $FILE
+done
+

data/vendor/github.com/zeromq/czmq/doc/wdput

@@ -0,0 +1,43 @@
+#! /usr/bin/python
+#
+#   wdput - Send one Wikidot page to api.zero.mq
+#   Part of the ztools/apisite toolkit. Install into any directory on PATH.
+#
+#   Author: Pieter Hintjens <ph@imatix.com>
+#   License: public domain
+#
+#   syntax: wdput sitename category page title
+#
+#   Wikidot text must be in page + '.wd'
+#
+#   Supply your Wikidot user name as an environment variable APISITE_USER
+#   Supply your Wikidot API key as an environment variable APISITE_KEY
+
+#   Get script arguments
+import sys
+sitename = sys.argv [1]
+category = sys.argv [2]
+name     = sys.argv [3]
+title    = sys.argv [4]
+
+#   Get authentication credentials
+import os
+user = os.environ ['APISITE_USER']
+key  = os.environ ['APISITE_KEY']
+
+#   Create XML/RPC connection to Wikidot
+from xmlrpclib import ServerProxy
+server = ServerProxy ('https://' + user + ':' + key + '@www.wikidot.com/xml-rpc-api.php')
+
+#   Send page content (create or update)
+file = open (name + ".wd", "r")
+content = ""
+for line in file:
+    content = content + line
+
+print " - " + category + ":" + name
+server.pages.save_one ({
+    "site": sitename,
+    "page": category + ":" + name,
+    "title": title,
+    "content": content})

data/vendor/github.com/zeromq/czmq/examples/security/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2010-2013 iMatix Corporation and Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/github.com/zeromq/czmq/examples/security/README.txt

@@ -0,0 +1,9 @@
+These examples show the five main security patterns that ZeroMQ/4.x 
+provides, and CZMQ wraps up in its zauth class:
+
+* Grasslands - plain text with no authentication
+* Strawhouse - plain text with authentication by IP address
+* Woodhouse - plain text with authentication by IP address and/or name & password
+* Stonehouse - encrypted, with server authentication but no client authentication
+* Ironhouse - encrypted and authentication of both clients and server
+

data/vendor/github.com/zeromq/czmq/examples/security/grasslands.c

@@ -0,0 +1,32 @@
+//  The Grasslands Pattern
+//
+//  The Classic ZeroMQ model, plain text with no protection at all.
+//
+//  CZMQ APIv3
+//
+//  More info: http://hintjens.com/blog:49#toc2
+//
+
+#include <czmq.h>
+
+int main (void) 
+{
+    //  Create and bind server socket
+    zsock_t *server = zsock_new (ZMQ_PUSH);
+    zsock_bind (server, "tcp://*:9000");
+
+    //  Create and connect client socket
+    zsock_t *client = zsock_new (ZMQ_PULL);
+    zsock_connect (client, "tcp://127.0.0.1:9000");
+    
+    //  Send a single message from server to client
+    zstr_send (server, "Hello");
+    char *message = zstr_recv (client);
+    assert (streq (message, "Hello"));
+    free (message);
+    puts ("Grasslands test OK");
+    
+    zsock_destroy (&client);
+    zsock_destroy (&server);
+    return 0;
+}

data/vendor/github.com/zeromq/czmq/examples/security/hello.c

@@ -0,0 +1,13 @@
+//
+//  CZMQ APIv3
+//
+
+#include <czmq.h>
+
+int main (void) {
+    zsock_t *publisher = zsock_new (ZMQ_PUB);
+    zsock_set_curve_server (publisher, true);
+    puts ("Hello, Curve!");
+    zsock_destroy(&publisher);
+    return 0;
+}

data/vendor/github.com/zeromq/czmq/examples/security/ironhouse.c

@@ -0,0 +1,64 @@
+//  The Ironhouse Pattern
+//
+//  Security doesn't get any stronger than this. An attacker is going to
+//  have to break into your systems to see data before/after encryption.
+//
+//  CZMQ APIv3
+//
+//
+//  For more info see: http://hintjens.com/blog:49#toc6
+//
+
+#include <czmq.h>
+
+int main (void) 
+{
+    //  Create and start authentication engine
+    zactor_t *auth = zactor_new (zauth,NULL);
+    zstr_send(auth,"VERBOSE");
+    zsock_wait(auth);
+    zstr_sendx(auth,"ALLOW","127.0.0.1",NULL);
+    zsock_wait(auth);
+
+    //  Tell the authenticator to use the certificate store in .curve
+    zstr_sendx (auth,"CURVE",".curve",NULL);
+
+    //  We'll generate a new client certificate and save the public part
+    //  in the certificate store (in practice this would be done by hand
+    //  or some out-of-band process).
+    zcert_t *client_cert = zcert_new ();
+    zsys_dir_create (".curve");
+    zcert_set_meta (client_cert, "name", "Client test certificate");
+    zcert_save_public (client_cert, ".curve/testcert.pub");
+    
+    //  Prepare the server certificate as we did in Stonehouse
+    zcert_t *server_cert = zcert_new ();
+    const char *server_key = zcert_public_txt (server_cert);
+    
+    //  Create and bind server socket
+    zsock_t *server = zsock_new (ZMQ_PUSH);
+    zcert_apply (server_cert, server);
+    zsock_set_curve_server (server, 1);
+    zsock_bind (server, "tcp://*:9000");
+
+    //  Create and connect client socket
+    zsock_t *client = zsock_new (ZMQ_PULL);
+    zcert_apply (client_cert, client);
+    zsock_set_curve_serverkey (client, server_key);
+    zsock_connect (client, "tcp://127.0.0.1:9000");
+    
+    //  Send a single message from server to client
+    zstr_send (server, "Hello");
+    char *message = zstr_recv (client);
+    assert (streq (message, "Hello"));
+    free (message);
+    puts ("Ironhouse test OK");
+
+    zcert_destroy (&client_cert);
+    zcert_destroy (&server_cert);
+    zactor_destroy (&auth);
+    zsock_destroy (&client);
+    zsock_destroy (&server);
+
+    return 0;
+}

data/vendor/github.com/zeromq/czmq/examples/security/ironhouse2.c

@@ -0,0 +1,123 @@
+//  The Ironhouse Pattern
+//
+//  This is exactly the same example but broken into two threads
+//  so you can better see what client and server do, separately.
+
+#include <czmq.h>
+
+void await_term (zsock_t *pipe)
+{
+    bool terminated = false;
+    while (!terminated) {
+        zmsg_t *msg = zmsg_recv (pipe);
+        if (!msg)
+            break;              //  Interrupted
+        char *command = zmsg_popstr (msg);
+        //  All actors must handle $TERM in this way
+        if (streq (command, "$TERM"))
+            terminated = true;
+        else {
+            puts ("E: invalid message to actor");
+            assert (false);
+        }
+        free (command);
+        zmsg_destroy (&msg);
+    }
+}
+
+//  The client task runs in its own context, and receives the
+//  server public key as an argument.
+
+static void
+client_task (zsock_t *pipe, void *args)
+{
+    //  Load our persistent certificate from disk
+    zcert_t *client_cert = zcert_load ("client_cert.txt");
+    assert (client_cert);
+
+    //  Create client socket and configure it to use full encryption
+    zsock_t *client = zsock_new (ZMQ_PULL);
+    assert (client);
+    zcert_apply (client_cert, client);
+    zsock_set_curve_serverkey (client, (char *) args);
+    int rc = zsock_connect (client, "tcp://127.0.0.1:9000");
+    assert (rc == 0);
+
+    zsock_signal (pipe, 0);
+
+    //  Wait for our message, that signals the test was successful
+    char *message = zstr_recv (client);
+    assert (streq (message, "Hello"));
+    free (message);
+    puts ("Ironhouse test OK");
+
+    await_term (pipe);
+
+    //  Free all memory we used
+    zsock_destroy (&client);
+    zcert_destroy (&client_cert);
+}
+
+static void
+server_task (zsock_t *pipe, void *args)
+{
+    //  Start the authenticator and tell it do authenticate clients
+    //  via the certificates stored in the .curve directory.
+    zactor_t *auth = zactor_new (zauth, NULL);
+    assert (auth);
+    assert (zstr_send (auth, "VERBOSE") == 0);
+    assert (zsock_wait (auth) >= 0);
+    assert (zstr_sendx (auth, "ALLOW", "127.0.0.1", NULL) == 0);
+    assert (zsock_wait (auth) >= 0);
+    assert (zstr_sendx (auth, "CURVE", ".curve", NULL) == 0);
+    assert (zsock_wait (auth) >= 0);
+
+    //  Create server socket and configure it to use full encryption
+    zsock_t *server = zsock_new (ZMQ_PUSH);
+    assert (server);
+    zcert_apply ((zcert_t *) args, server);
+    zsock_set_curve_server (server, 1);
+    int rc = zsock_bind (server, "tcp://*:9000");
+    assert (rc != -1);
+
+    zsock_signal (pipe, 0);
+
+    //  Send our test message, just once
+    assert (zstr_send (server, "Hello") == 0);
+
+    await_term (pipe);
+
+    //  Free all memory we used
+    zsock_destroy (&server);
+    zactor_destroy (&auth);
+}
+
+int main (void)
+{
+    //  Create the certificate store directory and client certs
+    zcert_t *client_cert = zcert_new ();
+    int rc = zsys_dir_create (".curve");
+    assert (rc == 0);
+    zcert_set_meta (client_cert, "name", "Client test certificate");
+    zcert_save_public (client_cert, ".curve/testcert.pub");
+    rc = zcert_save (client_cert, "client_cert.txt");
+    assert (rc == 0);
+    zcert_destroy (&client_cert);
+
+    //  Create the server certificate
+    zcert_t *server_cert = zcert_new ();
+
+    //  Now start the two detached threads; each of these has their
+    //  own ZeroMQ context.
+    zactor_t *server_actor = zactor_new (server_task, server_cert);
+    assert (server_actor);
+    zactor_t *client_actor = zactor_new (client_task, (void *) zcert_public_txt (server_cert));
+    assert (client_actor);
+
+    //  Free the memory we used
+    //  and coordinate process termination with actor termination
+    zactor_destroy (&client_actor);
+    zactor_destroy (&server_actor);
+
+    return 0;
+}