laag-libczmq 4.1.0.0

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

@@ -0,0 +1,107 @@
+//  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.
+//
+//  WARNING: CZMQ APIv2 will not compile with the current version of CZMQ
+//
+//
+//  For more info see: http://hintjens.com/blog:49#toc7
+//
+
+#include <czmq.h>
+
+//  The client task runs in its own context, and receives the 
+//  server public key as an argument.
+
+static void *
+client_task (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
+    zctx_t *ctx = zctx_new ();
+    assert (ctx);
+    void *client = zsocket_new (ctx, ZMQ_PULL);
+    assert (client);
+    zcert_apply (client_cert, client);
+    zsocket_set_curve_serverkey (client, (char *) args);
+    int rc = zsocket_connect (client, "tcp://127.0.0.1:9000");
+    assert (rc == 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");
+
+    //  Free all memory we used
+    zcert_destroy (&client_cert);
+    zctx_destroy (&ctx);
+    return NULL;
+}
+
+static void *
+server_task (void *args)
+{
+    zctx_t *ctx = zctx_new ();
+    assert (ctx);
+    
+    //  Start the authenticator and tell it do authenticate clients
+    //  via the certificates stored in the .curve directory.
+    zauth_t *auth = zauth_new (ctx);
+    assert (auth);
+    zauth_set_verbose (auth, true);
+    zauth_allow (auth, "127.0.0.1");
+    zauth_configure_curve (auth, "*", ".curve");
+    
+    //  Create server socket and configure it to use full encryption
+    void *server = zsocket_new (ctx, ZMQ_PUSH);
+    assert (server);
+    zcert_apply ((zcert_t *) args, server);
+    zsocket_set_curve_server (server, 1);
+    int rc = zsocket_bind (server, "tcp://*:9000");
+    assert (rc != -1);
+
+    //  Send our test message, just once
+    zstr_send (server, "Hello");
+    zclock_sleep (200);
+    
+    //  Free all memory we used
+    zauth_destroy (&auth);
+    zctx_destroy (&ctx);
+    return NULL;
+}
+
+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.
+    zthread_new (server_task, server_cert);
+    zthread_new (client_task, zcert_public_txt (server_cert));
+    
+    //  As we're using detached threads this is the simplest way 
+    //  to ensure they both end, before we exit the process. 200
+    //  milliseconds should be enough for anyone. In real code,
+    //  you would use messages to synchronize threads.
+    zclock_sleep (200);
+
+    //  Free the memory we used
+    zcert_destroy (&server_cert);
+    return 0;
+}

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

@@ -0,0 +1,2 @@
+admin=secret
+

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

@@ -0,0 +1,59 @@
+//  The Stonehouse Pattern
+//
+//  Where we allow any clients to connect, but we promise clients
+//  that we are who we claim to be, and our conversations won't be
+//  tampered with or modified, or spied on.
+//
+//  CZMQ APIv3
+//
+//
+//  For more info see: http://hintjens.com/blog:49#toc5
+//
+
+#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 how to handle CURVE requests
+    zstr_sendx (auth,"CURVE",CURVE_ALLOW_ANY,NULL);
+
+    //  We need two certificates, one for the client and one for
+    //  the server. The client must know the server's public key
+    //  to make a CURVE connection.
+    zcert_t *client_cert = zcert_new ();
+    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 ("Stonehouse 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/strawhouse.c

@@ -0,0 +1,49 @@
+//  The Strawhouse Pattern
+//
+//  We allow or deny clients according to their IP address. It may keep 
+//  spammers and idiots away, but won't stop a real attacker for more 
+//  than a heartbeat.
+//
+//  CZMQ APIv3
+//
+//  For more info see: http://hintjens.com/blog:49#toc3
+//
+#include <czmq.h>
+
+int main (void) 
+{
+    //  Start an authentication engine for this context. This engine
+    //  allows or denies incoming connections (talking to the libzmq
+    //  core over a protocol called ZAP).
+    zactor_t *auth = zactor_new(zauth,NULL);
+    
+    //  Get some indication of what the authenticator is deciding
+    zstr_send (auth,"VERBOSE");
+    zsock_wait (auth);
+    
+    //  Whitelist our address; any other address will be rejected
+    //  Add as much address as argument as you like before the NULL-Argument
+    //  e.g. zstr_sendx (auth,"ALLOW","127.0.0.1","192.168.1.20",NULL);
+    zstr_sendx (auth,"ALLOW","127.0.0.1",NULL);    
+    zsock_wait (auth);
+    
+    //  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 ("Strawhouse test OK");
+
+    zactor_destroy (&auth);
+    zsock_destroy (&client);
+    zsock_destroy (&server);    
+    return 0;
+}

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

@@ -0,0 +1,47 @@
+//  The Woodhouse Pattern
+//
+//  It may keep some malicious people out but all it takes is a bit
+//  of network sniffing, and they'll be able to fake their way in.
+//
+//  CZMQ APIv3
+//
+//
+//  For more info see: http://hintjens.com/blog:49#toc4
+//
+
+#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 how to handle PLAIN requests
+    zstr_sendx(auth,"PLAIN","passwords",NULL);
+    zsock_wait(auth); 
+    //  Create and bind server socket
+    zsock_t *server = zsock_new (ZMQ_PUSH);
+    zsock_set_plain_server (server, 1);
+    zsock_bind (server, "tcp://*:9000");
+
+    //  Create and connect client socket
+    zsock_t *client = zsock_new (ZMQ_PULL);
+    zsock_set_plain_username (client, "admin");
+    zsock_set_plain_password (client, "secret");
+    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 ("Woodhouse test OK");
+
+    zactor_destroy (&auth);
+    zsock_destroy (&server);
+    zsock_destroy (&client);
+    return 0;
+}

