flux_kvsitr_t *flux_kvsitr_create (const flux_kvsdir_t *dir) { flux_kvsitr_t *itr = NULL; const char *key; json_t *dirdata, *value; if (!dir) { errno = EINVAL; goto error; } if (!(itr = calloc (1, sizeof (*itr)))) goto error; if (!(itr->keys = zlist_new ())) goto error; dirdata = treeobj_get_data (dir->dirobj); json_object_foreach (dirdata, key, value) { if (zlist_push (itr->keys, (char *)key) < 0) goto error; } zlist_sort (itr->keys, sort_cmp); itr->reset = true; return itr; error: flux_kvsitr_destroy (itr); return NULL; }
int zmsg_pushstr (zmsg_t *self, const char *format, ...) { assert (self); assert (format); // Format string into buffer va_list argptr; va_start (argptr, format); int size = 255 + 1; char *string = (char *) malloc (size); if (!string) { va_end (argptr); return -1; } int required = vsnprintf (string, size, format, argptr); if (required >= size) { size = required + 1; string = (char *) realloc (string, size); if (!string) { va_end (argptr); return -1; } vsnprintf (string, size, format, argptr); } va_end (argptr); self->content_size += strlen (string); zlist_push (self->frames, zframe_new (string, strlen (string))); free (string); return 0; }
void * zctx__socket_new (zctx_t *self, int type) { // Initialize context now if necessary assert (self); zmutex_lock (self->mutex); if (!self->context) self->context = zmq_init (self->iothreads); zmutex_unlock (self->mutex); if (!self->context) return NULL; // Create and register socket void *zocket = zmq_socket (self->context, type); if (!zocket) return NULL; #if (ZMQ_VERSION_MAJOR == 2) // For ZeroMQ/2.x we use sndhwm for both send and receive zsocket_set_hwm (zocket, self->sndhwm); #else // For later versions we use separate SNDHWM and RCVHWM zsocket_set_sndhwm (zocket, self->sndhwm); zsocket_set_rcvhwm (zocket, self->rcvhwm); #endif zmutex_lock (self->mutex); if (zlist_push (self->sockets, zocket)) { zmutex_unlock (self->mutex); zmq_close (zocket); return NULL; } zmutex_unlock (self->mutex); return zocket; }
int zmsg_push (zmsg_t *self, zframe_t *frame) { assert (self); assert (frame); self->content_size += zframe_size (frame); return zlist_push (self->frames, (void *) frame); }
void zmsg_pushmem (zmsg_t *self, const void *src, size_t size) { assert (self); zframe_t *frame = zframe_new (src, size); self->content_size += size; zlist_push (self->frames, frame); }
/* Don't reply to request - just queue it for later. */ static int clog_request_cb (flux_t h, int typemask, zmsg_t **zmsg, void *arg) { ctx_t *ctx = getctx (h); if (zlist_push (ctx->clog_requests, *zmsg) < 0) oom (); *zmsg = NULL; return 0; }
static void s_service_disable_command (service_t *self, const char *command) { char *item = (char *) zlist_first (self->blacklist); while (item && !streq (item, command)) item = (char *) zlist_next (self->blacklist); if (!item) zlist_push (self->blacklist, strdup (command)); }
/* Don't reply to request - just queue it for later. */ void clog_request_cb (flux_t h, flux_msg_handler_t *w, const flux_msg_t *msg, void *arg) { ctx_t *ctx = getctx (h); flux_msg_t *cpy = flux_msg_copy (msg, true); if (zlist_push (ctx->clog_requests, cpy) < 0) oom (); }
void flux_msg_handler_start (flux_msg_handler_t *w) { struct dispatch *d = w->d; assert (w->magic == HANDLER_MAGIC); flux_watcher_start (d->w); if (zlist_push (d->handlers, w) < 0) oom (); }
int zmsg_pushstr (zmsg_t *self, const char *string) { assert (self); assert (zmsg_is (self)); assert (string); self->content_size += strlen (string); zlist_push (self->frames, zframe_new (string, strlen (string))); return 0; }
int zmsg_pushmem (zmsg_t *self, const void *src, size_t size) { assert (self); zframe_t *frame = zframe_new (src, size); if (frame) { self->content_size += size; return zlist_push (self->frames, frame); } else return -1; }
int zmsg_prepend (zmsg_t *self, zframe_t **frame_p) { assert (self); assert (zmsg_is (self)); assert (frame_p); zframe_t *frame = *frame_p; *frame_p = NULL; // We now own frame self->content_size += zframe_size (frame); return zlist_push (self->frames, frame); }
static vocket_t * vocket_new (driver_t *driver, int socktype, char *vtxname) { assert (driver); vocket_t *self = (vocket_t *) zmalloc (sizeof (vocket_t)); self->driver = driver; self->vtxname = strdup (vtxname); self->binding_hash = zhash_new (); self->peering_hash = zhash_new (); self->peering_list = zlist_new (); self->live_peerings = zlist_new (); self->socktype = socktype; uint index; for (index = 0; index < tblsize (s_vocket_config); index++) if (socktype == s_vocket_config [index].socktype) break; if (index < tblsize (s_vocket_config)) { self->routing = s_vocket_config [index].routing; self->nomnom = s_vocket_config [index].nomnom; self->min_peerings = s_vocket_config [index].min_peerings; self->max_peerings = s_vocket_config [index].max_peerings; } else { zclock_log ("E: invalid vocket type %d", socktype); exit (1); } // Create msgpipe vocket and connect over inproc to vtxname self->msgpipe = zsocket_new (driver->ctx, ZMQ_PAIR); assert (self->msgpipe); zsocket_connect (self->msgpipe, "inproc://%s", vtxname); // If we drop on no peerings, start routing input now if (self->min_peerings == 0) { // Ask reactor to start monitoring vocket's msgpipe pipe zmq_pollitem_t item = { self->msgpipe, 0, ZMQ_POLLIN, 0 }; zloop_poller (driver->loop, &item, s_vocket_input, self); } // Store this vocket per driver so that driver can cleanly destroy // all its vockets when it is destroyed. zlist_push (driver->vockets, self); //* Start transport-specific work self->inbuf_max = VTX_TCP_INBUF_MAX; self->outbuf_max = VTX_TCP_OUTBUF_MAX; //* End transport-specific work return self; }
void * zctx__socket_new (zctx_t *self, int type) { assert (self); // Initialize context now if necessary if (self->context == NULL) self->context = zmq_init (self->iothreads); assert (self->context); // Create and register socket void *socket = zmq_socket (self->context, type); assert (socket); zlist_push (self->sockets, socket); return socket; }
int zloop_timer (zloop_t *self, size_t delay, size_t times, zloop_fn handler, void *arg) { assert (self); s_timer_t *timer = s_timer_new (delay, times, handler, arg); if (!timer) return -1; if (zlist_push (self->timers, timer)) return -1; if (self->verbose) zclock_log ("I: zloop: register timer delay=%d times=%d", delay, times); return 0; }
int module_subscribe (modhash_t *mh, const char *uuid, const char *topic) { module_t *p = zhash_lookup (mh->zh_byuuid, uuid); int rc = -1; if (!p) { errno = ENOENT; goto done; } if (zlist_push (p->subs, xstrdup (topic)) < 0) oom (); rc = 0; done: return rc; }
int zmsg_pushstr (zmsg_t *self, const char *string) { assert (self); assert (zmsg_is (self)); assert (string); size_t len = strlen (string); zframe_t *frame = zframe_new (string, len); if (frame) { self->content_size += len; return zlist_push (self->frames, frame); } else return -1; }
int zmsg_pushstrf (zmsg_t *self, const char *format, ...) { assert (self); assert (zmsg_is (self)); assert (format); va_list argptr; va_start (argptr, format); char *string = zsys_vprintf (format, argptr); va_end (argptr); self->content_size += strlen (string); zlist_push (self->frames, zframe_new (string, strlen (string))); free (string); return 0; }
zlist_t * fetch_rules(void * sock, char * channel) { zlist_t * rules = zlist_new(); /* if(!endpoint) { zclock_log("W: no reup endpoint defined, won't try te refresh rules"); return rules; }*/ // zsocket_connect(sock, endpoint); zstr_sendm(sock, ""); zstr_send(sock, channel); zmsg_t * tmp; // while(tmp=zmsg_recv(sock)) { // zmsg_dump(tmp); //} // exit(1); zmsg_t * msg = zmsg_recv(sock); kill_envelope(msg); char * status = zmsg_popstr(msg); if(strcmp("200", status) != 0) { zclock_log("W: reloading rules for %s failed: got |%s|", channel, status); return rules; } free(status); zmsg_destroy(&msg); while((msg=zmsg_recv(sock))) { zclock_log("once"); kill_envelope(msg); zmsg_dump(msg); zframe_t * header = zmsg_pop(msg); if(zframe_streq(header, "")) { // we're done zclock_log("got a null header, we're out"); zframe_destroy(&header); zmsg_destroy(&msg); break; } zmsg_push(msg, header); zlist_push(rules, msg); } return rules; }
void reduce (flux_reduce_t *r, int batchnum, void *arg) { void *item; zlist_t *tmp = zlist_new (); if (!tmp) oom (); reduce_calls++; while ((item = flux_reduce_pop (r))) { if (zlist_push (tmp, item) < 0) oom (); reduce_items++; } while ((item = zlist_pop (tmp))) { if (flux_reduce_push (r, item) < 0) oom (); } zlist_destroy (&tmp); }
int zloop_poller (zloop_t *self, zmq_pollitem_t *item, zloop_fn handler, void *arg) { assert (self); s_poller_t *poller = s_poller_new (item, handler, arg); if (poller) { if (zlist_push (self->pollers, poller)) return -1; self->dirty = TRUE; if (self->verbose) zclock_log ("I: zloop: register %s poller (%p, %d)", item->socket? zsocket_type_str (item->socket): "FD", item->socket, item->fd); assert (strneq (zsocket_type_str (item->socket), "UNKNOWN")); return 0; } else return -1; }
void cleanup_push (cleaner_fun_f *fun, void * arg) { pthread_mutex_lock(&mutex); if (! cleanup_list || cleaner_pid != getpid()) { // This odd dance is to handle forked processes that do not exec if (cleaner_pid != 0 && cleanup_list) { zlist_destroy(&cleanup_list); } cleanup_list = zlist_new(); cleaner_pid = getpid(); atexit(cleanup); } struct cleaner * c = calloc(sizeof(struct cleaner), 1); c->fun = fun; c->arg = arg; /* Ignore return code, no way to return it callery anyway... */ (void) zlist_push(cleanup_list, c); pthread_mutex_unlock(&mutex); }
void * zctx__socket_new (zctx_t *self, int type) { // Initialize context now if necessary assert (self); if (!self->context) self->context = zmq_init (self->iothreads); if (!self->context) return NULL; // Create and register socket void *zocket = zmq_socket (self->context, type); if (!zocket) return NULL; zsocket_set_hwm (zocket, self->hwm); if (zlist_push (self->sockets, zocket)) { zmq_close (zocket); return NULL; } return zocket; }
static void collect_data_to_send (client_t *self) { zsys_info ("read %d bytes", (int) zpipes_msg_size (self->request)); // Do we have enough data to satisfy the read request? size_t required = zpipes_msg_size (self->request); // If pipe was closed, we'll do a short read with as much // data as we have pending if (required > self->pending && self->pipe == NULL) required = self->pending; if (self->pipe == NULL && self->pending == 0) engine_set_exception (self, pipe_shut_event); else if (self->pending >= required) { // Create a bucket chunk with the required max size zchunk_t *bucket = zchunk_new (NULL, required); // Now fill the bucket with chunks from our queue while (zchunk_size (bucket) < required) { // Get next chunk and consume as much of it as possible zchunk_t *chunk = (zchunk_t *) zlist_pop (self->queue); assert (chunk); zchunk_consume (bucket, chunk); // If chunk is exhausted, destroy it if (zchunk_exhausted (chunk)) zchunk_destroy (&chunk); else { // Push chunk back for next time zlist_push (self->queue, chunk); assert (zchunk_size (bucket) == required); } } zpipes_msg_set_chunk (self->reply, &bucket); self->pending -= required; } else engine_set_exception (self, not_enough_data_event); }
int zmsg_pushstrf (zmsg_t *self, const char *format, ...) { assert (self); assert (zmsg_is (self)); assert (format); va_list argptr; va_start (argptr, format); char *string = zsys_vprintf (format, argptr); va_end (argptr); if (!string) return -1; size_t len = strlen (string); zframe_t *frame = zframe_new (string, len); free (string); if (frame) { self->content_size += len; return zlist_push (self->frames, frame); } else return -1; }
JNIEXPORT jint JNICALL Java_zlist__1_1push (JNIEnv *env, jclass c, jlong self, jlong item) { jint push_ = (jint) zlist_push ((zlist_t *) self, (void *) item); return push_; }
int rrwrk_start(rrwrk_t *self, wrk_task_fn *cb) { self->heartbeat_at = zclock_time() + self->heartbeat; self->cb = cb; //** Start task thread and wait for synchronization signal self->pipe = zthread_fork(self->ctx, rrtask_manager_fn, (void *)self); assert(self->pipe); free(zstr_recv(self->pipe)); //self->liveness = HEARTBEAT_LIVENESS; //** Don't do reconnect before the first connection established while(!zctx_interrupted) { zmq_pollitem_t items[] = {{self->worker, 0, ZMQ_POLLIN, 0}, {self->pipe, 0, ZMQ_POLLIN, 0}}; //** Be aware: this must be within while loop!! int rc = zmq_poll(items, 2, self->heartbeat * ZMQ_POLL_MSEC); if (rc == -1) break; //** Interrupted if (items[0].revents & ZMQ_POLLIN) { //** Data from broker is ready zmsg_t *msg = zmsg_recv(self->worker); if (!msg) break; //** Interrupted. Need to do more research to confirm it self->liveness = HEARTBEAT_LIVENESS; self->last_heartbeat = zclock_time(); //** Dont try to handle errors, just assert noisily assert(zmsg_size(msg) >= 3); //** empty + header + command + ... zframe_t *empty = zmsg_pop(msg); assert(zframe_streq(empty, "")); zframe_destroy(&empty); zframe_t *header = zmsg_pop(msg); assert(zframe_streq(header, RR_WORKER)); zframe_destroy(&header); zframe_t *command = zmsg_pop(msg); if (zframe_streq(command, RRWRK_REQUEST)) { assert(zmsg_size(msg) == 3); //** UUID + SOURCE + INPUT DATA self->total_received++; zmq_pollitem_t item = {self->pipe, 0, ZMQ_POLLOUT, 0}; int rc = zmq_poll(&item, 1, 0); assert(rc != -1); if (item.revents & ZMQ_POLLOUT) { //** Dispatch it if worker is ready //** Send task to task manager zmsg_send(&msg, self->pipe); } else { //** Otherwise put it on waiting list zlist_push(self->data, zmsg_dup(msg)); } } else if (zframe_streq(command, RRWRK_HEARTBEAT)) { ; //** Do nothing for heartbeat } else if (zframe_streq(command, RRWRK_DISCONNECT)) { rrwrk_connect_to_broker(self); } else { log_printf(0, "E: invalid input message\n"); } zframe_destroy(&command); zmsg_destroy(&msg); } else if ((zclock_time() - self->heartbeat) > self->last_heartbeat) { if(--self->liveness == 0) { rrwrk_print(self); log_printf(0, "W: Disconnected from broker - retrying ...\n"); rrwrk_print(self); zclock_sleep(self->reconnect); rrwrk_connect_to_broker(self); } } if (items[1].revents & ZMQ_POLLIN) { //** Data from pipe is ready zmsg_t *output = zmsg_recv(self->pipe); assert(zmsg_size(output) == 3); //** UUID + SOURCE + DATA self->total_finished++; zmsg_t *reply = zmsg_new(); //** Adds UUID + SOURCE to reply message zframe_t *uuid = zframe_dup(zmsg_first(output)); zframe_t *source = zframe_dup(zmsg_next(output)); zmsg_add(reply, uuid); zmsg_add(reply, source); //** Sends reply to broker rrwrk_send_to_broker(self, RRWRK_REPLY, reply); //** Sends output to sinker //zmsg_send(&output, self->sender); rrwrk_send_to_sinker(self, RRWRK_OUTPUT, output); zmsg_destroy(&output); zmsg_destroy(&reply); } //** Dispatch task if any while (true) { zmq_pollitem_t pipe_write = {self->pipe, 0, ZMQ_POLLOUT, 0}; zmq_poll(&pipe_write, 1, 0); if ((pipe_write.revents & ZMQ_POLLOUT) && (zlist_size(self->data))) { zmsg_t* data = (zmsg_t *)zlist_pop(self->data); zmsg_send(&data, self->pipe); printf("Dispatched one task.\n"); } else break; } //** Send HEARTBEAT if it's time if (zclock_time() > self->heartbeat_at) { rrwrk_print(self); rrwrk_send_to_broker(self, RRWRK_HEARTBEAT, NULL); self->heartbeat_at = zclock_time() + self->heartbeat; } } if (zctx_interrupted) log_printf(0, "W: interrupt received. Killing worker...\n"); return -1; }
void zlist_test (bool verbose) { printf (" * zlist: "); // @selftest zlist_t *list = zlist_new (); assert (list); assert (zlist_size (list) == 0); // Three items we'll use as test data // List items are void *, not particularly strings char *cheese = "boursin"; char *bread = "baguette"; char *wine = "bordeaux"; zlist_append (list, cheese); assert (zlist_size (list) == 1); assert ( zlist_exists (list, cheese)); assert (!zlist_exists (list, bread)); assert (!zlist_exists (list, wine)); zlist_append (list, bread); assert (zlist_size (list) == 2); assert ( zlist_exists (list, cheese)); assert ( zlist_exists (list, bread)); assert (!zlist_exists (list, wine)); zlist_append (list, wine); assert (zlist_size (list) == 3); assert ( zlist_exists (list, cheese)); assert ( zlist_exists (list, bread)); assert ( zlist_exists (list, wine)); assert (zlist_head (list) == cheese); assert (zlist_next (list) == cheese); assert (zlist_first (list) == cheese); assert (zlist_tail (list) == wine); assert (zlist_next (list) == bread); assert (zlist_first (list) == cheese); assert (zlist_next (list) == bread); assert (zlist_next (list) == wine); assert (zlist_next (list) == NULL); // After we reach end of list, next wraps around assert (zlist_next (list) == cheese); assert (zlist_size (list) == 3); zlist_remove (list, wine); assert (zlist_size (list) == 2); assert (zlist_first (list) == cheese); zlist_remove (list, cheese); assert (zlist_size (list) == 1); assert (zlist_first (list) == bread); zlist_remove (list, bread); assert (zlist_size (list) == 0); zlist_append (list, cheese); zlist_append (list, bread); assert (zlist_last (list) == bread); zlist_remove (list, bread); assert (zlist_last (list) == cheese); zlist_remove (list, cheese); assert (zlist_last (list) == NULL); zlist_push (list, cheese); assert (zlist_size (list) == 1); assert (zlist_first (list) == cheese); zlist_push (list, bread); assert (zlist_size (list) == 2); assert (zlist_first (list) == bread); assert (zlist_item (list) == bread); zlist_append (list, wine); assert (zlist_size (list) == 3); assert (zlist_first (list) == bread); zlist_t *sub_list = zlist_dup (list); assert (sub_list); assert (zlist_size (sub_list) == 3); zlist_sort (list, s_compare); char *item; item = (char *) zlist_pop (list); assert (item == bread); item = (char *) zlist_pop (list); assert (item == wine); item = (char *) zlist_pop (list); assert (item == cheese); assert (zlist_size (list) == 0); assert (zlist_size (sub_list) == 3); zlist_push (list, sub_list); zlist_t *sub_list_2 = zlist_dup (sub_list); zlist_append (list, sub_list_2); assert (zlist_freefn (list, sub_list, &s_zlist_free, false) == sub_list); assert (zlist_freefn (list, sub_list_2, &s_zlist_free, true) == sub_list_2); zlist_destroy (&list); // Test autofree functionality list = zlist_new (); assert (list); zlist_autofree (list); // Set equals function otherwise equals will not work as autofree copies strings zlist_comparefn (list, s_compare); zlist_push (list, bread); zlist_append (list, cheese); assert (zlist_size (list) == 2); zlist_append (list, wine); assert (zlist_exists (list, wine)); zlist_remove (list, wine); assert (!zlist_exists (list, wine)); assert (streq ((const char *) zlist_first (list), bread)); item = (char *) zlist_pop (list); assert (streq (item, bread)); free (item); item = (char *) zlist_pop (list); assert (streq (item, cheese)); free (item); zlist_destroy (&list); assert (list == NULL); // @end printf ("OK\n"); }
void zlist_test (int verbose) { printf (" * zlist: "); // @selftest zlist_t *list = zlist_new (); assert (list); assert (zlist_size (list) == 0); // Three items we'll use as test data // List items are void *, not particularly strings char *cheese = "boursin"; char *bread = "baguette"; char *wine = "bordeaux"; zlist_append (list, cheese); assert (zlist_size (list) == 1); zlist_append (list, bread); assert (zlist_size (list) == 2); zlist_append (list, wine); assert (zlist_size (list) == 3); assert (zlist_head (list) == cheese); assert (zlist_next (list) == cheese); assert (zlist_first (list) == cheese); assert (zlist_tail (list) == wine); assert (zlist_next (list) == bread); assert (zlist_first (list) == cheese); assert (zlist_next (list) == bread); assert (zlist_next (list) == wine); assert (zlist_next (list) == NULL); // After we reach end of list, next wraps around assert (zlist_next (list) == cheese); assert (zlist_size (list) == 3); zlist_remove (list, wine); assert (zlist_size (list) == 2); assert (zlist_first (list) == cheese); zlist_remove (list, cheese); assert (zlist_size (list) == 1); assert (zlist_first (list) == bread); zlist_remove (list, bread); assert (zlist_size (list) == 0); zlist_append (list, cheese); zlist_append (list, bread); assert (zlist_last (list) == bread); zlist_remove (list, bread); assert (zlist_last (list) == cheese); zlist_remove (list, cheese); assert (zlist_last (list) == NULL); zlist_push (list, cheese); assert (zlist_size (list) == 1); assert (zlist_first (list) == cheese); zlist_push (list, bread); assert (zlist_size (list) == 2); assert (zlist_first (list) == bread); zlist_append (list, wine); assert (zlist_size (list) == 3); assert (zlist_first (list) == bread); zlist_sort (list, s_compare); char *item; item = (char *) zlist_pop (list); assert (item == bread); item = (char *) zlist_pop (list); assert (item == wine); item = (char *) zlist_pop (list); assert (item == cheese); assert (zlist_size (list) == 0); // Destructor should be safe to call twice zlist_destroy (&list); zlist_destroy (&list); assert (list == NULL); // @end printf ("OK\n"); }
static void process_arguments(int argc, char * const *argv) { char c; char *v; int longindex = 0; opterr = 0; static struct option long_options[] = { { "config", required_argument, 0, 'c' }, { "decompressors", required_argument, 0, 's' }, { "device-id", required_argument, 0, 'd' }, { "help", no_argument, 0, 0 }, { "hosts", required_argument, 0, 'h' }, { "input-port", required_argument, 0, 'p' }, { "io-threads", required_argument, 0, 'i' }, { "output-port", required_argument, 0, 'P' }, { "quiet", no_argument, 0, 'q' }, { "rcv-hwm", required_argument, 0, 'R' }, { "snd-hwm", required_argument, 0, 'S' }, { "subscribe", required_argument, 0, 'e' }, { "verbose", no_argument, 0, 'v' }, { 0, 0, 0, 0 } }; while ((c = getopt_long(argc, argv, "vqd:p:P:R:S:c:e:i:s:h:", long_options, &longindex)) != -1) { switch (c) { case 'v': if (verbose) debug= true; else verbose = true; break; case 'q': quiet = true; break; case 'e': subscriptions = split_delimited_string(optarg); break; case 'd': msg_meta.device_number = atoi(optarg); break; case 'p': pull_port = atoi(optarg); break; case 'P': pub_port = atoi(optarg); break; case 'c': config_file_name = optarg; break; case 'i': io_threads = atoi(optarg); if (io_threads == 0) { printf("[E] invalid io-threads value: must be greater than 0\n"); exit(1); } break; case 's': num_compressors = atoi(optarg); if (num_compressors == 0) { printf("[E] invalid number of compressors: must be greater than 0\n"); exit(1); } if (num_compressors > MAX_COMPRESSORS) { printf("[E] invalid number of compressors: must be less than %d\n", MAX_COMPRESSORS+1); exit(1); } break; case 'h': hosts = split_delimited_string(optarg); if (hosts == NULL || zlist_size(hosts) == 0) { printf("[E] must specifiy at least one device to connect to\n"); exit(1); } break; case 'R': rcv_hwm = atoi(optarg); break; case 'S': snd_hwm = atoi(optarg); break; case 0: print_usage(argv); exit(0); break; case '?': if (strchr("depcish", optopt)) fprintf(stderr, "option -%c requires an argument.\n", optopt); else if (isprint (optopt)) fprintf(stderr, "unknown option `-%c'.\n", optopt); else fprintf(stderr, "unknown option character `\\x%x'.\n", optopt); print_usage(argv); exit(1); default: fprintf(stderr, "BUG: can't process option -%c\n", c); exit(1); } } if (hosts == NULL) { hosts = split_delimited_string(getenv("LOGJAM_DEVICES")); if (hosts == NULL) hosts = zlist_new(); if (zlist_size(hosts) == 0) zlist_push(hosts, strdup("localhost")); } augment_zmq_connection_specs(&hosts, pull_port); if (subscriptions == NULL) subscriptions = split_delimited_string(getenv("LOGJAM_SUBSCRIPTIONS")); if (rcv_hwm == -1) { if (( v = getenv("LOGJAM_RCV_HWM") )) rcv_hwm = atoi(v); else rcv_hwm = DEFAULT_RCV_HWM; } if (snd_hwm == -1) { if (( v = getenv("LOGJAM_SND_HWM") )) snd_hwm = atoi(v); else snd_hwm = DEFAULT_SND_HWM; } }