void
zconfig_destroy (zconfig_t **self_p)
{
assert (self_p);
if (*self_p) {
zconfig_t *self = *self_p;
// Destroy all children and siblings recursively
if (self->child)
zconfig_destroy (&self->child);
if (self->next)
zconfig_destroy (&self->next);
zlist_destroy (&self->comments);
free (self->name);
free (self->value);
free (self);
*self_p = NULL;
}
}
static void
client_destroy (client_t **self_p)
{
assert (self_p);
if (*self_p) {
client_t *self = *self_p;
fmq_config_destroy (&self->config);
fmq_msg_destroy (&self->request);
fmq_msg_destroy (&self->reply);
// Destroy subscriptions
while (zlist_size (self->subs)) {
sub_t *sub = (sub_t *) zlist_pop (self->subs);
sub_destroy (&sub);
}
zlist_destroy (&self->subs);
free (self);
*self_p = NULL;
}
}
void
zconfig_comment (zconfig_t *self, char *format, ...)
{
if (format) {
if (!self->comments) {
self->comments = zlist_new ();
zlist_autofree (self->comments);
}
va_list argptr;
va_start (argptr, format);
char *string = zsys_vprintf (format, argptr);
va_end (argptr);
zlist_append (self->comments, string);
free (string);
}
else
zlist_destroy (&self->comments);
}
static void
zsync_node_destroy (zsync_node_t **self_p)
{
assert (self_p);
if (*self_p) {
zsync_node_t *self = *self_p;
zuuid_destroy (&self->own_uuid);
// TODO destroy all zsync_peers
zlist_destroy (&self->peers);
zhash_destroy (&self->zyre_peers);
zyre_destroy (&self->zyre);
free (self);
self_p = NULL;
}
}
int main(void)
{
zctx_t *ctx = zctx_new();
lbbroker_t *self = (lbbroker_t *)zmalloc(sizeof(lbbroker_t));
self->frontend = zsocket_new(ctx, ZMQ_ROUTER);
self->backend = zsocket_new(ctx, ZMQ_ROUTER);
#if (defined (WIN32))
zsocket_bind(self->frontend, "tcp://*:5672"); // frontend
zsocket_bind(self->backend, "tcp://*:5673"); // backend
#else
zsocket_bind(self->frontend, "ipc://frontend.ipc");
zsocket_bind(self->backend, "ipc://backend.ipc");
#endif
int client_nbr;
for (client_nbr = 0; client_nbr < NBR_CLIENTS; client_nbr++)
zthread_new(client_task, NULL);
int worker_nbr;
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++)
zthread_new(worker_task, NULL);
// Queue of available workers
self->workers = zlist_new();
// Prepare reactor and fire it up
zloop_t *reactor = zloop_new();
zmq_pollitem_t poller = { self->backend, 0, ZMQ_POLLIN };
zloop_poller(reactor, &poller, s_handle_backend, self);
zloop_start(reactor);
zloop_destroy(&reactor);
// When we're done, clean up properly
while (zlist_size(self->workers)) {
zframe_t *frame = (zframe_t *)zlist_pop(self->workers);
zframe_destroy(&frame);
}
zlist_destroy(&self->workers);
zctx_destroy(&ctx);
free(self);
return 0;
}
/*
PUB tcp://*:9003
<< [ "(?stock:[A-Z][A-Z0-9]+)" ]
[ timestamp :f64 ]
[ price :f64 ]
*/
int main(int argc, const char* argv[])
{
SetConsoleTitle(L"tickz.server");
// initialize random number generator
srand( (unsigned int)time(NULL) );
// initialize stock data
tick_t msft = tick_new("MSFT", 41.78);
tick_t aapl = tick_new("AAPL", 95.35);
tick_t goog = tick_new("GOOG",571.09);
tick_t yhoo = tick_new("YHOO", 34.53);
tick_t bbry = tick_new("BBRY", 10.90);
zlist_t *stocks = zlist_new();
zlist_append(stocks,&msft);
zlist_append(stocks,&aapl);
zlist_append(stocks,&goog);
zlist_append(stocks,&yhoo);
zlist_append(stocks,&bbry);
// set up publisher
zctx_t *ctx = zctx_new();
void *pub = zsocket_new(ctx,ZMQ_PUB);
zsocket_bind(pub,"tcp://*:9003");
// set up main loop
zloop_t *loop = zloop_new();
zloop_data_t loopdata;
loopdata.stocks = stocks;
loopdata.socket = pub;
// every 500 ms, update the stocks and publish the new data
int timer = zloop_timer(loop,500,0,onloop,&loopdata); //TOOD: take delay as input
zloop_start(loop); //NOTE: CTRL+C will cleanly interrupt the infinite loop
// clean up
zctx_destroy(&ctx);
zlist_destroy(&stocks);
return 0;
}
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
zinterface_test(bool verbose)
{
printf(" * zinterface: ");
zlist_t *interfaces = zinterface_list();
assert(interfaces);
if (verbose) {
printf("Len: %zu\n", zlist_size(interfaces));
zinterface_t *iface = zlist_first(interfaces);
while (iface) {
printf ("%s\t%s\t%s\t%s\n", zinterface_name(iface), zinterface_address(iface),
zinterface_netmask(iface), zinterface_broadcast(iface));
iface = zlist_next(interfaces);
}
}
zlist_destroy(&interfaces);
printf("OK\n");
}
void
ztask_job_request_dump (ztask_job_request_t *self)
{
assert (self);
zclock_log("ztask_job_request: Processes=%ld", zhash_size (self->processes));
zlist_t *keys = zhash_keys (self->processes);
char *key = (char *) zlist_first (keys);
ztask_job_proc_t *p;
while (key) {
zclock_log ("ztask_job_request: key=%s", key);
p = (ztask_job_proc_t *) zhash_lookup (self->processes, key);
ztask_job_proc_dump (p);
key = (char *) zlist_next (keys);
}
zlist_destroy (&keys);
}
zlist_t *
zlist_dup (zlist_t *self)
{
if (!self)
return NULL;
zlist_t *copy = zlist_new ();
copy->autofree = self->autofree;
if (copy) {
node_t *node;
for (node = self->head; node; node = node->next) {
if (!zlist_append (copy, node->item)) {
zlist_destroy (©);
break;
}
}
}
return copy;
}
void
zconfig_destroy (zconfig_t **self_p)
{
assert (self_p);
if (*self_p) {
zconfig_t *self = *self_p;
// Destroy all children and siblings recursively
zconfig_destroy (&self->child);
zconfig_destroy (&self->next);
// Destroy other properties and then self
zlist_destroy (&self->comments);
zfile_destroy (&self->file);
free (self->name);
free (self->value);
free (self);
*self_p = NULL;
}
}
void
zhash_comment (zhash_t *self, const char *format, ...)
{
if (format) {
if (!self->comments) {
self->comments = zlist_new ();
if (!self->comments)
return;
zlist_autofree (self->comments);
}
va_list argptr;
va_start (argptr, format);
char *string = zsys_vprintf (format, argptr);
va_end (argptr);
if (string)
zlist_append (self->comments, string);
zstr_free (&string);
}
else
zlist_destroy (&self->comments);
}
void
zre_msg_destroy (zre_msg_t **self_p)
{
assert (self_p);
if (*self_p) {
zre_msg_t *self = *self_p;
// Free class properties
zframe_destroy (&self->routing_id);
free (self->ipaddress);
if (self->groups)
zlist_destroy (&self->groups);
zhash_destroy (&self->headers);
zmsg_destroy (&self->content);
free (self->group);
// Free object itself
free (self);
*self_p = NULL;
}
}
void
zctx_destroy (zctx_t **self_p)
{
assert (self_p);
if (*self_p) {
zctx_t *self = *self_p;
// Destroy all sockets
while (zlist_size (self->sockets))
zctx__socket_destroy (self, zlist_first (self->sockets));
zlist_destroy (&self->sockets);
zmutex_destroy (&self->mutex);
// ZMQ context may not yet be instantiated
if (self->context && !self->shadow)
zmq_term (self->context);
free (self);
*self_p = NULL;
}
}
int module_start_all (modhash_t *mh)
{
zlist_t *uuids;
char *uuid;
int rc = -1;
if (!(uuids = zhash_keys (mh->zh_byuuid)))
oom ();
uuid = zlist_first (uuids);
while (uuid) {
module_t *p = zhash_lookup (mh->zh_byuuid, uuid);
assert (p != NULL);
if (module_start (p) < 0)
goto done;
uuid = zlist_next (uuids);
}
rc = 0;
done:
zlist_destroy (&uuids);
return rc;
}
static void
mount_sub_store (mount_t *self, client_t *client, fmq_msg_t *request)
{
// Store subscription along with any previous ones
// Coalesce subscriptions that are on same path
char *path = fmq_msg_path (request);
sub_t *sub = (sub_t *) zlist_first (self->subs);
while (sub) {
if (client == sub->client) {
// If old subscription is superset/same as new, ignore new
if (strncmp (path, sub->path, strlen (sub->path)) == 0)
return;
else
// If new subscription is superset of old one, remove old
if (strncmp (sub->path, path, strlen (path)) == 0) {
zlist_remove (self->subs, sub);
sub_destroy (&sub);
sub = (sub_t *) zlist_first (self->subs);
}
else
sub = (sub_t *) zlist_next (self->subs);
}
else
sub = (sub_t *) zlist_next (self->subs);
}
// New subscription for this client, append to our list
sub = sub_new (client, path, fmq_msg_cache (request));
zlist_append (self->subs, sub);
// If client requested resync, send full mount contents now
if (fmq_msg_options_number (client->request, "RESYNC", 0) == 1) {
zlist_t *patches = fmq_dir_resync (self->dir, self->alias);
while (zlist_size (patches)) {
fmq_patch_t *patch = (fmq_patch_t *) zlist_pop (patches);
sub_patch_add (sub, patch);
fmq_patch_destroy (&patch);
}
zlist_destroy (&patches);
}
}
zctx_t *
zctx_new (void)
{
zctx_t *self = (zctx_t *) zmalloc (sizeof (zctx_t));
if (!self)
return NULL;
self->sockets = zlist_new ();
self->mutex = zmutex_new ();
if (!self->sockets || !self->mutex) {
zlist_destroy (&self->sockets);
zmutex_destroy (&self->mutex);
free (self);
return NULL;
}
self->iothreads = 1;
self->pipehwm = 1000;
self->sndhwm = 1000;
self->rcvhwm = 1000;
zsys_catch_interrupts ();
return self;
}
static void
client_destroy (client_t **self_p)
{
assert (self_p);
if (*self_p) {
client_t *self = *self_p;
fmq_config_destroy (&self->config);
int server_nbr;
for (server_nbr = 0; server_nbr < self->nbr_servers; server_nbr++) {
server_t *server = self->servers [server_nbr];
server_destroy (&server);
}
// Destroy subscriptions
while (zlist_size (self->subs)) {
sub_t *sub = (sub_t *) zlist_pop (self->subs);
sub_destroy (&sub);
}
zlist_destroy (&self->subs);
free (self);
*self_p = NULL;
}
}
module_t *module_lookup_byname (modhash_t *mh, const char *name)
{
zlist_t *uuids;
char *uuid;
module_t *result = NULL;
if (!(uuids = zhash_keys (mh->zh_byuuid)))
oom ();
uuid = zlist_first (uuids);
while (uuid) {
module_t *p = zhash_lookup (mh->zh_byuuid, uuid);
assert (p != NULL);
if (!strcmp (module_get_name (p), name)) {
result = p;
break;
}
uuid = zlist_next (uuids);
p = NULL;
}
zlist_destroy (&uuids);
return result;
}
int cache_expire_entries (struct cache *cache, int current_epoch, int thresh)
{
zlist_t *keys;
char *ref;
struct cache_entry *hp;
int count = 0;
if (!(keys = zhash_keys (cache->zh)))
oom ();
while ((ref = zlist_pop (keys))) {
if ((hp = zhash_lookup (cache->zh, ref))
&& !cache_entry_get_dirty (hp)
&& cache_entry_get_valid (hp)
&& (thresh == 0 || cache_entry_age (hp, current_epoch) > thresh)) {
zhash_delete (cache->zh, ref);
count++;
}
free (ref);
}
zlist_destroy (&keys);
return count;
}
void lsmod_map_hash (zhash_t *mods, flux_lsmod_f cb, void *arg)
{
zlist_t *keys = NULL;
const char *key;
mod_t *m;
int errnum = 0;
if (!(keys = zhash_keys (mods)))
oom ();
key = zlist_first (keys);
while (key != NULL) {
if ((m = zhash_lookup (mods, key))) {
if (cb (m->name, m->size, m->digest, m->idle,
nodeset_str (m->nodeset), arg) < 0) {
if (errno > errnum)
errnum = errno;
}
}
key = zlist_next (keys);
}
zlist_destroy (&keys);
}
zlist_t *
zdir_resync (zdir_t *self, const char *alias)
{
zlist_t *patches = zlist_new ();
if (!patches)
return NULL;
zfile_t **files = zdir_flatten (self);
uint index;
for (index = 0;; index++) {
zfile_t *file = files [index];
if (!file)
break;
if (zlist_append (patches, zdir_patch_new (
self->path, file, patch_create, alias))) {
zlist_destroy (&patches);
break;
}
}
freen (files);
return patches;
}
void
zproto_example_destroy (zproto_example_t **self_p)
{
assert (self_p);
if (*self_p) {
zproto_example_t *self = *self_p;
// Free class properties
zframe_destroy (&self->routing_id);
free (self->data);
if (self->aliases)
zlist_destroy (&self->aliases);
zhash_destroy (&self->headers);
zchunk_destroy (&self->public_key);
zuuid_destroy (&self->identifier);
zframe_destroy (&self->address);
zmsg_destroy (&self->content);
// Free object itself
free (self);
*self_p = NULL;
}
}
static void emit_command_help_from_pattern (const char *pattern, FILE *fp)
{
zhash_t *zh = NULL;
zlist_t *keys = NULL;
const char *cat;
zh = get_command_list_hash (pattern);
if (zh == NULL)
return;
keys = zhash_keys (zh);
zlist_sort (keys, (zlist_compare_fn *) category_cmp);
cat = zlist_first (keys);
while (cat) {
emit_command_list_category (zh, cat, fp);
if ((cat = zlist_next (keys)))
fprintf (fp, "\n");
}
zlist_destroy (&keys);
zhash_destroy (&zh);
return;
}
END_TEST
// --------------------------------------------------------------------------
/// Try to _pop () a zlist_t *
START_TEST(test_msg_pop_l)
{
sam_selftest_introduce ("test_msg_pop_h");
zmsg_t *zmsg = zmsg_new ();
if (zmsg_pushstr (zmsg, "value2") ||
zmsg_pushstr (zmsg, "value1") ||
zmsg_pushstr (zmsg, "2")) {
ck_abort_msg ("could not build zmsg");
}
sam_msg_t *msg = sam_msg_new (&zmsg);
ck_assert_int_eq (sam_msg_size (msg), 3);
zlist_t *list;
int rc = sam_msg_pop (msg, "l", &list);
ck_assert_int_eq (rc, 0);
ck_assert_int_eq (sam_msg_size (msg), 0);
ck_assert_int_eq (zlist_size (list), 2);
ck_assert_str_eq (zlist_first (list), "value1");
ck_assert_str_eq (zlist_next (list), "value2");
ck_assert (zlist_next (list) == NULL);
zlist_destroy (&list);
sam_msg_destroy (&msg);
}
zlist_t *
zhash_keys (zhash_t *self)
{
assert (self);
zlist_t *keys = zlist_new ();
if (!keys)
return NULL;
zlist_set_destructor (keys, self->key_destructor);
zlist_set_duplicator (keys, self->key_duplicator);
uint index;
size_t limit = primes [self->prime_index];
for (index = 0; index < limit; index++) {
item_t *item = self->items [index];
while (item) {
if (zlist_append (keys, (void *) item->key)) {
zlist_destroy (&keys);
break;
}
item = item->next;
}
}
return keys;
}
void flux_msg_handler_destroy (flux_msg_handler_t *w)
{
if (w) {
assert (w->magic == HANDLER_MAGIC);
flux_msg_handler_stop (w);
if (w->match.topic_glob)
free (w->match.topic_glob);
if (w->coproc)
coproc_destroy (w->coproc);
if (w->backlog) {
flux_msg_t *msg;
while ((msg = zlist_pop (w->backlog)))
flux_msg_destroy (msg);
zlist_destroy (&w->backlog);
}
if (w->wait_match.topic_glob)
free (w->wait_match.topic_glob);
if (w->arg_free)
w->arg_free (w->arg);
w->magic = ~HANDLER_MAGIC;
dispatch_usecount_decr (w->d);
free (w);
}
}
static void
zyre_node_destroy (zyre_node_t **self_p)
{
assert (self_p);
if (*self_p) {
zyre_node_t *self = *self_p;
zpoller_destroy (&self->poller);
zuuid_destroy (&self->uuid);
zhash_destroy (&self->peers);
zhash_destroy (&self->peer_groups);
zlist_destroy (&self->own_groups);
zhash_destroy (&self->headers);
zsock_destroy (&self->inbox);
zsock_destroy (&self->outbox);
zactor_destroy (&self->beacon);
zactor_destroy (&self->gossip);
zstr_free (&self->endpoint);
zstr_free (&self->gossip_bind);
zstr_free (&self->gossip_connect);
free (self->name);
free (self);
*self_p = NULL;
}
}
int main (int argc, char *argv [])
{
// First argument is this broker's name
// Other arguments are our peers' names
//
if (argc < 2) {
printf ("syntax: peering3 me {you}...\n");
exit (EXIT_FAILURE);
}
self = argv [1];
printf ("I: preparing broker at %s...\n", self);
srandom ((unsigned) time (NULL));
// Prepare our context and sockets
zctx_t *ctx = zctx_new ();
char endpoint [256];
// Bind cloud frontend to endpoint
void *cloudfe = zsocket_new (ctx, ZMQ_ROUTER);
zsockopt_set_identity (cloudfe, self);
zsocket_bind (cloudfe, "ipc://%s-cloud.ipc", self);
// Bind state backend / publisher to endpoint
void *statebe = zsocket_new (ctx, ZMQ_PUB);
zsocket_bind (statebe, "ipc://%s-state.ipc", self);
// Connect cloud backend to all peers
void *cloudbe = zsocket_new (ctx, ZMQ_ROUTER);
zsockopt_set_identity (cloudbe, self);
int argn;
for (argn = 2; argn < argc; argn++) {
char *peer = argv [argn];
printf ("I: connecting to cloud frontend at '%s'\n", peer);
zsocket_connect (cloudbe, "ipc://%s-cloud.ipc", peer);
}
// Connect statefe to all peers
void *statefe = zsocket_new (ctx, ZMQ_SUB);
for (argn = 2; argn < argc; argn++) {
char *peer = argv [argn];
printf ("I: connecting to state backend at '%s'\n", peer);
zsocket_connect (statefe, "ipc://%s-state.ipc", peer);
}
// Prepare local frontend and backend
void *localfe = zsocket_new (ctx, ZMQ_ROUTER);
zsocket_bind (localfe, "ipc://%s-localfe.ipc", self);
void *localbe = zsocket_new (ctx, ZMQ_ROUTER);
zsocket_bind (localbe, "ipc://%s-localbe.ipc", self);
// Prepare monitor socket
void *monitor = zsocket_new (ctx, ZMQ_PULL);
zsocket_bind (monitor, "ipc://%s-monitor.ipc", self);
// Start local workers
int worker_nbr;
for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++)
zthread_new (ctx, worker_task, NULL);
// Start local clients
int client_nbr;
for (client_nbr = 0; client_nbr < NBR_CLIENTS; client_nbr++)
zthread_new (ctx, client_task, NULL);
// Interesting part
// -------------------------------------------------------------
// Publish-subscribe flow
// - Poll statefe and process capacity updates
// - Each time capacity changes, broadcast new value
// Request-reply flow
// - Poll primary and process local/cloud replies
// - While worker available, route localfe to local or cloud
// Queue of available workers
int local_capacity = 0;
int cloud_capacity = 0;
zlist_t *workers = zlist_new ();
while (1) {
zmq_pollitem_t primary [] = {
{ localbe, 0, ZMQ_POLLIN, 0 },
{ cloudbe, 0, ZMQ_POLLIN, 0 },
{ statefe, 0, ZMQ_POLLIN, 0 },
{ monitor, 0, ZMQ_POLLIN, 0 }
};
// If we have no workers anyhow, wait indefinitely
int rc = zmq_poll (primary, 4,
local_capacity? 1000 * ZMQ_POLL_MSEC: -1);
if (rc == -1)
break; // Interrupted
// Track if capacity changes during this iteration
int previous = local_capacity;
// Handle reply from local worker
zmsg_t *msg = NULL;
if (primary [0].revents & ZMQ_POLLIN) {
msg = zmsg_recv (localbe);
if (!msg)
break; // Interrupted
zframe_t *address = zmsg_unwrap (msg);
zlist_append (workers, address);
local_capacity++;
// If it's READY, don't route the message any further
zframe_t *frame = zmsg_first (msg);
if (memcmp (zframe_data (frame), LRU_READY, 1) == 0)
zmsg_destroy (&msg);
}
// Or handle reply from peer broker
else if (primary [1].revents & ZMQ_POLLIN) {
msg = zmsg_recv (cloudbe);
if (!msg)
break; // Interrupted
// We don't use peer broker address for anything
zframe_t *address = zmsg_unwrap (msg);
zframe_destroy (&address);
}
// Route reply to cloud if it's addressed to a broker
for (argn = 2; msg && argn < argc; argn++) {
char *data = (char *) zframe_data (zmsg_first (msg));
size_t size = zframe_size (zmsg_first (msg));
if (size == strlen (argv [argn])
&& memcmp (data, argv [argn], size) == 0)
zmsg_send (&msg, cloudfe);
}
// Route reply to client if we still need to
if (msg)
zmsg_send (&msg, localfe);
// Handle capacity updates
if (primary [2].revents & ZMQ_POLLIN) {
char *status = zstr_recv (statefe);
cloud_capacity = atoi (status);
free (status);
}
// Handle monitor message
if (primary [3].revents & ZMQ_POLLIN) {
char *status = zstr_recv (monitor);
printf ("%s\n", status);
free (status);
}
// Now route as many clients requests as we can handle
// - If we have local capacity we poll both localfe and cloudfe
// - If we have cloud capacity only, we poll just localfe
// - Route any request locally if we can, else to cloud
//
while (local_capacity + cloud_capacity) {
zmq_pollitem_t secondary [] = {
{ localfe, 0, ZMQ_POLLIN, 0 },
{ cloudfe, 0, ZMQ_POLLIN, 0 }
};
if (local_capacity)
rc = zmq_poll (secondary, 2, 0);
else
rc = zmq_poll (secondary, 1, 0);
assert (rc >= 0);
if (secondary [0].revents & ZMQ_POLLIN)
msg = zmsg_recv (localfe);
else if (secondary [1].revents & ZMQ_POLLIN)
msg = zmsg_recv (cloudfe);
else
break; // No work, go back to primary
if (local_capacity) {
zframe_t *frame = (zframe_t *) zlist_pop (workers);
zmsg_wrap (msg, frame);
zmsg_send (&msg, localbe);
local_capacity--;
}
else {
// Route to random broker peer
int random_peer = randof (argc - 2) + 2;
zmsg_pushmem (msg, argv [random_peer], strlen (argv [random_peer]));
zmsg_send (&msg, cloudbe);
}
}
if (local_capacity != previous) {
// We stick our own address onto the envelope
zstr_sendm (statebe, self);
// Broadcast new capacity
zstr_sendf (statebe, "%d", local_capacity);
}
}
// When we're done, clean up properly
while (zlist_size (workers)) {
zframe_t *frame = (zframe_t *) zlist_pop (workers);
zframe_destroy (&frame);
}
zlist_destroy (&workers);
zctx_destroy (&ctx);
return EXIT_SUCCESS;
}
void
do_zone(dbref player, dbref cause, int key, char *tname, char *pname)
{
dbref thing, zonemaster;
switch( key ) {
case ZONE_ADD: /* or default */
if( *tname && !*pname ) {
init_match(player, tname, NOTYPE);
match_everything(0);
thing = noisy_match_result();
if( thing == NOTHING )
return;
if( !Examinable(player, thing) ) {
notify_quiet(player, "You can't do that.");
return;
}
viewzonelist(player, thing);
return;
}
if( !*tname || !*pname ) {
notify_quiet(player, "This switch expects two arguments.");
return;
}
init_match(player, tname, NOTYPE);
match_everything(0);
thing = noisy_match_result();
if( thing == NOTHING )
return;
/* Make sure we can do it */
if ( (NoMod(thing) && !WizMod(player)) ||
(Backstage(player) && NoBackstage(thing)) ) {
notify_quiet(player, "Permission denied.");
return;
}
if (!Controls(player, thing)) {
notify_quiet(player, "Permission denied.");
return;
}
if( ZoneMaster(thing) ) {
notify_quiet(player, "You can't zone a Zone Master.");
return;
}
/* Find out what the new zone is */
init_match(player, pname, NOTYPE);
match_everything(0);
zonemaster = noisy_match_result();
if (zonemaster == NOTHING)
return;
if( !ZoneMaster(zonemaster) ) {
notify_quiet(player, "That's not a Zone Master.");
return;
}
if(!Controls(player, zonemaster) &&
!could_doit(player, zonemaster, A_LZONETO, 0, 0) &&
!could_doit(player, zonemaster, A_LZONEWIZ, 0, 0)) {
notify_quiet(player, "Permission denied.");
return;
}
if( zlist_inlist(thing, zonemaster) ) {
notify_quiet(player, "Object is already in that zone.");
return;
}
zlist_add(thing, zonemaster);
zlist_add(zonemaster, thing);
notify_quiet(player, "Zone Master added to object.");
break;
case ZONE_DELETE:
if( !*tname || !*pname ) {
notify_quiet(player, "This switch expects two arguments.");
return;
}
/* Find out what the zone is */
init_match(player, pname, NOTYPE);
match_everything(0);
zonemaster = noisy_match_result();
if (zonemaster == NOTHING)
return;
init_match(player, tname, NOTYPE);
match_everything(0);
thing = noisy_match_result();
if( thing == NOTHING )
return;
if(!zlist_inlist(thing, zonemaster)) {
notify_quiet(player, "That is not one of this object's Zone Masters.");
return;
}
/* only need to control zmo or be zonewiz to delete
or control object */
if(!Controls(player, thing) &&
!Controls(player, zonemaster) &&
!could_doit(player, zonemaster, A_LZONEWIZ, 0, 0)
) {
notify_quiet(player, "Permission denied.");
return;
}
if ( (NoMod(thing) && !WizMod(player)) ||
(Backstage(player) && NoBackstage(thing)) ) {
notify_quiet(player, "Permission denied.");
return;
}
zlist_del(thing, zonemaster);
zlist_del(zonemaster, thing);
notify_quiet(player, "Deleted.");
break;
case ZONE_PURGE:
if( !*tname || *pname) {
notify_quiet(player, "This switch expects one argument.");
return;
}
/* Find out what the zone is */
init_match(player, tname, NOTYPE);
match_everything(0);
thing = noisy_match_result();
if (thing == NOTHING)
return;
if( ZoneMaster(thing) ) {
if(!Controls(player, thing) &&
!could_doit(player, thing, A_LZONEWIZ, 0, 0)) {
notify_quiet(player, "Permission denied.");
return;
}
if ( (NoMod(thing) && !WizMod(player)) ||
(Backstage(player) && NoBackstage(thing)) ) {
notify_quiet(player, "Permission denied.");
return;
}
zlist_destroy(thing);
notify_quiet(player, "All objects removed from zone.");
}
else {
if(!Controls(player, thing)) {
notify_quiet(player, "Permission denied.");
return;
}
if ( (NoMod(thing) && !WizMod(player)) ||
(Backstage(player) && NoBackstage(thing)) ) {
notify_quiet(player, "Permission denied.");
return;
}
zlist_destroy(thing);
notify_quiet(player, "Object removed from all zones.");
}
break;
default:
notify_quiet(player, "Unknown switch!");
break;
}
return;
}