data/vendor/github.com/zeromq/czmq/include/.gitignore

@@ -0,0 +1 @@
+platform.h

data/vendor/github.com/zeromq/czmq/include/czmq.h

@@ -0,0 +1,39 @@
+/*  =========================================================================
+    CZMQ - a high-level binding in C for ZeroMQ
+
+    Copyright (c) the Contributors as noted in the AUTHORS file.
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+    =========================================================================
+
+  "Tell them I was a writer.
+   A maker of software.
+   A humanist. A father.
+   And many things.
+   But above all, a writer.
+   Thank You. :)
+   - Pieter Hintjens
+*/
+
+#ifndef __CZMQ_H_INCLUDED__
+#define __CZMQ_H_INCLUDED__
+
+//  These are signatures for handler functions that customize the
+//  behavior of CZMQ containers. These are shared between all CZMQ
+//  container types.
+
+//  -- destroy an item
+typedef void (czmq_destructor) (void **item);
+//  -- duplicate an item
+typedef void *(czmq_duplicator) (const void *item);
+//  - compare two items, for sorting
+typedef int (czmq_comparator) (const void *item1, const void *item2);
+
+//  Include the project library file
+#include "czmq_library.h"
+
+#endif

data/vendor/github.com/zeromq/czmq/include/czmq_library.h

