FreeBSD Manual Pages
ZSYS(3) CZMQ Manual ZSYS(3) NAME zsys - Class for system-level methods SYNOPSIS // This is a stable class, and may not change except for emergencies. It // is provided in stable builds. // This class has draft methods, which may change over time. They are not // in stable releases, by default. Use --enable-drafts to enable. // Callback for interrupt signal handler typedef void (zsys_handler_fn) ( int signal_value); // Initialize CZMQ zsys layer; this happens automatically when you create // a socket or an actor; however this call lets you force initialization // earlier, so e.g. logging is properly set-up before you start working. // Not threadsafe, so call only from main thread. Safe to call multiple // times. Returns global CZMQ context. CZMQ_EXPORT void * zsys_init (void); // Optionally shut down the CZMQ zsys layer; this normally happens automatically // when the process exits; however this call lets you force a shutdown // earlier, avoiding any potential problems with atexit() ordering, especially // with Windows dlls. CZMQ_EXPORT void zsys_shutdown (void); // Get a new ZMQ socket, automagically creating a ZMQ context if this is // the first time. Caller is responsible for destroying the ZMQ socket // before process exits, to avoid a ZMQ deadlock. Note: you should not use // this method in CZMQ apps, use zsock_new() instead. // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT void * zsys_socket (int type, const char *filename, size_t line_nbr); // Destroy/close a ZMQ socket. You should call this for every socket you // create using zsys_socket(). // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT int zsys_close (void *handle, const char *filename, size_t line_nbr); // Return ZMQ socket name for socket type // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT char * zsys_sockname (int socktype); // Create a pipe, which consists of two PAIR sockets connected over inproc. // The pipe is configured to use the zsys_pipehwm setting. Returns the // frontend socket successful, NULL if failed. CZMQ_EXPORT zsock_t * zsys_create_pipe (zsock_t **backend_p); // Set interrupt handler; this saves the default handlers so that a // zsys_handler_reset () can restore them. If you call this multiple times // then the last handler will take affect. If handler_fn is NULL, disables // default SIGINT/SIGTERM handling in CZMQ. CZMQ_EXPORT void zsys_handler_set (zsys_handler_fn *handler_fn); // Reset interrupt handler, call this at exit if needed CZMQ_EXPORT void zsys_handler_reset (void); // Set default interrupt handler, so Ctrl-C or SIGTERM will set // zsys_interrupted. Idempotent; safe to call multiple times. // Can be suppressed by ZSYS_SIGHANDLER=false // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT void zsys_catch_interrupts (void); // Return 1 if file exists, else zero CZMQ_EXPORT bool zsys_file_exists (const char *filename); // Return file modification time. Returns 0 if the file does not exist. CZMQ_EXPORT time_t zsys_file_modified (const char *filename); // Return file mode; provides at least support for the POSIX S_ISREG(m) // and S_ISDIR(m) macros and the S_IRUSR and S_IWUSR bits, on all boxes. // Returns a mode_t cast to int, or -1 in case of error. CZMQ_EXPORT int zsys_file_mode (const char *filename); // Delete file. Does not complain if the file is absent CZMQ_EXPORT int zsys_file_delete (const char *filename); // Check if file is 'stable' CZMQ_EXPORT bool zsys_file_stable (const char *filename); // Create a file path if it doesn't exist. The file path is treated as // printf format. CZMQ_EXPORT int zsys_dir_create (const char *pathname, ...); // Remove a file path if empty; the pathname is treated as printf format. CZMQ_EXPORT int zsys_dir_delete (const char *pathname, ...); // Move to a specified working directory. Returns 0 if OK, -1 if this failed. CZMQ_EXPORT int zsys_dir_change (const char *pathname); // Set private file creation mode; all files created from here will be // readable/writable by the owner only. CZMQ_EXPORT void zsys_file_mode_private (void); // Reset default file creation mode; all files created from here will use // process file mode defaults. CZMQ_EXPORT void zsys_file_mode_default (void); // Return the CZMQ version for run-time API detection; returns version // number into provided fields, providing reference isn't null in each case. CZMQ_EXPORT void zsys_version (int *major, int *minor, int *patch); // Format a string using printf formatting, returning a freshly allocated // buffer. If there was insufficient memory, returns NULL. Free the returned // string using zstr_free(). CZMQ_EXPORT char * zsys_sprintf (const char *format, ...); // Format a string with a va_list argument, returning a freshly allocated // buffer. If there was insufficient memory, returns NULL. Free the returned // string using zstr_free(). CZMQ_EXPORT char * zsys_vprintf (const char *format, va_list argptr); // Create UDP beacon socket; if the routable option is true, uses // multicast (not yet implemented), else uses broadcast. This method // and related ones might _eventually_ be moved to a zudp class. // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT SOCKET zsys_udp_new (bool routable); // Close a UDP socket // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT int zsys_udp_close (SOCKET handle); // Send zframe to UDP socket, return -1 if sending failed due to // interface having disappeared (happens easily with WiFi) // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT int zsys_udp_send (SOCKET udpsock, zframe_t *frame, inaddr_t *address, int addrlen); // Receive zframe from UDP socket, and set address of peer that sent it // The peername must be a char [INET_ADDRSTRLEN] array if IPv6 is disabled or // NI_MAXHOST if it's enabled. Returns NULL when failing to get peer address. // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT zframe_t * zsys_udp_recv (SOCKET udpsock, char *peername, int peerlen); // Handle an I/O error on some socket operation; will report and die on // fatal errors, and continue silently on "try again" errors. // *** This is for CZMQ internal use only and may change arbitrarily *** CZMQ_EXPORT void zsys_socket_error (const char *reason); // Return current host name, for use in public tcp:// endpoints. Caller gets // a freshly allocated string, should free it using zstr_free(). If the host // name is not resolvable, returns NULL. CZMQ_EXPORT char * zsys_hostname (void); // Move the current process into the background. The precise effect depends // on the operating system. On POSIX boxes, moves to a specified working // directory (if specified), closes all file handles, reopens stdin, stdout, // and stderr to the null device, and sets the process to ignore SIGHUP. On // Windows, does nothing. Returns 0 if OK, -1 if there was an error. CZMQ_EXPORT int zsys_daemonize (const char *workdir); // Drop the process ID into the lockfile, with exclusive lock, and switch // the process to the specified group and/or user. Any of the arguments // may be null, indicating a no-op. Returns 0 on success, -1 on failure. // Note if you combine this with zsys_daemonize, run after, not before // that method, or the lockfile will hold the wrong process ID. CZMQ_EXPORT int zsys_run_as (const char *lockfile, const char *group, const char *user); // Returns true if the underlying libzmq supports CURVE security. // Uses a heuristic probe according to the version of libzmq being used. CZMQ_EXPORT bool zsys_has_curve (void); // Configure the number of I/O threads that ZeroMQ will use. A good // rule of thumb is one thread per gigabit of traffic in or out. The // default is 1, sufficient for most applications. If the environment // variable ZSYS_IO_THREADS is defined, that provides the default. // Note that this method is valid only before any socket is created. CZMQ_EXPORT void zsys_set_io_threads (size_t io_threads); // Configure the scheduling policy of the ZMQ context thread pool. // Not available on Windows. See the sched_setscheduler man page or sched.h // for more information. If the environment variable ZSYS_THREAD_SCHED_POLICY // is defined, that provides the default. // Note that this method is valid only before any socket is created. CZMQ_EXPORT void zsys_set_thread_sched_policy (int policy); // Configure the scheduling priority of the ZMQ context thread pool. // Not available on Windows. See the sched_setscheduler man page or sched.h // for more information. If the environment variable ZSYS_THREAD_PRIORITY is // defined, that provides the default. // Note that this method is valid only before any socket is created. CZMQ_EXPORT void zsys_set_thread_priority (int priority); // Configure the numeric prefix to each thread created for the internal // context's thread pool. This option is only supported on Linux. // If the environment variable ZSYS_THREAD_NAME_PREFIX is defined, that // provides the default. // Note that this method is valid only before any socket is created. CZMQ_EXPORT void zsys_set_thread_name_prefix (int prefix); // Return thread name prefix. CZMQ_EXPORT int zsys_thread_name_prefix (void); // Adds a specific CPU to the affinity list of the ZMQ context thread pool. // This option is only supported on Linux. // Note that this method is valid only before any socket is created. CZMQ_EXPORT void zsys_thread_affinity_cpu_add (int cpu); // Removes a specific CPU to the affinity list of the ZMQ context thread pool. // This option is only supported on Linux. // Note that this method is valid only before any socket is created. CZMQ_EXPORT void zsys_thread_affinity_cpu_remove (int cpu); // Configure the number of sockets that ZeroMQ will allow. The default // is 1024. The actual limit depends on the system, and you can query it // by using zsys_socket_limit (). A value of zero means "maximum". // Note that this method is valid only before any socket is created. CZMQ_EXPORT void zsys_set_max_sockets (size_t max_sockets); // Return maximum number of ZeroMQ sockets that the system will support. CZMQ_EXPORT size_t zsys_socket_limit (void); // Configure the maximum allowed size of a message sent. // The default is INT_MAX. CZMQ_EXPORT void zsys_set_max_msgsz (int max_msgsz); // Return maximum message size. CZMQ_EXPORT int zsys_max_msgsz (void); // Configure the default linger timeout in msecs for new zsock instances. // You can also set this separately on each zsock_t instance. The default // linger time is zero, i.e. any pending messages will be dropped. If the // environment variable ZSYS_LINGER is defined, that provides the default. // Note that process exit will typically be delayed by the linger time. CZMQ_EXPORT void zsys_set_linger (size_t linger); // Configure the default outgoing pipe limit (HWM) for new zsock instances. // You can also set this separately on each zsock_t instance. The default // HWM is 1,000, on all versions of ZeroMQ. If the environment variable // ZSYS_SNDHWM is defined, that provides the default. Note that a value of // zero means no limit, i.e. infinite memory consumption. CZMQ_EXPORT void zsys_set_sndhwm (size_t sndhwm); // Configure the default incoming pipe limit (HWM) for new zsock instances. // You can also set this separately on each zsock_t instance. The default // HWM is 1,000, on all versions of ZeroMQ. If the environment variable // ZSYS_RCVHWM is defined, that provides the default. Note that a value of // zero means no limit, i.e. infinite memory consumption. CZMQ_EXPORT void zsys_set_rcvhwm (size_t rcvhwm); // Configure the default HWM for zactor internal pipes; this is set on both // ends of the pipe, for outgoing messages only (sndhwm). The default HWM is // 1,000, on all versions of ZeroMQ. If the environment var ZSYS_ACTORHWM is // defined, that provides the default. Note that a value of zero means no // limit, i.e. infinite memory consumption. CZMQ_EXPORT void zsys_set_pipehwm (size_t pipehwm); // Return the HWM for zactor internal pipes. CZMQ_EXPORT size_t zsys_pipehwm (void); // Configure use of IPv6 for new zsock instances. By default sockets accept // and make only IPv4 connections. When you enable IPv6, sockets will accept // and connect to both IPv4 and IPv6 peers. You can override the setting on // each zsock_t instance. The default is IPv4 only (ipv6 set to 0). If the // environment variable ZSYS_IPV6 is defined (as 1 or 0), this provides the // default. Note: has no effect on ZMQ v2. CZMQ_EXPORT void zsys_set_ipv6 (int ipv6); // Return use of IPv6 for zsock instances. CZMQ_EXPORT int zsys_ipv6 (void); // Set network interface name to use for broadcasts, particularly zbeacon. // This lets the interface be configured for test environments where required. // For example, on Mac OS X, zbeacon cannot bind to 255.255.255.255 which is // the default when there is no specified interface. If the environment // variable ZSYS_INTERFACE is set, use that as the default interface name. // Setting the interface to "*" means "use all available interfaces". CZMQ_EXPORT void zsys_set_interface (const char *value); // Return network interface to use for broadcasts, or "" if none was set. CZMQ_EXPORT const char * zsys_interface (void); // Set IPv6 address to use zbeacon socket, particularly for receiving zbeacon. // This needs to be set IPv6 is enabled as IPv6 can have multiple addresses // on a given interface. If the environment variable ZSYS_IPV6_ADDRESS is set, // use that as the default IPv6 address. CZMQ_EXPORT void zsys_set_ipv6_address (const char *value); // Return IPv6 address to use for zbeacon reception, or "" if none was set. CZMQ_EXPORT const char * zsys_ipv6_address (void); // Set IPv6 milticast address to use for sending zbeacon messages. This needs // to be set if IPv6 is enabled. If the environment variable // ZSYS_IPV6_MCAST_ADDRESS is set, use that as the default IPv6 multicast // address. CZMQ_EXPORT void zsys_set_ipv6_mcast_address (const char *value); // Return IPv6 multicast address to use for sending zbeacon, or "" if none was // set. CZMQ_EXPORT const char * zsys_ipv6_mcast_address (void); // Configure the automatic use of pre-allocated FDs when creating new sockets. // If 0 (default), nothing will happen. Else, when a new socket is bound, the // system API will be used to check if an existing pre-allocated FD with a // matching port (if TCP) or path (if IPC) exists, and if it does it will be // set via the ZMQ_USE_FD socket option so that the library will use it // instead of creating a new socket. CZMQ_EXPORT void zsys_set_auto_use_fd (int auto_use_fd); // Return use of automatic pre-allocated FDs for zsock instances. CZMQ_EXPORT int zsys_auto_use_fd (void); // Set log identity, which is a string that prefixes all log messages sent // by this process. The log identity defaults to the environment variable // ZSYS_LOGIDENT, if that is set. CZMQ_EXPORT void zsys_set_logident (const char *value); // Set stream to receive log traffic. By default, log traffic is sent to // stdout. If you set the stream to NULL, no stream will receive the log // traffic (it may still be sent to the system facility). CZMQ_EXPORT void zsys_set_logstream (FILE *stream); // Sends log output to a PUB socket bound to the specified endpoint. To // collect such log output, create a SUB socket, subscribe to the traffic // you care about, and connect to the endpoint. Log traffic is sent as a // single string frame, in the same format as when sent to stdout. The // log system supports a single sender; multiple calls to this method will // bind the same sender to multiple endpoints. To disable the sender, call // this method with a null argument. CZMQ_EXPORT void zsys_set_logsender (const char *endpoint); // Enable or disable logging to the system facility (syslog on POSIX boxes, // event log on Windows). By default this is disabled. CZMQ_EXPORT void zsys_set_logsystem (bool logsystem); // Log error condition - highest priority CZMQ_EXPORT void zsys_error (const char *format, ...); // Log warning condition - high priority CZMQ_EXPORT void zsys_warning (const char *format, ...); // Log normal, but significant, condition - normal priority CZMQ_EXPORT void zsys_notice (const char *format, ...); // Log informational message - low priority CZMQ_EXPORT void zsys_info (const char *format, ...); // Log debug-level message - lowest priority CZMQ_EXPORT void zsys_debug (const char *format, ...); // Self test of this class. CZMQ_EXPORT void zsys_test (bool verbose); #ifdef CZMQ_BUILD_DRAFT_API // *** Draft method, for development use, may change without warning *** // Check if default interrupt handler of Ctrl-C or SIGTERM was called. // Does not work if ZSYS_SIGHANDLER is false and code does not call // set interrupted on signal. CZMQ_EXPORT bool zsys_is_interrupted (void); // *** Draft method, for development use, may change without warning *** // Set interrupted flag. This is done by default signal handler, however // this can be handy for language bindings or cases without default // signal handler. CZMQ_EXPORT void zsys_set_interrupted (void); // *** Draft method, for development use, may change without warning *** // Format a string using printf formatting, returning a freshly allocated // buffer. If there was insufficient memory, returns NULL. Free the returned // string using zstr_free(). The hinted version allows to optimize by using // a larger starting buffer size (known to/assumed by the developer) and so // avoid reallocations. CZMQ_EXPORT char * zsys_sprintf_hint (int hint, const char *format, ...); // *** Draft method, for development use, may change without warning *** // Configure the numeric prefix to each thread created for the internal // context's thread pool. This option is only supported on Linux. // If the environment variable ZSYS_THREAD_NAME_PREFIX_STR is defined, that // provides the default. // Note that this method is valid only before any socket is created. CZMQ_EXPORT void zsys_set_thread_name_prefix_str (const char *prefix); // *** Draft method, for development use, may change without warning *** // Return thread name prefix. CZMQ_EXPORT const char * zsys_thread_name_prefix_str (void); // *** Draft method, for development use, may change without warning *** // Configure whether to use zero copy strategy in libzmq. If the environment // variable ZSYS_ZERO_COPY_RECV is defined, that provides the default. // Otherwise the default is 1. CZMQ_EXPORT void zsys_set_zero_copy_recv (int zero_copy); // *** Draft method, for development use, may change without warning *** // Return ZMQ_ZERO_COPY_RECV option. CZMQ_EXPORT int zsys_zero_copy_recv (void); // *** Draft method, for development use, may change without warning *** // Configure the threshold value of filesystem object age per st_mtime // that should elapse until we consider that object "stable" at the // current zclock_time() moment. // The default is S_DEFAULT_ZSYS_FILE_STABLE_AGE_MSEC defined in zsys.c // which generally depends on host OS, with fallback value of 5000. CZMQ_EXPORT void zsys_set_file_stable_age_msec (int64_t file_stable_age_msec); // *** Draft method, for development use, may change without warning *** // Return current threshold value of file stable age in msec. // This can be used in code that chooses to wait for this timeout // before testing if a filesystem object is "stable" or not. CZMQ_EXPORT int64_t zsys_file_stable_age_msec (void); // *** Draft method, for development use, may change without warning *** // Test if ipv6 is available on the system. Return true if available. // The only way to reliably check is to actually open a socket and // try to bind it. (ported from libzmq) CZMQ_EXPORT bool zsys_ipv6_available (void); // *** Draft method, for development use, may change without warning *** // Set IPv4 multicast address to use for sending zbeacon messages. By default // IPv4 multicast is NOT used. If the environment variable // ZSYS_IPV4_MCAST_ADDRESS is set, use that as the default IPv4 multicast // address. Calling this function or setting ZSYS_IPV4_MCAST_ADDRESS // will enable IPv4 zbeacon messages. CZMQ_EXPORT void zsys_set_ipv4_mcast_address (const char *value); // *** Draft method, for development use, may change without warning *** // Return IPv4 multicast address to use for sending zbeacon, or NULL if none was // set. CZMQ_EXPORT const char * zsys_ipv4_mcast_address (void); // *** Draft method, for development use, may change without warning *** // Set multicast TTL default is 1 CZMQ_EXPORT void zsys_set_mcast_ttl (byte value); // *** Draft method, for development use, may change without warning *** // Get multicast TTL CZMQ_EXPORT byte zsys_mcast_ttl (void); // *** Draft method, for development use, may change without warning *** // Print formatted string. Format is specified by variable names // in Python-like format style // // "%(KEY)s=%(VALUE)s", KEY=key, VALUE=value // become // "key=value" // // Returns freshly allocated string or NULL in a case of error. // Not enough memory, invalid format specifier, name not in args // Caller owns return value and must destroy it when done. CZMQ_EXPORT char * zsys_zprintf (const char *format, zhash_t *args); // *** Draft method, for development use, may change without warning *** // Return error string for given format/args combination. // Caller owns return value and must destroy it when done. CZMQ_EXPORT char * zsys_zprintf_error (const char *format, zhash_t *args); // *** Draft method, for development use, may change without warning *** // Print formatted string. Format is specified by variable names // in Python-like format style // // "%(KEY)s=%(VALUE)s", KEY=key, VALUE=value // become // "key=value" // // Returns freshly allocated string or NULL in a case of error. // Not enough memory, invalid format specifier, name not in args // Caller owns return value and must destroy it when done. CZMQ_EXPORT char * zsys_zplprintf (const char *format, zconfig_t *args); // *** Draft method, for development use, may change without warning *** // Return error string for given format/args combination. // Caller owns return value and must destroy it when done. CZMQ_EXPORT char * zsys_zplprintf_error (const char *format, zconfig_t *args); #endif // CZMQ_BUILD_DRAFT_API Please add '@interface' section in './../src/zsys.c'. DESCRIPTION The zsys class provides a portable wrapper for system calls. We collect them here to reduce the number of weird #ifdefs in other classes. As far as possible, the bulk of CZMQ classes are fully portable. Please add @discuss section in ./../src/zsys.c. EXAMPLE From zsys_test method. zsys_catch_interrupts (); // Check capabilities without using the return value int rc = zsys_has_curve (); const char *SELFTEST_DIR_RW = "src/selftest-rw"; if (verbose) { char *hostname = zsys_hostname (); zsys_info ("host name is %s", hostname); freen (hostname); zsys_info ("system limit is %zu ZeroMQ sockets", zsys_socket_limit ()); } #ifdef CZMQ_BUILD_DRAFT_API zsys_set_file_stable_age_msec (5123); assert (zsys_file_stable_age_msec() == 5123); zsys_set_file_stable_age_msec (-1); assert (zsys_file_stable_age_msec() == 5123); #endif // CZMQ_BUILD_DRAFT_API zsys_set_linger (0); zsys_set_sndhwm (1000); zsys_set_rcvhwm (1000); zsys_set_pipehwm (2500); assert (zsys_pipehwm () == 2500); zsys_set_ipv6 (0); zsys_set_thread_priority (-1); zsys_set_thread_sched_policy (-1); zsys_set_thread_name_prefix (0); assert (0 == zsys_thread_name_prefix()); assert (streq ("0", zsys_thread_name_prefix_str())); zsys_thread_affinity_cpu_add (0); zsys_thread_affinity_cpu_remove (0); zsys_set_zero_copy_recv(0); assert (0 == zsys_zero_copy_recv()); zsys_set_zero_copy_recv(1); assert (1 == zsys_zero_copy_recv()); // Test pipe creation zsock_t *pipe_back; zsock_t *pipe_front = zsys_create_pipe (&pipe_back); zstr_send (pipe_front, "Hello"); char *string = zstr_recv (pipe_back); assert (streq (string, "Hello")); freen (string); zsock_destroy (&pipe_back); zsock_destroy (&pipe_front); // Test file manipulation // Don't let anyone fool our workspace if (zsys_file_exists ("nosuchfile")) { zsys_warning ("zsys_test() had to remove 'nosuchfile' which was not expected here at all"); zsys_file_delete ("nosuchfile"); } rc = zsys_file_delete ("nosuchfile"); assert (rc == -1); bool rc_bool = zsys_file_exists ("nosuchfile"); assert (rc_bool != true); rc = (int) zsys_file_size ("nosuchfile"); assert (rc == -1); time_t when = zsys_file_modified ("."); assert (when > 0); int mode = zsys_file_mode ("."); assert (S_ISDIR (mode)); assert (mode & S_IRUSR); assert (mode & S_IWUSR); const char *testbasedir = ".testsys"; const char *testsubdir = "subdir"; char *basedirpath = NULL; // subdir in a test, under SELFTEST_DIR_RW char *dirpath = NULL; // subdir in a test, under basedirpath char *relsubdir = NULL; // relative short "path" of subdir under testbasedir basedirpath = zsys_sprintf ("%s/%s", SELFTEST_DIR_RW, testbasedir); assert (basedirpath); dirpath = zsys_sprintf ("%s/%s", basedirpath, testsubdir); assert (dirpath); relsubdir = zsys_sprintf ("%s/%s", testbasedir, testsubdir); assert (relsubdir); // Normally tests clean up in the end, but if a selftest run dies // e.g. on assert(), workspace remains dirty. Better clean it up. // We do not really care about results here - we clean up a possible // dirty exit of an older build. If there are permission errors etc. // the actual tests below would explode. if (zsys_file_exists(dirpath)) { if (verbose) zsys_debug ("zsys_test() has to remove ./%s that should not have been here", dirpath); zsys_dir_delete (dirpath); } if (zsys_file_exists (basedirpath)) { if (verbose) zsys_debug ("zsys_test() has to remove ./%s that should not have been here", basedirpath); zsys_dir_delete (basedirpath); } // Added tracing because this file-age check fails on some systems // presumably due to congestion in a mass-build and valgrind on top zsys_file_mode_private (); if (verbose) printf ("zsys_test() at timestamp %" PRIi64 ": " "Creating %s\n", zclock_time(), relsubdir ); rc = zsys_dir_create ("%s/%s", SELFTEST_DIR_RW, relsubdir); if (verbose) printf ("zsys_test() at timestamp %" PRIi64 ": " "Finished creating %s with return-code %d\n", zclock_time(), relsubdir, rc ); assert (rc == 0); when = zsys_file_modified (dirpath); if (verbose) printf ("zsys_test() at timestamp %" PRIi64 ": " "Finished calling zsys_file_modified(), got age %jd\n", zclock_time(), (intmax_t)when ); assert (when > 0); if (verbose) printf ("zsys_test() at timestamp %" PRIi64 ": " "Checking if file is NOT stable (is younger than 1 sec)\n", zclock_time() ); assert (!s_zsys_file_stable (dirpath, verbose)); if (verbose) printf ("zsys_test() at timestamp %" PRIi64 ": " "Passed the test, file is not stable - as expected\n", zclock_time() ); rc = zsys_dir_delete ("%s/%s", SELFTEST_DIR_RW, relsubdir); assert (rc == 0); rc = zsys_dir_delete ("%s/%s", SELFTEST_DIR_RW, testbasedir); assert (rc == 0); zsys_file_mode_default (); #if (defined (PATH_MAX)) char cwd[PATH_MAX]; #else # if (defined (_MAX_PATH)) char cwd[_MAX_PATH]; # else char cwd[1024]; # endif #endif memset (cwd, 0, sizeof(cwd)); #if (defined (WIN32)) if (_getcwd(cwd, sizeof(cwd)) != NULL) { #else if (getcwd(cwd, sizeof(cwd)) != NULL) { #endif if (verbose) printf ("zsys_test() at timestamp %" PRIi64 ": " "current working directory is %s\n", zclock_time(), cwd); assert (zsys_dir_change (SELFTEST_DIR_RW) == 0); assert (zsys_dir_change (cwd) == 0); } else { zsys_warning ("zsys_test() : got getcwd() error... " "testing zsys_dir_change() anyway, but it can confuse " "subsequent tests in this process"); assert (zsys_dir_change (SELFTEST_DIR_RW) == 0); } zstr_free (&basedirpath); zstr_free (&dirpath); zstr_free (&relsubdir); // Other subtests int major, minor, patch; zsys_version (&major, &minor, &patch); assert (major == CZMQ_VERSION_MAJOR); assert (minor == CZMQ_VERSION_MINOR); assert (patch == CZMQ_VERSION_PATCH); string = zsys_sprintf ("%s %02x", "Hello", 16); assert (streq (string, "Hello 10")); freen (string); char *str64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890,."; int num10 = 1234567890; string = zsys_sprintf ("%s%s%s%s%d", str64, str64, str64, str64, num10); assert (strlen (string) == (4 * 64 + 10)); freen (string); // Test logging system zsys_set_logident ("czmq_selftest"); zsys_set_logsender ("inproc://logging"); void *logger = zsys_socket (ZMQ_SUB, NULL, 0); assert (logger); rc = zmq_connect (logger, "inproc://logging"); assert (rc == 0); rc = zmq_setsockopt (logger, ZMQ_SUBSCRIBE, "", 0); assert (rc == 0); if (verbose) { zsys_error ("This is an %s message", "error"); zsys_warning ("This is a %s message", "warning"); zsys_notice ("This is a %s message", "notice"); zsys_info ("This is a %s message", "info"); zsys_debug ("This is a %s message", "debug"); zsys_set_logident ("hello, world"); zsys_info ("This is a %s message", "info"); zsys_debug ("This is a %s message", "debug"); // Check that logsender functionality is working char *received = zstr_recv (logger); assert (received); zstr_free (&received); } zsys_close (logger, NULL, 0); { // zhash based printf zhash_t *args = zhash_new (); zhash_insert (args, "key", "value"); zhash_insert (args, "ham", "spam"); char *str = zsys_zprintf ("plain string", args); assert (streq (str, "plain string")); zstr_free (&str); str = zsys_zprintf ("%%a%%", args); assert (streq (str, "%a%")); zstr_free (&str); str = zsys_zprintf ("VALUE=%(key)s123", args); assert (streq (str, "VALUE=value123")); zstr_free (&str); str = zsys_zprintf ("VALUE=%(key)s123, %(ham)s, %(ham)s, %%(nospam)s!!!", args); assert (streq (str, "VALUE=value123, spam, spam, %(nospam)s!!!")); zstr_free (&str); str = zsys_zprintf ("VALUE=%(nokey)s123, %(ham)s, %(ham)s, %%(nospam)s!!!", args); assert (!str); str = zsys_zprintf_error ("VALUE=%(nokey)s123, %(ham)s, %(ham)s, %%(nospam)s!!!", args); assert (streq (str, "Key 'nokey' not found in hash")); zstr_free (&str); str = zsys_zprintf ("VALUE=%(key)s/%%S", args); assert (streq (str, "VALUE=value/%S")); zstr_free (&str); zhash_destroy (&args); //ZPL based printf zconfig_t *root = zconfig_new ("root", NULL); zconfig_put (root, "zsp", ""); zconfig_put (root, "zsp/return_code", "0"); str = zsys_zplprintf ("return_code=%(zsp/return_code)s", root); assert (streq (str, "return_code=0")); zstr_free (&str); zconfig_destroy (&root); } AUTHORS The czmq manual was written by the authors in the AUTHORS file. RESOURCES Main web site: Report bugs to the email <zeromq-dev@lists.zeromq.org[1]> COPYRIGHT 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/. LICENSE included with the czmq distribution. NOTES 1. zeromq-dev@lists.zeromq.org mailto:zeromq-dev@lists.zeromq.org CZMQ 4.2.1 11/01/2025 ZSYS(3)
NAME | SYNOPSIS | DESCRIPTION | EXAMPLE | AUTHORS | RESOURCES | COPYRIGHT | NOTES
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=zsys&sektion=3&manpath=FreeBSD+Ports+15.0>