@@ -0,0 +1,190 @@
+/*  =========================================================================
+    czmq - generated layer of public API
+
+    Copyright (c) the Contributors as noted in the AUTHORS file.
+    This file is part of CZMQ, the high-level C binding for 0MQ:
+    http://czmq.zeromq.org.
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+    =========================================================================
+*/
+
+#ifndef CZMQ_LIBRARY_H_INCLUDED
+#define CZMQ_LIBRARY_H_INCLUDED
+
+//  Set up environment for the application
+#include "czmq_prelude.h"
+
+//  External dependencies
+#include <zmq.h>
+
+//  CZMQ version macros for compile-time API detection
+#define CZMQ_VERSION_MAJOR 4
+#define CZMQ_VERSION_MINOR 1
+#define CZMQ_VERSION_PATCH 0
+
+#define CZMQ_MAKE_VERSION(major, minor, patch) \
+    ((major) * 10000 + (minor) * 100 + (patch))
+#define CZMQ_VERSION \
+    CZMQ_MAKE_VERSION(CZMQ_VERSION_MAJOR, CZMQ_VERSION_MINOR, CZMQ_VERSION_PATCH)
+
+#if defined (__WINDOWS__)
+#   if defined CZMQ_STATIC
+#       define CZMQ_EXPORT
+#   elif defined CZMQ_INTERNAL_BUILD
+#       if defined DLL_EXPORT
+#           define CZMQ_EXPORT __declspec(dllexport)
+#       else
+#           define CZMQ_EXPORT
+#       endif
+#   elif defined CZMQ_EXPORTS
+#       define CZMQ_EXPORT __declspec(dllexport)
+#   else
+#       define CZMQ_EXPORT __declspec(dllimport)
+#   endif
+#   define CZMQ_PRIVATE
+#elif defined (__CYGWIN__)
+#   define CZMQ_EXPORT
+#   define CZMQ_PRIVATE
+#else
+#   define CZMQ_EXPORT
+#   if (defined __GNUC__ && __GNUC__ >= 4) || defined __INTEL_COMPILER
+#       define CZMQ_PRIVATE __attribute__ ((visibility ("hidden")))
+#   else
+#       define CZMQ_PRIVATE
+#   endif
+#endif
+
+//  Opaque class structures to allow forward references
+//  These classes are stable or legacy and built in all releases
+typedef struct _zactor_t zactor_t;
+#define ZACTOR_T_DEFINED
+typedef struct _zarmour_t zarmour_t;
+#define ZARMOUR_T_DEFINED
+typedef struct _zcert_t zcert_t;
+#define ZCERT_T_DEFINED
+typedef struct _zcertstore_t zcertstore_t;
+#define ZCERTSTORE_T_DEFINED
+typedef struct _zchunk_t zchunk_t;
+#define ZCHUNK_T_DEFINED
+typedef struct _zclock_t zclock_t;
+#define ZCLOCK_T_DEFINED
+typedef struct _zconfig_t zconfig_t;
+#define ZCONFIG_T_DEFINED
+typedef struct _zdigest_t zdigest_t;
+#define ZDIGEST_T_DEFINED
+typedef struct _zdir_t zdir_t;
+#define ZDIR_T_DEFINED
+typedef struct _zdir_patch_t zdir_patch_t;
+#define ZDIR_PATCH_T_DEFINED
+typedef struct _zfile_t zfile_t;
+#define ZFILE_T_DEFINED
+typedef struct _zframe_t zframe_t;
+#define ZFRAME_T_DEFINED
+typedef struct _zhash_t zhash_t;
+#define ZHASH_T_DEFINED
+typedef struct _zhashx_t zhashx_t;
+#define ZHASHX_T_DEFINED
+typedef struct _ziflist_t ziflist_t;
+#define ZIFLIST_T_DEFINED
+typedef struct _zlist_t zlist_t;
+#define ZLIST_T_DEFINED
+typedef struct _zlistx_t zlistx_t;
+#define ZLISTX_T_DEFINED
+typedef struct _zloop_t zloop_t;
+#define ZLOOP_T_DEFINED
+typedef struct _zmsg_t zmsg_t;
+#define ZMSG_T_DEFINED
+typedef struct _zpoller_t zpoller_t;
+#define ZPOLLER_T_DEFINED
+typedef struct _zsock_t zsock_t;
+#define ZSOCK_T_DEFINED
+typedef struct _zstr_t zstr_t;
+#define ZSTR_T_DEFINED
+typedef struct _zsys_t zsys_t;
+#define ZSYS_T_DEFINED
+typedef struct _zuuid_t zuuid_t;
+#define ZUUID_T_DEFINED
+typedef struct _zauth_t zauth_t;
+#define ZAUTH_T_DEFINED
+typedef struct _zbeacon_t zbeacon_t;
+#define ZBEACON_T_DEFINED
+typedef struct _zgossip_t zgossip_t;
+#define ZGOSSIP_T_DEFINED
+typedef struct _zmonitor_t zmonitor_t;
+#define ZMONITOR_T_DEFINED
+typedef struct _zproxy_t zproxy_t;
+#define ZPROXY_T_DEFINED
+typedef struct _zrex_t zrex_t;
+#define ZREX_T_DEFINED
+//  Draft classes are by default not built in stable releases
+#ifdef CZMQ_BUILD_DRAFT_API
+typedef struct _zargs_t zargs_t;
+#define ZARGS_T_DEFINED
+typedef struct _zproc_t zproc_t;
+#define ZPROC_T_DEFINED
+typedef struct _ztimerset_t ztimerset_t;
+#define ZTIMERSET_T_DEFINED
+typedef struct _ztrie_t ztrie_t;
+#define ZTRIE_T_DEFINED
+#endif // CZMQ_BUILD_DRAFT_API
+
+
+//  Public classes, each with its own header file
+#include "zactor.h"
+#include "zarmour.h"
+#include "zcert.h"
+#include "zcertstore.h"
+#include "zchunk.h"
+#include "zclock.h"
+#include "zconfig.h"
+#include "zdigest.h"
+#include "zdir.h"
+#include "zdir_patch.h"
+#include "zfile.h"
+#include "zframe.h"
+#include "zhash.h"
+#include "zhashx.h"
+#include "ziflist.h"
+#include "zlist.h"
+#include "zlistx.h"
+#include "zloop.h"
+#include "zmsg.h"
+#include "zpoller.h"
+#include "zsock.h"
+#include "zstr.h"
+#include "zsys.h"
+#include "zuuid.h"
+#include "zauth.h"
+#include "zbeacon.h"
+#include "zgossip.h"
+#include "zmonitor.h"
+#include "zproxy.h"
+#include "zrex.h"
+#ifdef CZMQ_BUILD_DRAFT_API
+#include "zargs.h"
+#include "zproc.h"
+#include "ztimerset.h"
+#include "ztrie.h"
+#endif // CZMQ_BUILD_DRAFT_API
+
+#ifdef CZMQ_BUILD_DRAFT_API
+//  Self test for private classes
+CZMQ_EXPORT void
+    czmq_private_selftest (bool verbose);
+#endif // CZMQ_BUILD_DRAFT_API
+
+#endif
+/*
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+*/