// vim:foldmethod=marker:syntax=lpc:noexpandtab
// $Id: archetype.gen,v 1.85 2008/11/29 08:24:10 lynx Exp $
//
// the meta-generator that contains all sorts of PSYC room code and with
// a few defines and an include generates cloneable room implementations.
// inheritance was not the answer for plugging together the best of room
// behaviours. not even multiple inheritance.

// psyced rooms store members by object:nick or UNI:nick, nick just being
// an optimization. but don't we really want to have UNI:object or UNI:UNL ...?
// should we use an array as value for the member mapping? this kind of
// discussion belongs into CHANGESTODO anyway, so go read there.

// the "default" configuration for dynamically instantiated places
#ifdef DEFAULT
// here is an alphabetic list of selectors available for archetype includers.
// some of them commented out when not useful for the default case.
// some simply unfinished/unusable as yet. this file is also used by
// archetype.pl to find out which selectors exist. it uses the letters
// in square brackets for its model filenames. the + was meant to indicate
// things that every model should define, but that's in ESSENTIALS now.
//
//# define PLACE_FILTERS		// [+] provide /silence for public rooms
# define PLACE_HISTORY			// [h] provide history functionality
# define PLACE_HISTORY_SWITCH		// TODO: history off by default
//# define PLACE_HISTORY_EXPORT		// [e] export history to websites
# define PLACE_SCRATCHPAD		// [s] provide a scratchpad via web
//# define PLACE_LOGGING		//     provide /logging for public rooms
# define PLACE_MASQUERADE		// [m] provide a local /nick command
//# define PLACE_MASQUERADE_COMMAND	//     provide a /masq admin command
//# define PLACE_MASQUERADE_SECRET	-- see FIXME first
//# define PLACE_MAY_HISTORY		// provide a MAY_HISTORY hook
//# define PLACE_NEWSFEED		-- be a newsfeed.. TODO
//# define PLACE_OWNED			// [o] owners and aides logic
# define PLACE_PUBLIC_COMMAND		//     provide a /public admin command
# define PLACE_STORE_COMMAND		// [+] provide a /store command
# define PLACE_STYLE_COMMAND		// [+] owners can define /style sheet
# define PLACE_TOPIC			// [+] provide a topic function
# define PLACE_TOPIC_COMMAND		// [+] provide a /topic command
//# define PLACE_TOPIC_FOR_ALL		//     allow anybody to set the topic
//# define PLACE_UNKNOWN_HOOK		//     provide a handler for ON_UNKNOWN
#endif

// things that every archetype auto-model gets.
// the rest is #define'able via place.gen
#ifdef ESSENTIALS
# define PLACE_FILTERS			// [+] provide /silence for public rooms
# define PLACE_STORE_COMMAND		// [+] provide a /store command
# define PLACE_STYLE_COMMAND		// [+] owners can define /style sheet
# define PLACE_TOPIC			// [+] provide a topic function
# define PLACE_TOPIC_COMMAND		// [+] provide a /topic command
#endif

// the former "basic" place that older place code still inherits
#ifdef BASIC
// this recreates the functionality of the former net/place/basic
// which is still being inherited by some special applications
# define PLACE_TOPIC			// provide a topic function
# define PLACE_TOPIC_COMMAND		// provide a /topic command
#endif

// some words about signatures, hooks, method overloading and macros
// are waiting for you to read at..
// http://about.psyc.eu/Create_place#Message_flow_in_psyced_places
// and a MAY_HISTORY hook is just hanging around in this file waiting
// for you to be seen as an example on how to extract code into its
// own hook. pretty simple really. in fact, before writing these
// words and making this my official plan I considered several other
// architectural plans on how to make efficient extensible places.
// first the one which is in place now. the following paragraphs discuss
// that and are essentially deadly boring and mostly a note to myself.
// so stop reading this. anyway, here goes:
//
// the design that i took uses a single table of known signatures for the
// entire system, since signatures are meant to be constant information
// at all times. yeah it could even be implemented in some preprocessor
// form so that signature unpacking actually happens in the code. but for
// now it's in the call_signature() library function.
//
// behaviour extensions are solved by the handler mentioned in the signature,
// thus the hook calls and inheritance requirement. the function table lookup
// of a string function name is slightly costy - in exchange we don't have
// baggage closure mappings in the objects. one more advantage is, that after
// several other thoughts i figured out that what looks like chaos at first
// glance (this file really does) is actually close to optimal. hooks only
// where necessary, and more than just before/after if necessary (as in a
// complex operation such as _request_enter), and macros as an abstraction
// layer to provide a consistent interface to the place writer.
//
// and these were the alternatives considered:
//
// 1. have before and after hooks (only?) also in the signatures, which
// however need to be called by function table lookup in each object no
// matter if it actually makes use of them: very inefficient.
//
// 2. have all behaviour filters generated by place.gen, even the default
// ones. like every place with a /topic command would be compiled with yet
// another copy of the same bytecode which tells it who is in charge of
// changing the topic. very memory unfriendly.
//
// 3. another option was to put before/after hooks into big switches around
// the signature call. this means several switch lookups additional to the
// signature lookup and you can't access the unpacked variables in the before
// part unless you split signature unpacking from calling the handler. so
// you even have to put the before and after switches into their own functions
// or it will be impossible to extend them. wah.
//
// 4. each place keeps a data structure which describes its signatures
// together with closures for handlers, before and after hooks (ppp
// style). this is cool for extensibility as you don't need inheritance
// to extend functionality (but why would you want to do that in LPC?),
// but the trade-off is larger memory consumption in large installations
// with large amounts of identical place programs, each of them carrying
// a signature table along even though it was supposed to be constant.
// may be worth it anyhow. yeah it could have been an ok alternative.
// but the advantages just don't make sense in the LPC environment.
// also it is limited to before/after hooks unless you make the structure
// complex enough to carry unlimited hooks (ppp doesn't and tries to cope).

// local debug messages - turn them on by using psyclpc -DDplace=<level>
#ifdef Dplace
# undef DEBUG
# define DEBUG Dplace
#endif

#include <net.h>
#include <person.h>
#include <status.h>
#include <uniform.h>
#include <driver.h>

#ifdef GAMMA
# define ECHOES
#endif

#ifdef PLACE_HISTORY
# include <text.h>		// inherits textc

inherit NET_PATH "lastlog";

# ifndef _limit_amount_history_persistent
#  define _limit_amount_history_persistent 444
# endif

# ifndef _limit_amount_history_export
#  define _limit_amount_history_export 24
# endif

# define DEFAULT_GLIMPSE 3
# define MAX_SIMPLE_HISTCLEAR 100

volatile int _histChange;
#endif // PLACE_HISTORY

// internal (was basic.c)
#define MEMBER(UNIFORM)	member(_u, UNIFORM)
#define DATA_FILE(name) (DATA_PATH "place/" + lower_case(name))

inherit NET_PATH "group/master";

#ifdef PERSISTENT_MASTERS
mapping _u;
#endif

// used by new /reload
members(recover) {
	if (recover) {
		ASSERT("members() recovering", mappingp(recover), recover)
		PT(("%O recovering members %O\n", ME, recover))
		_u = recover;
	}
	return _u;
}

#ifdef PLACE_OWNED
volatile mapping banned;

// sometimes overridden by place.gen
mixed qOwners() { return 0; }
#endif

#ifdef PLACE_SCRATCHPAD
volatile mapping used, given; // used/given scratchpad IDs
#endif

#ifdef PLACE_MASQUERADE
//
// OPTIMIZE: the new !DONT_REWRITE_NICKS code serves the purpose of enabling
// local nicks according to jabber MUC. the code may also be used by NICKS
// that is: instead of having an extra snames mapping we could put local
// nicks into our _u[uniform] value field. but this is just a quick thought
// and may not be viable after all, have to look at this closer ... TODO
//
protected volatile mapping snames;
//
# ifdef PLACE_MASQUERADE_COMMAND
qMasquerade() {
	ASSERT("qMasquerade called", 1==0, 0)
	return 1;
}
# else
qMasquerade() { return v("masquerade"); }
# endif
#endif

#ifdef PLACE_LOGGING
private volatile string _logfile;

qLogging() { return v("logging"); }
#endif

int qSaveImmediately() {
#if defined(SAVE_LOG_IMMEDIATELY) || defined(_flag_save_place_log_immediately)
    return 1;
#else
    return 0;
#endif
}

// to be overloaded by place.gen
qNewsfeed() { return 0; }
// _request_list_feature uses this in *all* place objects, dont ifdef

#ifdef PLACE_HISTORY
mayLog(mc) { return abbrev("_message", mc); }

qHistory() { return v("log"); }

int qHistoryGlimpse() { return DEFAULT_GLIMPSE; }
int qHistoryPersistentLimit() { return _limit_amount_history_persistent; }
int qHistoryExportLimit() { return _limit_amount_history_export; }

histClear(a, b, source, vars) {
	int l = logSize();

	if (a == "") a = 0;
	if (!a && l > MAX_SIMPLE_HISTCLEAR) {
		sendmsg(source, "_warning_usage_histclear",
		     "The history is [_amount_history] entries long. "
		     "Usage: /histclear «amount»",
		    ([ "_amount_history" : l ]));
		return 1;
	}
	logClear(a);
	save();
	sendmsg(source, "_echo_place_history_cleared",
	     "The history has been reduced from [_amount_history_old] "
	     "entries to [_amount_history].",
		    // the "0" is needed for remote delivery by PSYC
		    // i wonder if i should change psyc/parse instead
		    // or if this is the correct way to indicate that
		    // the variable is zero, not removed
		([ "_amount_history" : logSize() || "0",
		   "_amount_history_old" : l || "0",
		   "_amount_removed" : a ]));
	return 1;
}

msgView(source, mc, data, vars, showingLog) {
	string fmt;

# ifdef PLACE_HISTORY_EXPORT
#  if HAS_PORT(HTTP_PORT, HTTP_PATH) || HAS_PORT(HTTPS_PORT, HTTP_PATH)
	// 'ecmascript' output is effectively JSON, but more than that,
	// since it is intended for output as html, it uses html quoting
	// rather than json quoting, and quotes all html characters on
	// top of just quoting javascript's own. also, since we only
	// output strings, we can leave out all the other special cases
	// of make_json(). all in all this function may belong into json.c
	// as a special case - make_htjson().
	//
	if (showingLog == "ecmascript" || showingLog == "html") {
		string s, *t;
//		s = psyctext( T("x"+mc, ""), vars, data, source );
// first we render the message into a default plain text string
		s = psyctext( T(mc, ""), vars, data, source );
		if (strlen(s) < 7) return;
		s = s[..<2];
// htquote doesn't do the job as necessary for javascript
		s = regreplace(s, "\&", "\\\&amp;", 1);
		s = regreplace(s, "<", "\\\&lt;", 1);
		s = regreplace(s, ">", "\\\&gt;", 1);
		s = regreplace(s, "\"", "\\\&quot;", 1);
		s = regreplace(s, "\n|\\\\", " ", 1);
//		unless (sscanf(s, "%s: %s", s, tx) == 2) return;
// then we parse the plain text string to seperate nick from
// action and text. this isn't very elegant really.
		t = regexplode (s, " [a-z_1-9]*: ");
// under funny circumstances it may match more than once
		if (sizeof(t) > 3) t[2] = implode(t[2..], "");
// and when "en_g" is set as default language, the output may not
// have an action at all
		else if (sizeof(t) < 3) {
			t = ({ 0, "", 0 });
			unless(sscanf(s, "%s %s", t[0], t[2])) {
			    P1(("%O could not reparse %O for %s\n", ME, s,
				showingLog))
			    return;
			}
		}
		P3(("%O becomes %O\n", s, t))
//		t = regreplace(s, ": ", "\", \"", 1);
//		if (s == t) return;
		if (showingLog == "html")
//			fmt = "(<i>%s</i>) <b>%s %s</b>: %s<br/>\n";
			fmt = stringp(t[2]) ? "<div class='msg'><span class='ts'>%s</span> <span class='sp'><b>%s</b> %s</span> <span class='tx'>%s</span></div>\n" : "<div class='msg'><span class='ts'>%s</span> <span class='sp'><b>%s</b> %s</span></div>\n";
		else // showingLog == "ecmascript"
			fmt = "\t%O, %O, %O, %O,\n";
		
		if (vars["_action_possessive"])
		    printf(fmt, isotime(vars["_time_place"]
				 || vars["_time_INTERNAL"] || 4404, 0),
			t[0]+"s", vars["_action_possessive"], t[2]
		    );
		else printf(fmt, isotime(vars["_time_place"]
				 || vars["_time_INTERNAL"] || 4404, 0),
			t[0], vars["_action"] || t[1][1..<3], t[2]
		    );
	} else
#  endif
# endif
       	{
# if 0 //def BRAIN
		// this is just because old storage files on fly
		// contain _context's in their history data
		// you can delete this after 2004
		m_delete(vars, "_context");
		// showing history is a unicast operation
		// and may not contain a _context
	// .. then again, isn't _context necessary to calculate
	// the message id? okay we don't have msg ids yet..
# endif
		// and we don't wanna fake the origin of the message either..
# ifdef UNSAFE_LASTLOG
		if (source) {
# endif
			// stow away the original source, then send
			// ME as source, so that clients can figure
			// out in which frame to display this
			vars["_source_relay"] = source;
					// UNIFORM(source) ?
			// storing psyc_name for local object looks neat
			// but actually messes with history display logic.
			// if it's a local object the _nick is enough anyway
# ifdef UNSAFE_LASTLOG
		}
# endif
		source = ME;
# if 1
		// yes history is not multicast, but when retransmitting
		// earlier multicasts you are supposed to provide
		// both _target and _context
	// see http://about.psyc.eu/Routing#Unicast_Message_for_State_Signaling
		// mark this message as a retransmission from this context
		vars["_INTERNAL_context"] = ME; // vars["_context"] = ME;
# endif
# ifdef VARS_IS_SACRED
		// in this case net/irc takes care of protecting vars
		sendmsg(showingLog, mc, data, vars, source, 1);
# else
		// since castmsg is not being used we have to protect
		// our history database by copying the vars mapping
		sendmsg(showingLog, mc, data, copy(vars), source, 1);
# endif
	}
}

# ifdef PLACE_HISTORY_EXPORT
#  ifdef TIME_HISTORY_EXPORT_RELOAD
#   ifndef TIME_HISTORY_EXPORT_RELOAD_PARANOID
#    define TIME_HISTORY_EXPORT_RELOAD_PARANOID 12
#   endif

volatile int lastTime;
volatile string lastIP;
#  endif
# endif
#endif /* PLACE_HISTORY */

#ifdef PLACE_TOPIC
// this reminds you of public.c
qTopic() { return v("topic"); }

#ifdef PLACE_TOPIC_COMMAND
sTopic(text, source, nick) {
	unless (nick) return;
#ifndef PLACE_TOPIC_FOR_ALL
# ifdef PLACE_OWNED
#   define OFFICIAL 0
	if (!qAide(objectp(source) ? nick : source)) {
		sendmsg(source, "_error_unavailable_function_place_topic",
			"This function is not available to you here.");
		return 1;
	}
# else
#  ifdef PLACE_PUBLIC_COMMAND
#   define OFFICIAL 0
	if (qPublic()) if (!boss(source) && stringp(v("topic-user"))
		       && lower_case(nick) != lower_case(v("topic-user"))) {
		sendmsg(source, "_error_unavailable_function_place_topic",
			"This function is not available to you here.");
		return;
	}
#  else
#   define OFFICIAL "_official"
//#   echo It's official!
	unless (boss(source) > 59) return;
#  endif
# endif
#else
# define OFFICIAL 0
#endif
	if (stringp(text) && strlen(text)) {
		vSet("topic", text);
		vSet("topic-user", nick);
		vSet("topic-time", time());
		// TODO: no support for _official.. yet
		castmsg(ME, "_notice_place_topic",
		    "New topic in [_nick_place] by [_nick]: [_topic]",
			([ "_nick" : v("topic-user"),
			  "_topic" : v("topic"),
			  "_nick_place" : MYNICK ]) );
	} else if (v("topic")) {
		// TODO: no support for _official.. again
		castmsg(ME, "_notice_place_topic_removed",
		    "[_nick] removes [_nick_topic]'s topic: [_topic]",
			   ([ "_nick": nick,
			"_nick_topic": v("topic-user"),
			     "_topic": v("topic"),
			     "_nick_place" : MYNICK ]) );
		vDel("topic");
		vDel("topic-user");
	}
	save();
	return v("topic");
}
#endif

showTopic(rcpt, verbose, mc) {
	P4(("showTopic to %O (%O)\n", rcpt, mc))
	if (v("topic")) sendmsg(rcpt, mc
			    ? "_status_place_topic"+ mc
			    : "_status_place_topic",
		"Topic by [_nick]: [_topic]",
		    ([ "_nick" : v("topic-user"),
			    // '123456789' is a dummy for old place data
			    // that has no topic timestamp
		      "_time_place" : v("topic-time") || 123456789,
			    // this one is used by IRC
		      "_INTERNAL_time_topic" : v("topic-time") || 123456789,
		      "_topic" : v("topic"),
		      "_nick_place" : MYNICK,
	  ]) );
	else if (verbose) sendmsg(rcpt, "_status_place_topic_none",
		     "No topic is set in [_nick_place].", ([
		      "_nick_place" : MYNICK,
	  ]) );
	return 1;
}

# ifdef SIGS
_request_set_topic(source, mc, data, vars, b) {
    string value = vars["_value"] || vars["_topic"];
    if (strlen(value)) {
	if (value == "-") value = 0;
	sTopic(value, source, vars["_nick"]);
    } else {
	showTopic(source, 1, OFFICIAL);
    }
    return 1;
}
# endif
#endif

#if HAS_PORT(HTTP_PORT, HTTP_PATH) || HAS_PORT(HTTPS_PORT, HTTP_PATH)
htget(prot, query, headers, qs, data, noprocess) {
    //P3((">> archetype.gen:htget(%O, %O, %O, %O, %O, %O)\n", prot, query, headers, qs, data, noprocess))
# ifdef PLACE_SCRATCHPAD
	// we *could* allow each place to define its own textdb.. but why?
        sTextPath(query["layout"] /* || MYNICK */, query["lang"], "html");
	if (!noprocess && (!qs || query["scratchpad"])) {
		string rand, buf, len;
// microscopic wiki functionality .. cheap imitation of tobi's save.pike
//
// things one could add:
// 1. advertise URL in /st and change notice
// 2. call it v("notepad") and volatile scratchpad
//    so that we can choose if something is persistent or not
// 3. authentication / compare ip with locations of people in room or schergen
// 4. implement locking !? or history !???
// 5. have multiple scratchpads per key in a mapping. like:
// 	/place/group?scratchpad&key=goodmood
// 6. autogenerate numeric keys 1,2,3..
// 7. have a garbage collection for old scratchpads?
//
		htok(prot);
		//unless (v("key")) vSet("key", ([])); <- next evolutionary step
		// if someone pushes send button after 24h, he might block
		// someone elses id in the rare case that RANDHEXSTRING
		// reprovided the specific id to someone else who didn't send
		// his changes first.. well. might not happen.
		// TODO: prefix id with epoch?
		if (stringp(query["scratchpad"])
			&& (len = strlen(query["scratchpad"])) > 1
//
// id logic serves the purpose of not changing the scratchpad while going
// "back" in the browser history. only a new "post" should change it.
// it could have been an incremental counter, but then you would have to
// recopy the contents of your scratchpad if someone else posted in the
// meantime. it's a question of taste. probably simpler and better.
//
			&& (!stringp(query["id"])
			    || !member(used, query["id"]))) {
#ifdef __LDMUD__
		    // problem apparently caused by ldmud input charset logic
		    buf = replace(query["scratchpad"], "\r", "");
#else
		    buf = query["scratchpad"];
#endif
		    if (buf != v("scratchpad")) {
			vSet("scratchpad", buf);
			m_add(used, query["id"]);
// some people bookmark the page after saving, thus they resubmit the used
// id days later.. don't know what to do about that, but this is not helpful:
//			call_out(#'m_delete, 86400 /* 24 hours */,
//				 used, query["id"]);

			castmsg(ME, "_notice_update_scratchpad", 0, ([
				"_size_scratchpad": len,
#ifdef PRO_PATH // __TLS__
				"_page_scratchpad":
				  ((tls_available() && HTTPS_URL) || HTTP_URL)
#else
			    // problem with POST over https apparently..
				"_page_scratchpad": (HTTP_URL)
#endif
					  // TODO: use psycName() here instead
						 +"/@"+ MYNICK +"?scratchpad"
			]));
		    }
		}

		while (member(given, rand = time() + "z" + RANDHEXSTRING));
		m_add(given, rand);
		// notTODO: time() monotonically increases, so .. holding the
		// entries for four seconds only might not be sufficient if
		// time changes to past.
		// anyway, collisions (and timechanges to past) are quite
		// unlikely, especially contemporaneous, so we don't need to
		// hurry with this.
		call_out(#'m_delete, 4, given, rand);
		// the whole idea of rands returning the same value while
		// two people request this page within the same two seconds
		// is a bit paranoid really. this function would probably
		// work fine without a "given" mapping. well saga is a
		// perfectionist and we usually love him for that  ;)
		//
		// FIXME would be more useful to never delete given tokens so we
		// can figure out when a request is coming in with a token
		// that has never been given out (older than last restart,
		// bookmarked months ago etc). given & used could be
		// optimized to be the same mapping with state machine values.

		w("_PAGES_group_scratchpad", 0,
			([ "_scratchpad" : htquote(v("scratchpad") || ""),
			   "_id"	 : rand,
			   //"_group_nick" : MYNICK, -- why?
			   "_nick_place" : MYNICK ]) );
		//noprocess = 2;
		return 1;
	}
# endif
# ifdef PLACE_HISTORY_EXPORT
	int a;

	PT(("%O inspection %O %O\n", ME, query, headers))
#  ifdef TIME_HISTORY_EXPORT_RELOAD
	a = time() - lastTime;
	if (a < TIME_HISTORY_EXPORT_RELOAD_PARANOID) return 1;
	if (a < TIME_HISTORY_EXPORT_RELOAD && lastIP == query_ip_number())
	    return 1;
	lastTime = time();
	lastIP = query_ip_number();
#  endif
	// limit this to "?format=js", as planned before
	unless (noprocess) {
	    if (query["amount"]) {
		sscanf(query["amount"], "%d", a);
		a = a < qHistoryExportLimit() ? a : qHistoryExportLimit();
		P4(("%O amount is %O\n", ME, a))
	    }
	    switch(query["format"]) {
	    case "js":
		sTextPath(0, query["lang"], "html");
		htok3(prot, "application/x-javascript",
		     "Cache-Control: no-cache\n");
		write("\ndocument."+ (query["name"] || MYLOWERNICK)
		    + " = new Array(\n");
		logView(a, "ecmascript", 15);
		write("  \""+ implode(names(), ", ")+"\""
#if defined(ALPHA) && defined(PLACE_TOPIC)
			// this adds current topic to data structure
			// but probably breaks all psyclog.js code
			",\n\t\""+ v("topic") +"\""
#endif
		      ")\n\n");
		break;
#if 0
	    case "json":
		sTextPath(0, query["lang"], "html");
		htok3(prot, "application/x-javascript", // probably incorrect
		     "Cache-Control: no-cache\n");
		logView(a, "json", 15);
		// this calls msgView which should probably create a buffer
		// data structure that can be output with make_json.. 
		break;
#endif
	    default:
		sTextPath(query["layout"], query["lang"], "html");
		htok(prot);
		// we could output a css something here..
		// w("_HTML_head");
		write("\n\n<table>");
		logView(a, "html", 15);
		write("</table>");
		// write("</table>\n\n");
		// w("_HTML_tail");
		break;
	    }
	}
#  ifndef _flag_disable_notice_place_examine_web
	if (query["from"] == "") query["from"] = 0;
	if (query["location"] == "") query["location"] = 0;

	// should be renamed into _notice_examine_web_place
	castmsg(ME, "_notice_place_examine_web", "[_nick_place] inspected on [_web_on] coming from [_web_from].",
	([	"_web_referrer" : query["from"] || "bookmark",
		"_web_page" : query["location"] || headers["referer"] || "",
		"_web_browser" : headers["user-agent"] || "",
		"_web_on" : query["location"] || headers["referer"] ||
			    headers["user-agent"] || "",
		"_web_from" : query["from"] ||
			//    query_ip_name(this_interactive()) ||
			    headers["user-agent"] || "http",
		"_host_name" : query_ip_name(this_interactive()) || "",
		"_nick_place" : MYNICK || "This place",
	    ]) );
#  endif

	// this is usually not very interesting really.. like:
	//   refer= http://euroclash.com jsloc= http://euroclash.com/
	//
	D1( if (query["location"] && headers["referer"] &&
		headers["referer"] != query["location"])
	    D(S("Interesting: refer= %s jsloc= %s\n",
		    headers["referer"], query["location"]));
	)
# else
#  ifdef T
	//sTextPath(query["layout"], query["lang"], "html");
	unless (noprocess) {
	    htok(prot);
	    w("_HTML_head");
	}
	w("_PAGES_place_default",
	    "You are looking at the [_nick_place] default page.\n",
		([ "_nick_place" : MYNICK ]) );
	unless (noprocess) w("_HTML_tail");
#  else
	write("\n\nYou are looking at the "+MYNICK+" default page.\n");
#  endif
# endif
	//printf("%O: %O (%O) in %O\n", this_interactive(), query, qs, headers);
	return 1;
}
#endif

mixed isValidRelay(mixed x) { return x == ME; }

// not in use anywhere
isMember(source, origin) { return MEMBER(source); }

#ifndef QUIET_REMOTE_MEMBERS
castPresence(source, mc, data, vars, filterpresence) {
	P3(("castpresence vars %O to %O\n", vars, source))
	unless(filterpresence) castmsg(source, mc, data, vars);
	// vars["_source"] is the link we are on
	// we have to implement that in slave so it will forward the
	// _notice_place_enter to _source_relay
	// <lynX> hmmm.. should this be changed to _INTERNAL_origin? TODO
	sendmsg(vars["_source"], mc, data, 
		vars + ([ "_source_relay" : source ]));
}
// #else
// # echo QUIET_REMOTE_MEMBERS is activated.
#endif

// actually insert the new member into our data structures
// (happens after all checks have passed)
insert_member(source, mc, data, vars, ni, neu, again) {
	unless (ni) {
		P0(("insert_member w/out nick for %O in %O.\n", source, ME))
		// try to make the ugly three trailing parameters optional
		ni = vars["_nick"];
		neu = !MEMBER(source); // don't output the status again
		again = 0;
	}
#ifdef PLACE_MASQUERADE
	if (vars["_nick_local"]) snames[source] = vars["_nick_local"];
#endif
	//mc = "_notice_place_enter";
	// should this be _source_nick and _context_nick instead?
//		unless (objectp(source))
//		    data = "[_nick] enters [_nick_place].";
	data = "[_nick] enters [_nick_place].";		// TODO
	vars["_nick_place"] = MYNICK;

	P4(("%O: %O is %O (%O)\n", ME, source, neu, v("_filter_presence")))
	// We ALWAYS do castmsg() before adding the user to 
	// our members, otherwise the logic on recipient side 
	// is much higher
	if (neu) {
		// TODO: wir wollen eigentlich nicht, dass alle
		// 	vars da durchgehen... _amount_history
		// 	z.b. auch nicht
		unless (v("_filter_presence")) {
#ifdef PERSISTENT_SLAVES
		    revision += 1;
#endif
		    castmsg(source, mc, data, copy(vars));
		}
		// we used to call insert_member() even for people who are
		// already in.. i guess it was a bug!!
		::insert_member(source, vars["_INTERNAL_origin"]);
	}
	// this was before insert_member(), but shouldn't make a difference
	//
	// makeMembers() used to be at this point, but I changed that
	// to simplify the user.c logic
#ifdef DONT_REWRITE_NICKS
	_u[ source ] = ni;
#else
	// not sure if this can be a security problem. should it
	// be so, we need to use an _INTERNAL_nick_local instead.
	// then again, if any jabberer can propose his nick here,
	// we might aswell allow it for anybody..
	_u[ source ] = vars["_nick_local"] || ni;
#endif
#ifdef ENTER_MEMBERS
	// this used to be before adding the new member. if there's a
	// reason to put it back there, then we need to teach user.c
	// to add itself to _list_members before calling the w()'s
	unless(again) vars += makeMembers()[1];
#endif
	// experimental: let the clients know this is a non-speaking room.
	// see also conferencing.pml for a more elaborate scheme for
	// conference control. this is just something nice to start with.
	if (v("_filter_conversation")) vars["_control"] = "_silent";
	// stylesheet support
	if (v("_uniform_style"))
	    vars["_uniform_style"] = v("_uniform_style");
	// we set it on all requests instead
//		if (v("topic")) vars["_topic"] = v("topic");
#ifdef PLACE_OWNED
	int nuowna = 0;

	// NEW: if OWNERS have not been provided by place.gen
	// we'll make the first guy who walks in our owner.
	unless (v("owners")) {
	    vSet("owners", ([ lower_case(SNICKER): source ]));
		// don't send _warning_place_duty_owner
		// before acquitting enter operation..
		vars["_duty"] = "owner"; // _owner_new ?
		nuowna = 1;
	} else {
		int level = qAide(SNICKER);

		if (level) vars["_duty"] =
		    level > 2 ? "owner" : "administrator";
		else vars["_duty"] = "member";
	}
#else
# if 0 //def MODERATED 
// this code is ignored, since MODERATED is never defined here
// <fip> schoen waers wenn das hier auch funktionieren wuerd
// [x] inheritance aware preprocessor now  <- illogical wish ;)
// what you want here is to turn off inheritance and use code
// generation by include. that's what we do in place.gen, but
// to avoid code explosion we use inheritance here. simply put
// this code into place.gen and it works as you intend it. ok, not
// *that* simple - you have to put it into the appropriate hook.
// which in this case is enter() probably. TODO
	vars["_duty"] = "none"; 
	// role of "moderator" upon entering?
# else
	// only this code runs
	vars["_duty"] = "member";
	// why not _role instead of _duty?
# endif
#endif // OWNED
	// we are also echoing his vars back to the requestor
	// that should normally be harmless and even useful
	// yes.. in fact we handle _nick_local like that
	P4(("sending _echo for %O with vars %O to %O\n",
	    mc, vars, source))
	// is it okay to remap mc here, or should i use a temp var?
	// semantically it looks ok
	mc = "_echo" + mc[7..];
	//if (v("_filter_conversation")) mc += "_filtered";
	m_delete(vars, "_group"); // why are we merging vars from a _do anyway?
	sendmsg(source, mc, data, vars);
	// ensure that a client knows this room has been entered
	// before any room details like topic etc. are sent
	//
	// this used to have an unless(quiet), but why not show
	// the status in public rooms with _filter_presence on?
	// but what we still can't do is output this twice for
	// repeating joins, in particular because jabber cannot
	// distinguish a new join from just a change in presence
	// (going away or returning from idle looks just like a join)
	// so we now make sure the user is already in. should we
	// need further distinction, then we will have to append
	// a _jabber to the mc just to take care of this jabberish
	// shortcoming.
	//
	// wait.. THIS is the new 'quiet'
	// newsfeeds and other non-talking rooms do not need to be
	// visible as channels in any user interface
	if (neu &&! v("_filter_conversation"))
	    onEnter(source, mc, data, vars);
#ifdef PLACE_OWNED
	if (nuowna)
	    sendmsg(source, "_warning_place_duty_owner",
		"You are the new owner of [_nick_place].",
		    ([ "_nick_place" : MYNICK ]));
#endif // OWNED
}

private leaveMsg(ni, isError, source, mc, data, vars) {
	mixed origin;
				// a direct psyc connection can be its own origin
	if (isError && vars && (origin = vars["_INTERNAL_origin"] || source)) {
		mixed m, n, server, t;
		mapping abandon = ([]);

		// member list clean up logic.
		//
		// this stuff mentally belongs to group/master, but
		// since it doesn't apply for persons, we leave it here.

		if (objectp(origin))
		    server = origin->qOrigin() || source;
		else
		    server = origin;

		P3(("%O: errleave(%O, %O, %O, %O, %O, %O) origin %O\n",
		    ME, ni, isError, source, mc, data, vars, origin))

		// a previous message from the pushback may already
		// have removed the subtree
		unless (t = _routes[server]) return 0;

#ifdef MEMBERS_BY_SOURCE
# ifdef TIDILY
		if (mappingp(t)) {
		    P2(("Tidily looking for netburps for %O via %O in %O\n",
		       	server, origin, ME))
		    // does foreach really need a copy() here?
		    each (m, copy(t)) {
			abandon[m] = _u[m];
			remove_member(m, server);
		    }
		}
		else
# endif
		if (intp(t)) {
		    P2(("Messily looking for netburps for %O via %O in %O\n",
		       	server, origin, ME))
		    // does foreach really need a copy() here?
		    mapeach(m, n, copy(_u)) if (stringp(m)
# if 1 //def we_dont_care_about_virtual_hosts
			&& abbrev(server, m)
# else // could run both for maximum paranoia
			&& find_target_handler(m) == origin
# endif
		    ) {
			    abandon[m] = n;
			    remove_member(m, server);
		    }
		}
		if (sizeof(abandon)) {
# if DEBUG == 1
		    if (t && t != sizeof(abandon) && intp(t)) {
			P1(("Netburp in %O: supposed to delete %O people coming from %O, but found %O\n",
			    ME, t, server, abandon))
		    }
# else
		    P2(("Netburp in %O: %O people coming from %O, found %O\n",
			ME, t, server, abandon))
# endif
		    mapeach (m, n, abandon) {
			castmsg(m, "_notice_place_leave_netburp",
			    "Lost route to [_nick].",
				([ "_nick" : n ]));
		    }
		} else
#endif
		    monitor_report("_notice_forward"+mc,
			 "could not handle the error coming from "+
			 to_string(source));
		return 1;
	}
	// should use object, not nickname... old story
#ifndef QUIET_REMOTE_MEMBERS
	if (isValidRelay(source)
	    || isValidRelay(vars["_source_relay"])) {
		// we have to do sendmsg first... daher kein castPresence().. doof!
		sendmsg(vars["_source"], mc, data, vars + ([ "_source_relay" : source ]));
		unless(v("_filter_presence")) castmsg(source, mc, data, vars);
	} else unless (objectp(source) || is_formal(source)) {
	    return;
	}
#endif
	unless (MEMBER(source)) {
		if (isError) error(source, mc, data, vars);
		// probably room got reloaded .. or person first left the
		// place, then unsubscribed..   just let them leave
		// _notice not _echo? was: _failure_invalid_place_membership
		else if (mc == "_notice_place_leave_subscribe")
#ifndef ECHOES
		    sendmsg(source, mc,
#else /* ECHOES */
		    sendmsg(source, "_echo_place_leave_subscribe",
#endif /* ECHOES */
			"You unsubscribe [_nick_place]. Bye bye.",
			([ "_nick_place" : MYNICK,
			 "_nick" : vars["_nick"] ]) );
		// careful: detected some recursions here..
		// and.. _echo shouldnt be used for enter/leave meguesses
		//else if (mc != "_echo_place_leave_invalid")
		else if (mc != "_notice_place_leave_invalid") 
		    // couldn't it be a real _warning ?
#ifndef ECHOES
		    sendmsg(source, "_notice_place_leave_invalid",
#else /* ECHOES */
		    sendmsg(source, "_echo_place_leave_invalid",
#endif /* ECHOES */
			"[_nick_place] doesn't remember seeing you anyway.",
			([ "_nick_place" : MYNICK,
			 "_nick_local" : vars["_nick_local"],
			 "_nick" : vars["_nick"] ]) );
		return 1;
	}
 //	unless (member(_u, vars["_nick"])) return 1;
 //	unless (_u[who] == previous_object() ||
 //	  find_person(who) == previous_object()) return 0;

	//mc = "_notice_place_leave";
	data = "[_nick] leaves [_nick_place].";		// TODO
	vars["_nick_place"] = MYNICK;
#ifdef PERSISTENT_SLAVES
	revision += 1;
#endif
	// this code doesn't really consider the presence of _tag.
	// a _tag should make it unicast an _echo, remove the member
	// from the tree, then multicast the notice to other people.
	// and since we don't leave without a _tag in most cases, we
	// don't need any other behaviour really. the idea that we can
	// optimize away the echo isn't really pragmatic.. TODO.
	// we may also simplify the context specification then, huh?
	//
#ifdef EXPERIMENTAL
	// first send tagged echo to the person leaving
	unless(isError) sendmsg(source, mc, data, vars+ ([ "_source_relay" : source ]));
	// remove her from the context
	remove_member(source, vars["_INTERNAL_origin"]);
	// let everybody else know about the loss
	unless(isError || v("_filter_presence")) castmsg(source, mc, data, vars);
#else
	unless(isError) {
		if (v("_filter_presence")) {
			// arent you a little heavy on the relays here? i dont get it
			sendmsg(source, mc, data, vars+ ([ "_source_relay" : source ]));
		} 
		else castmsg(source, mc, data, vars);
	}
	remove_member(source, vars["_INTERNAL_origin"]);
#endif
	// it's probably safer to call this hook _after_ removing
	// the candidate to avoid risking loops
	leave(source, mc, data, vars);  // hook here.. hardly ever used
	// in fact it should no longer be necessary as you can extend leaveMsg()
	// from place.gen (need to add a #define for it.. TODO)
	return 1;
}

// extending this to hook up operations is more complete, as it also sees
// people dropping out of the place by errors, but it is also a bit more
// dangerous: if you castmsg() from here, you may be recursively triggering
// more errors, since there may be more then one person dropping out of
// the place from the same origin. add a #define to place.gen anyway.. TODO
remove_member(source, origin) {
	m_delete(_u, source);
#ifdef PLACE_MASQUERADE
	m_delete(snames, source);
#endif
	::remove_member(source, origin);
}

msg(source, mc, data, mapping vars) {
	string t;
	string ni;

	P4(("PRE %O msg(%O,%O,%O,%O) from %O\n", ME, source, mc, data, vars,
		previous_object()))

	unless (source) {
		source = vars["_INTERNAL_source"];
		ASSERT("source", source, source)
	}
	// this can indeed happen when the object has already been terminated
	// during shutdown procedure, but something comes back to talk to it.
	// in fact it's enough to type something (^L) in telnet after
	// officially having left all places. should set place=0 in user.c...
	// ASSERT() is no good here, as this is not a debug case
	if (!_u) {
                //raise_error("place not initialized!?\n");
                P1(("Warn: Unitialized %O got %O from %O\n", ME, mc, source))
                return;
        }

#ifdef PLACE_OWNED
	// belongs into the enter() hook
	if (abbrev("_request_enter", mc) || abbrev("_request_context_enter", mc)) {
		// let NICKLESS pass
		if (member(banned, lower_case(SNICKER))) {
		    sendmsg(source, "_error_place_enter_necessary_invitation",
			// let's pretend this is an invite-only room
			"[_nick_place] can only be entered upon invitation.",
			// "You are not allowed to join [_nick_place].",
			([ "_nick_place" : MYNICK ]));
		    return;
		}
	}
	// new hook necessary here
	else if (mc == "_request_invitation" && v("_restrict_invitation")) {
		mixed supplicant;
		unless (supplicant = vars["_invitation"]) return;
		if (qOwner(SNICKER)) {
			if (objectp(supplicant))
			    supplicant = supplicant->qName();
			sAide(supplicant, source);
			PT(("implied mandate for %O with invitation into "
			    "restricted room: %O\n", supplicant, ME))
		} else {
			castmsg(ME,
			    "_failure_place_invitation_necessary_ownership",
	"[_nick] tries to invite [_nick_target] but fails.",
				vars);
			// be kind and also inform the supplicant
			sendmsg(supplicant,
			    "_failure_place_invitation_necessary_ownership",
	"[_nick] tries to invite [_nick_target] but fails.",
				vars);
			return;
		}
	}
#endif
#if 0
	// zero source means it's a system message
	// currently only used by monitor_report()
	// but we should work on that
	unless(source) {
		//D2( raise_error("caught zero source\n"); )
		// server warn gets here!
		P1(("%O caught zero source (%O,%O,%O)\n",
			ME, mc, data, vars))
		return;
	}
#endif
	// if (data && member(data, '\n') != -1)
	//	data = replace(data, "\n", " ");

	//t = lookup_identification(source, (qExists(source) ? 0 : vars["_source_identification"]));
	t = source;
	// should this happen for string sources only? as in person.c? TODO
	//
	// again, entity.c replaces UNLs with UNIs here and later patches things
	// back in uni::sendmsg so on the way out stuff goes to the UNLs
	unless (::msg(&source, mc, data, vars)) return 0;
	P4(("POST %O msg(%O,%O,%O,%O) from %O in %O\n", ME, source, mc, data, vars,
		t, previous_object()))
//	ASSERT("seen local uniform",
//	   objectp(source) || ... is_formal(source), source)
#ifdef SIGS
	if (call_signature(source, mc, data, vars)) return 1;
#endif
// TODO: drin weil das unten nicht geht
	if (abbrev("_status", mc)) {
		P1(("%O rejecting status(%O,%O..)\n",
		    ME,source,mc))
		return;
	}
	// uni and unl differ
	if (t != source) {
		P2(("@%s knows: %O is really %O\n", MYNICK, t, source))
		//source = t;
		// if (!member(vars, "_nick"))   -- dont trust the UNL
		if (objectp(source)) {
			if (objectp(t)) // location is local, we can trust him
			    ni = vars["_nick"] || source->qName();
			else	// uni is here but msg comes from client
			    ni = vars["_nick"] = source->qName();
		} else {
#if 1
// hier folgt ein block mit der komplexen extraktion des nicknames aus
// der url der UNI. was mich dabei verwundert ist, wenn wir schon nicht
// der _nick variable vertrauen wollen, warum machen wir das nur bei der UNI
// und nicht bei jeder remote suorce generell? TODO
		    mixed *u = parse_uniform(source);
		    if (u) {
			string n = u[UNick];
			unless (n) return 0; // not n? hm...

			unless (vars["_nick"]
				&& (lower_case(n)
				    == lower_case(ni = vars["_nick"])))
			    ni = vars["_nick"] = n;
		    } else //return 0; // uhm.
			// just think of non-chat apps where a host may
			// have a good reason to enter a group..
			ni = source;
#else
		    vars["_nick"] = source;
#endif
		}
	} else {
		// uni and unl are the same
		if (vars["_nick"]) ni = vars["_nick"];
		else 
		    ni = vars["_nick"] = UNIFORM(source);
	}

	// to avoid recursions, we catch this right from the start
	if (abbrev("_warning", mc)) {
		t = objectp(source) ? vars["_source_relay"] : source;
		P1(("Ignored: %O got %s from %O via %O\n",
		    ME, mc, t, previous_object()))
		return;
	}
	if (abbrev("_error", mc) || abbrev("_failure", mc)) {
		t = objectp(source) ? vars["_source_relay"] : source;
		P1(("Netburp: %O got %s from %O via %O\n",
			ME, mc, t, previous_object()))
		ni = vars["_nick_target"] || t;
		if (leaveMsg(ni, 1, t, mc, data, vars)) {
#if 0
		    // klappt immernoch nicht zuverlässig!
			castmsg(t, "_notice_place_leave_netburp",
			    "Error delivering to [_nick].",
				([ "_nick" : ni ]));
	        } else {
#endif
//		    monitor_report("_notice_forward"+mc,
//			 S("%O got %O from %O\n",
//			 ME, psyctext(data, vars, mc, source), source));
		    log_file("PLACE_ERROR", "%O « (%O,%s,%O,%O)\n",
			     ME, source, mc, data, vars);
//		    monitor_report(mc, psyctext(source+": "+data,vars,"",source));
		}
		return;
	}
	if (abbrev("_request", mc)) {
		// needs a rewrite into a try-and-slice switch()
		// or shouldn't this stuff just move into the signature table?
		if (abbrev("_request_enter", mc)
		    || abbrev("_request_leave", mc)
		    || abbrev("_request_invitation", mc)) {
			mc = "_notice_place"+mc[8..];
#ifdef PLACE_TOPIC
			// hm, this doesn't just go back to the new
			// person.. it is resent to all..
			if (v("topic") &&! abbrev("_request_leave", mc))
			    vars["_topic"] = v("topic");
#endif
		// should become the common family for all three of the above
		} else if (abbrev("_request_context", mc)) {	// SPEC
			// we're not ready for this:
			//mc = "_notice"+mc[8..];	// keep the _context
			// instead:
			mc = "_notice_place"+mc[16..];
#ifdef PLACE_TOPIC
			// we even set it on leaves.. so what.
			if (v("topic")) vars["_topic"] = v("topic");
#endif
		} else if (abbrev("_request_description", mc)) {
		    unless (mappingp(t = qDescription(source, vars, ni))) {
			    // should we issue a _failure_unavailable..?
			    // then again person.c says: be quiet do not reply
			    return 1;
		    }
		    t["_nick_place"] = MYNICK;
		    return sendmsg(source, "_status_description_place", 0, t);
#ifdef JABBER_PATH
		} else if (abbrev("_request_list_feature", mc)) {
		    mixed isfeed = qNewsfeed();
		    mixed rv = ([ "_nick_place" : MYNICK,
				"_name" : MYNICK,
				"_list_feature" : ({ "list_feature" }),	// _tab
				]);
		    if (isfeed) {
			rv["_identity"] = "news";
		    } else {
			rv["_identity"] = "place";
			rv["_list_feature"] += ({ "jabber-gc-1.0", "jabber-muc", "nonanonymous", v("public") ? "public" : "private", "persistent" });
		    }
		    // _notice??? this is a _status! FIXME
		    sendmsg(source, "_notice_list_feature" + 
			    (isfeed ? "_newsfeed" : "_place"),
			    "[_nick] is a [_identity] called [_name] offering features [_list_feature].",
			    rv);
		    return 1;
		} else if (abbrev("_request_list_item", mc)) {
		    // after the cmd parser rewrite we may offer so-called
		    // ad-hoc commands
		    mixed rv = ([ "_nick_place" : MYNICK,
				"_name" : MYNICK,
				]);
		    unless(MEMBER(source)) {
			// TODO: send an appropriate error
			// for now, just continue as it doesnt make 
			// a difference
		    }
		    PT(("_target_fragment: %O\n", vars["_target_fragment"]))
		    switch(vars["_target_fragment"]) {
		    case 0:
			rv["_list_item"] = ({ }),   // _tab
			rv["_list_item_description"] = ({ });	// _tab
		    }
		    // _notice??? this is a _status! FIXME
		    sendmsg(source, "_notice_list_item",
			    "[_nick] has lots of items: [_list_item_description].",
			    rv);
		    return 1;
#endif
		} else if (!MEMBER(source)) {
/*
 * everything below this check is member-only
 * so when rewriting commands and functions into
 * signature handlers, the checks need to be
 * transplanted accordingly. this makes the
 * blueprints a bit larger, as you have the same
 * if-member checks in each handler, but that is no
 * problem. nothing gets less efficient by that.
 * in fact the signature call should be a lot
 * faster than going through a series of switches
 * or -gasp- if/else trees of abbrev checks. 
 */
		    P1(("ARCHETYPE (%O,%O,%O,%O..) needs to enter %O first"
		        " (members: %O).\n",
			source,mc,data,vars, ME, _u))
		    // do not allow _request_history etc.
		    return sendmsg(source, "_error_necessary_membership",
		    "You need to enter [_nick_place] first.",
			 ([ "_nick_place" : MYNICK ]) );
		} else if (abbrev("_request_members", mc)) {
		    P4(("%O from %O.\n", mc, ME))
		    return showMembers(VERBOSITY_REQUEST_MEMBERS, source);
		} else if (abbrev("_request_status", mc)) {
		    mixed b = 0, vy = VERBOSITY_STATUS_TERSE;

		    if (!abbrev("_request_status_terse", mc)) {
			b = boss(source);
			vy = VERBOSITY_STATUS;
		    }
		    // irc clients use extra requests for topic 
		    if (trail("_IRC", mc))
			vy -= VERBOSITY_TOPIC;
		    // irc clients don't like unexpected member lists
		    else if (vy & VERBOSITY_MEMBERS)
			showMembers(vy, source);
		    return showStatus(vy, b, source, mc, data, vars);
		} else if (abbrev("_request_execute", mc)) {
		    string *args = explode(data, " ");
		    data = lower_case(args[0]);
		    unless(vars["_nick"]) vars["_nick"] = objectp(source) ?
					    source->qName() : to_string(source);
		    unless(cmd(data, args, boss(source), source, vars, mc))
		      sendmsg(source,
			      "_failure_unsupported_execute_place_command",
			    "Sorry, no such command here.");
		    return 1;
#ifdef PLACE_HISTORY
# ifndef SIGS
		} else if (abbrev("_request_history", mc)) {
		    return _request_history(source, mc, data, vars, 0);
# endif
#endif
#ifdef PLACE_TOPIC_COMMAND
		} else if (abbrev("_request_set_topic", mc)) {
		    sTopic(vars["_topic"], source, vars["_nick"]);
		    return 0;
#endif
		} else return;
	}
	// it is correct to leave a place with _notice_place_leave instead
	// of _request_leave because a room is not entitled to keep a
	// member in, when he doesn't want to. the place also accepts
	// _notice_place_enter as a _request_enter, but you shouldn't use that
	if (abbrev("_notice_place_enter", mc)
	     || abbrev("_notice_context_enter", mc)) {  // actually a _request
		int neu, again;

#ifdef PLACE_MASQUERADE
					// könnte ungut enden.. lieber nicht
		// if (vars["_nick_local"]) ni = vars["_nick_local"];
#endif
		P3(("ENTER (%O, %O)\n", source, vars))
		unless (stringp(vars["_nick"]) && strlen(ni)) {
			sendmsg(source, "_error_place_enter_necessary_nick",
    "Sorry, you can't just walk into here without a proper nickname.");
			return;
		}
		// TODO: double usage of this flag is bad:
		// 	/1/ send history, memberlist, ...
		// 	/2/ cast new presence to room
		// 	i would like to differentiate this and do /1/ always
		// 	because the only st00pid clients that have problems
		// 	with that are jabber clients which may send a 
		// 	different mc (_request_enter_this_may_be_a_presence_change)
		neu = !MEMBER(source); // don't output the status again
		if (trail("_again", mc)) {
		    mc = mc[..<7];
		    again = !neu;
		}

		// zero return value means user is not allowed to enter!
#ifndef QUIET_REMOTE_MEMBERS
		// TODO: haeh? das is doch fuer den basic vollkommen wurst
		// das gehoert wenn schon in den master und dort 
		// unter SILENT oder so gehandelt
		// der basic koennte es generell einfach rejecten
		// wenn source relay oder context gesetzt ist. 
		// aber die Nachrichten erzeugen die der master machen
		// sollte... nene.
		P1(("enter! %O relay? ", source))
		// simplify for all objects that have no isValidRelay()
		if (isValidRelay(source)
		    || isValidRelay(vars["_source_relay"])
		    || isValidRelay(vars["_context"])) {
			P1(("yes. cast & out: %O in %O\n", source, ME))
			return castPresence(source, mc, data, vars,
			    // don't broadcast the user's presence
			    !neu || v("_filter_presence"));
		} else unless (objectp(source) || is_formal(source)) {
			P1(("no, but what is it? returning.\n"))
			return;
		}
		if (vars["_source_relay"]) {
			P1(("no, he forgot to link. returning.\n"))
			sendmsg(source, "_error_necessary_link_place",
    "Sorry, you can't just walk into here without a proper link."); 
			return;
		}
		P1(("no. he's local.\n"))
#endif
		if (neu)    // mayEnter hook
		    unless (enter(source, mc, data, vars)) return;
		insert_member(source, mc, data, vars, ni, neu, again);
		return 1;
	} else if (abbrev("_notice_place_leave", mc)
#if 0
		    || (t = abbrev("_failure", mc))
		    || (t = abbrev("_warning", mc))
		    || (t = abbrev("_error", mc))
#endif
		    || (abbrev("_notice_context_leave", mc)) ) {
		// this is not a hook, this is behaviour!
		leaveMsg(ni, 0, source, mc, data, vars);
		return 1;
	}
#ifdef PLACE_TOPIC
    	else if (abbrev("_query_topic", mc)) return showTopic(source, 1, OFFICIAL);
#endif
		// would be nice to lighten up this orgy of ors
	else unless (!source
		     || qAllowExternal(&source, mc, vars)   // mayExternal hook
		     || MEMBER(source)
		     || source == "/"	    // allow root to send everywhere
		     || isValidRelay(source)
		     || isValidRelay(vars["_source_relay"])
		     || isValidRelay(vars["_context"])) {
		P1(("(%O,%O,%O..) needs to enter %O first (members: %O).\n",
		    source,mc,data, ME, _u))
#if !( defined(PRO_PATH) && DEBUG < 2 )
		sendmsg(source, "_error_necessary_membership", 0,
			 ([ "_nick_place" : MYNICK ]) );
		//P1(("==> source, relay: %O, %O\n", source, vars["_source_relay"]))
#endif
		return 1;
	} else if (v("_filter_presence") && abbrev("_notice_place", mc) ) {
#ifdef PLACE_TOPIC
		if (strstr(mc, "_topic") == -1) return 1;
#endif
		D2(D(mc+" has passed the silence check!\n");)
		return castmsg(source, mc, data, vars);
#if 0	// TODO: this causes bugs
	} else unless (objectp(source) || abbrev("_message", mc)) {
		// fängt auch _notice_link ab!?
		P1(("%O rejecting %O from %O\n", ME,mc,source))
		return;
#endif
	}
#if 0
	// and here it belongs, the new flood protection
	// store lasttime per user

        if (time() - lasttime1 < MIN_INPUT_TIME && !boss(ME)) {
                pr("_error_invalid_input_speed",
                        "Too much input! %O rejected.\n", a);
                return 1;
        } else {
                lasttime1 = lasttime2;
                lasttime2 = time();
        }
#endif
	if (abbrev("_message", mc)
#ifdef JABBER_PATH
		    // specially requested by fippo for MUC
		    // still wondering whether this is generally
		    // a good idea or not..
		|| mc == "_request_message_public"
#endif
	) {
		if (v("_filter_conversation")) {
			// add hook here?
#ifdef PLACE_TOPIC
			sendmsg(source,
			    "_error_place_silent_configuration_topic",
				"This room is not for talking. [_topic]",
				([ "_topic" : (v("topic") || "") ]) );
#else
			sendmsg(source,
			    "_error_place_silent_configuration",
				"This room is not for talking.");
#endif
			return 0;
		}
		// ist das die nette antwort auf /m channel ?
		if (mc == "_message_private") mc = "_message_public";
		// vorsicht mit _message_public_question und _message_video
	}
#ifdef PLACE_UNKNOWN_HOOK
	unknownmsg(source, mc, data, vars);
}
unknownmsg(source, mc, data, vars) {
#endif
	/* if the source is not a member of the room and was allowed 
	 * because of qAllowExternal* we probably should use the room's
	 * psycName instead of the source
	 * yes, I admit it, afaik this only fixes bugs in net/jabber!
	 */
	castmsg(source, mc, data, vars);
}

// distribution being done by place object..
// this is not the final PSYC plan, but at least
// it is protocol-conformant!
//
// this function is here to be enhanced by net/place/public and master
//
castmsg(source, mc, data, vars) {
	mixed rc;
#ifdef PLACE_MASQUERADE
	string nick;

	// we could also overwrite _nick, but then we end up with some
	// identity headaches in user.c which probably need to be solved 1st
	if (nick = snames[source]) vars["_nick_local"] = nick;
#endif
#ifdef PLACE_LOGGING
	if (v("logging")) {
		unless (_logfile)
			_logfile = "place/"+ MYLOWERNICK +".plog";
		log_file(_logfile, "%O %O %O\n", mc,
			     vars + ([ "_time" : time() ]), data);
	}
#endif
#ifndef DONT_REWRITE_NICKS
	if (vars["_nick"] && _u[source] && vars["_nick"] != _u[source])
	    vars["_nick"] = _u[source];
#endif
	vars["_nick_place"] = MYNICK;
#ifdef IRC_PATH
	// a clear case of _state here.. this is being used by irc/user:w()
	// only, currently, so we might as well make it _INTERNAL.
	if (v("_filter_conversation")) vars["_INTERNAL_control"] = "_silent";
#endif
#ifndef HISTORY_COUNT
	// here we create a copy(vars) by subtracting the _tag
	// later mods like adding _context will not arrive at the upper
	// layer but the _nick changes just above are returned.
	// we could change that by creating our own vars right from the
	// start of this function, but it will probably not do the right thing
	// (all apps and in particular history may not depend on _nick_place
	//  and _nick having been set by this function)
	rc = ::castmsg(source, mc, data, vars - ([ "_tag" ])); // == copy(vars)
#else
	// in this case, calling castmsg() removes tags and makes _context
	// and _count show up in vars and go into history. all apps have to
	// ensure they no longer need the _tag before going into here.  :(
	m_delete(vars, "_tag");
	rc = ::castmsg(source, mc, data, vars);
	// restore the _tag after the cast?
#endif
#ifdef PLACE_HISTORY
	if (mayLog(mc)) {	// mayLog hook!
		// _context should not go into history
		// because history is never multicast
		// to its viewers.. we first need to make
		// a copy of the vars as inheriters may want
		// to keep on using vars after we were here
# if 1
		// all of the above is incorrect. yes history
		// is not multicast, but when retransmitting
		// earlier multicasts you are supposed to provide
		// both _target and _context
	// see http://about.psyc.eu/Routing#Unicast_Message_for_State_Signaling
		// but since object pointers get lost in persistence
		// we re-add the _context at sending time
		if (member(vars, "_context")) {
			// we normally don't get here anyway, because castmsg()
			// created a copy of the vars before setting _context
			// so only a _context mistakenly set by the caller
			// can appear here.
			P1(("Archetype Warning: _context provided to castmsg(%O)\nin %O. Traceback (this is NOT an error):\n%s\n", mc, ME, DEBUG_TRACE))
#  ifndef VARS_IS_SACRED
			vars = copy(vars);
#  endif
			m_delete(vars, "_context");
		}
# endif
		logAppend(source, mc, data, vars, 0, "_time_place");
		_histChange++;
		if (qSaveImmediately()) save();
		// cannot just call ::castmsg after logAppend because
		// logAppend adds the _time_place var so i have to
		// patch around one way or the other
	}
#endif /* PLACE_HISTORY */
	return rc;
}

reboot(reason, restart) {
	// some place objects are clones, some are their blueprints
	// but some are originals. this weeds out the blueprints:
	unless (MYNICK) {
	    P3(("reboot: %O has no MYNICK. good\n", ME))
	    return;
	}
	// if _u were persistent we could recover the (remote) member list
	// after reboot, we should try if that makes sense.. not sure
	save();
	if (mappingp(_u) && sizeof(_u)) {
		P2(("%O shutting down\n", ME))
		if (restart)
		     castmsg(ME,
#ifdef PERSISTENT_MASTERS
			 // not so sure about this mc  ;)
			 "_warning_unavailable_temporary_shutdown",
#else
			 "_notice_place_leave_temporary_shutdown",
#endif
			// used to output _source here, but when a UNI relays
			// the message to a UNL, the UNI is shown instead of ME
		      "Server for [_nick_place] is being restarted: [_reason]", 
			([ "_reason": reason ]) );
		else castmsg(ME, "_notice_place_leave_shutdown", // _permanent ?
		      "Server for [_nick_place] is shutting down: [_reason]",
			([ "_reason": reason ]) );
#ifndef PERSISTENT_MASTERS
		_u = 0;
#endif
		// circuits still need our object id to process the
		// unlink request from the queue. also this part gets
		// called before slave::reboot has run. so lets not destruct.
		//destruct(ME);
	}
}

// administrative call to reload the object
quit() {
	save();
#ifndef PERSISTENT_MASTERS
	castmsg(ME, "_notice_place_leave_temporary",
	    "[_nick_place] is temporarily being shut down for reload.",
	     ([ "_nick_place" : MYNICK ]) );
#endif
	destruct(ME);
}

// called from prepare_destruct() in modern MUDs and now also in psyced
remove() {
	PT(("%O getting destructed...\n", ME))
#ifdef MUD
	quit();
#else
	save();
#endif
}

// create() gets called in clones (of standard), in inheriters
// (like place/europe.c) and inheritees (so-called "super" objects)
// alike.. so you have to be somewhat careful. we could split that,
// but that would worsen the chances of MUD compatibility.
void create() {
	mixed t;

	P2((" [@ %O] ", ME))
#ifdef PLACE_SCRATCHPAD
	used = m_allocate(0, 1);
	given = m_allocate(0, 1);
#endif
#ifdef PLACE_MASQUERADE
	snames = ([]);
#endif
#ifdef PLACE_HISTORY
	_histChange = 0;
	logInit();
	P4(("logInit() in %O\n", ME))
#endif
	// this will allocate empty mappings even in "super" objects
	// (classes which are only used for inheritance)
	// they are useless, but also harmless
	vInit();
	::create();
#ifdef T
	sTextPath();
#endif
	// this will optimize one or two instances of ([]) away
	//if (!_u || clonep(ME)) _u = ([]);
	// not really worth the hassle.. thanks however
	_u = ([]);
	// geht nicht: if (!a) load();
	// wir müssen den richtigen namen abwarten
#ifdef PLACE_OWNED
	banned = ([]);
	if (t = qOwners()) vSet("owners", (mapping) t);
#endif
}

#ifdef PLACE_HISTORY
void reset(int again) {
//	::reset(again);
    if (_histChange) {
	if (qHistoryPersistentLimit())
	    logClip(2 * qHistoryPersistentLimit(), qHistoryPersistentLimit());
	save();
	P2(("RESET: %O stores its history (+%O)\n", ME, _histChange))
    }

	_histChange = 0;
#if 0 //ndef NOCLEANUP
	// keep the server clean. unused places may exit.
	// shall this peace of code resist here ... or better in leave()?
	if (clonep() && ! sizeof(_u)) {
	    P2(("%O is empty, shutting down.\n", ME))
	    reboot("Self-destructing"); // msg should never be seen
	} else
	    P2(("%O is not empty (or is booting up), staying up.\n", ME))
#endif
}
#endif

// see also doc/applied/clean_up: A room defines clean_up() to
//	self-destruct if it is neither inherited nor used as a
//	blueprint, is empty and was not entered for a long time.
//
clean_up(ref) {
    P3(("REFCOUNT for %O is %O.\n", ME, ref))
	if (ref < 1 && clonep(ME)) {
	    unless (sizeof(_u)) {
		P2(("%O is empty, shutting down.\n", ME))
		reboot("Self-destructing"); // msg should never be seen
	    } else {
		P2(("%O is not empty. staying up.\n", ME))
		return 1; // clean_up wouldn't (under some circumstances?) be
			  // called again afterwards.
	    }
	}
	D3(else D(S("%O is a blueprint or special crafted. staying up. "
		   "won't be clean_up()ed again.\n", ME));)
}

load(name, keep) {
	unless (v("name")) {
		unless (name) {
			sscanf(o2s(ME), PLACE_PATH "%s", name);
			if (!name) return;  // the blueprint?

			name = capitalize(name);
			keep = 0;
		}
		::load(DATA_FILE(name));
		if (keep || !v("name") || stricmp(v("name"), name))
		    vSet("name", name);
		else
		    name = v("name");
		sName(name);
		unless (identification)
		    identification = psyc_name(ME, psycName());
#ifdef PERSISTENT_MASTERS
		if (!mappingp(_u)) _u = ([]);
		D2( else if (sizeof(_u))
		    PP(("members in %O: %O\n", ME, _u)); )
		if (!mappingp(_routes)) _routes = ([]);
		D2( else if (sizeof(_routes))
		    PP(("_routes in %O: %O\n", ME, _routes)); )
#endif
#ifdef PLACE_OWNED
		// override storage data
		if (qOwners()) vSet("owners", (mapping) qOwners());
#endif
	}
	//return MYNICK;
	return ME;
}

save() {
	// the ldmud way to check this probably is
	//	clonep() || object_info(ME)[OIB_REF]
	unless (MYNICK) {
		PT(("Should not save() %O !!\n", ME))
		return;	// blueprint? skip!
	}
	P4(("save() %O\n", ME))
#ifndef VOLATILE
        if (index(MYNICK, '/') >= 0) {
		D("Will not save() a place called "+MYNICK+"\n");
		return; 
        }
#endif
	return ::save(DATA_FILE(MYNICK));
}

// called by user object when unknown commands have been entered
// with the advent of signatures, which allow for a proper "psyc"
// way to do commands, this strategy is slowly being evaporated.
cmd(a, args, b, source, vars) {
	P2(("cmd(%O, %O, %O)\n", a, b, source))
	P4(("cmd(%O %O %O %O %O)\n", a, args, b, source, vars))
#ifdef SIGS
	if (call_signature(source, "_request_"+a, args, vars, b)) return 1;
#endif
	switch(a) {
	case "mode":	// irc legacy compatibility interface
			// not implemented as "sig" since we don't need it
			// for psyc clients
		PT(("MODE(%O %O %O %O %O)\n", a, args, b, source, vars))
		return 1;
#ifndef SIGS
#ifdef PLACE_MASQUERADE
	case "nickname":
	case "nick":
	case "ni":
#ifdef PLACE_MASQUERADE_COMMAND
		unless (qMasquerade()) break;
#endif
		if (sizeof(args) >= 2 && args[1]) {
			if(args[1] == "-") {
				snames = m_delete(snames, source);
				previous_object()->w("_echo_place_nick_removed",
					"You have removed your mask.");
			} else {
				snames[source] = ARGS(1);
#ifndef PLACE_MASQUERADE_SECRET
				// should be "_notice_place_nick" ? (_local?)
				castmsg(ME, "_notice_place_masquerade",
				    "[_nick] now masquerades as [_nick_local].",
				     ([ "_nick" : previous_object()->qName(),
				  "_nick_local" : snames[source] ]));
#else
				// FIXME
				previous_object()->w("_echo_place_nick",
			"You are now masquerading as [_nick_local].",
			    ([ "_nick_local" : snames[source] ]));
#endif
			}
		}
		else if (snames[source])
			previous_object()->w("_status_place_nick",
			    "You are masquerading as [_nick_local].",
			    ([ "_nick_local" : snames[source] ]));
		else
			previous_object()->w("_warning_usage_nick",
			    "Usage: /nick (Mask)");
		return 1;
#ifdef PLACE_MASQUERADE_COMMAND
	case "masquerade":
	case "masq":
//		if (!b && stringp(v("topic-user"))
//		       && lower_case(previous_object()->qName()) !=
//		          lower_case(v("topic-user"))) {
//	previous_object()->pr("_error_unavailable_function_place_masquerade",
//			"This function is not available to you here.\n");
//			return 1;
//		}
		if (b > 0) {
			if (sizeof(args) == 2) sMasquerade(args[1]);
			else previous_object()->pr("_warning_usage_masquerade",
			    "Usage: /masquerade [yes|no]\n");
			return 1;
		}
		break;
#endif
#endif
#ifdef PLACE_PUBLIC_COMMAND
	case "public":
		if (b > 20) {
		    if (sizeof(args) == 2) sPublic(args[1]);
		    else previous_object()->pr("_warning_usage_public",
			"Usage: /public [yes|no]\n");
		    return 1;
		}
		break;
#endif
#endif /* !SIGS */
#ifdef PLACE_HISTORY
# ifndef SIGS
	case "hist":
	case "history":
		if (sizeof(args)>1) vars["_parameter"] = ARGS(1);
		_request_history(source, 0, 0, vars, b);
		return 1;
# endif
	case "hc":
	case "histclean": // in case you don't remember exactly.. it's ok
	case "histclear": // wieso um alles in der welt soll das jeder dürfen?
//			    liest denn keiner die cvs kommentare? da stands
//			    drin.. ok wir sind realistisch und schreiben es
//			    gleich in den source... ja also manche menschen
//			    merken erst nachtraeglich dass sie zu private
//			    dinge oeffentlich gesagt haben.. dann sollen sie
//			    nicht betteln muessen.. jeder hat das recht die
//			    history zu killen.. mal schaun ob das mal ein
//			    problem ist, aber bisher hatte ich nicht den
//			    eindruck als sei das der fall
//		if (b > 49) return histClear();
		return histClear(sizeof(args)>1? args[1]: 0, b, source, vars);
		break;
#endif
#ifdef PLACE_STORE_COMMAND
	case "store":
	case "save":
		save();
		return 1;
#endif
#ifdef PLACE_TOPIC_COMMAND
	// not used anymore, see _request_set_topic() instead
	case "topic":
	case "topi":
	case "top":
	case "to":
	case "t":
		sTopic(ARGS(1), source, vars["_nick"]);
		return 1;
#endif
#ifdef PLACE_OWNED
	case "mandates":
	case "listaides":
	case "listschergen":
		// warum nicht einfach bei /st ausgeben?
		if (qOwner(SNICKER)) return listAides(source);
		return;
	case "uninvite":
		unless (v("_restrict_invitation")) return;
		// fall thru
	case "unmandate":
	case "unmand":
	case "unmd":
	case "unchop":
		// fall thru. i think we should provide real /unmandate
	case "mandate":
	case "mand":
	case "md":
	case "schergify":
	case "chop":
		if (qOwner(SNICKER)) {
		    unless (sizeof(args) == 2) {
#if 0
			sendmsg(source, "_warning_usage_mandate",
				"Usage: /mandate «aide»");
			return 1;
#else
			return listAides(source);
#endif
		    }
		    switch(sAide(args[1], source)) {
		    case 1:
			sendmsg(source, "_notice_place_aide_removed",
				"[_aide] was removed from the list of "
				"aides.", ([ "_aide" : args[1] ]) );
			return 1;
		    case 2:
			sendmsg(source, "_notice_place_aide_added",
				"[_aide] was added to the list of "
				"aides.", ([ "_aide" : args[1] ]) );
			return 1;
		    }
		}
		return;
#endif // PLACE_OWNED
	}
#if defined(PLACE_LOGGING) || defined(PLACE_FILTERS)
	if (b) switch(a) {
#ifdef PLACE_LOGGING
	case "logging":
                if (sizeof(args) == 2 && stringp(a = args[1])) {
			string state;

			if (a == "on") vSet("logging", SNICKER);
			else vDel("logging");
			save();
			state = v("logging") ? "on" : "off";
			sendmsg(source, "_echo_place_set_logging_"+state,
				"You switch logging "+ state +".");
		}
                else sendmsg(source, "_warning_usage_logging",
                    "Usage: /logging (on|off)");
                return 1;
#endif
#ifdef PLACE_FILTERS
//	case "quiet": 
//	case "filter": 
//	case "silent": 
//              sendmsg(source, "_error_usage_quiet",
//	"The /quiet and /silent functions have been replaced by /silence.\n\
//See the manual for details.");
//              return 1;
	case "silence": 
		// thought about calling this /filter, but maybe we need that
		// in the user as /filter <method> <flags> someday..
                if (sizeof(args) == 2 && a = lower_case(args[1])) {
			string who = SNICKER;

			if (a == "presence") {
			     vSet("_filter_presence", who);
			     vDel("_filter_conversation");
			} else if (a == "conversation" || a == "talk") {
			     vSet("_filter_conversation", who);
			     vDel("_filter_presence");
			} else if (a=="all" || a=="on" || a=="yes") {
			     vSet("_filter_presence", who);
			     vSet("_filter_conversation", who);
			} else {
			     vDel("_filter_conversation");
			     vDel("_filter_presence");
			}
			save();
		}
                else sendmsg(source, "_warning_usage_silence",
		  "Usage: /silence [presence|conversation|all|none]");
		sendmsg(source, "_status_place_filter_presence_"+
			(v("_filter_presence") ? "on" : "off"),
		    "Presence (enter/leave) messages are "
		    +( v("_filter_presence") ? "disabled" : "enabled" )+
		    " in this place.");
		sendmsg(source, "_status_place_filter_conversation_"+
			(v("_filter_conversation") ? "on" : "off"),
		    "Conversational messages are "
		    +( v("_filter_conversation") ? "disabled" : "enabled" )+
		    " in this place.");
                return 1;
#endif
#if 0
	case "banhost":
	case "tiehost":
                sendmsg(source, "_warning_usage_tiehost",
                    "Usage: /tiehost <ip-match>");
                return 1;
#endif
	case "rou":
	case "routes":
		sendmsg(source, "_status_place_routes",
		    sprintf("The route data structure for %O is: %O",
			    ME, routes()));
		return 1;
	case "obj":
	case "objects":
		sendmsg(source, "_status_place_members_technical",
		    sprintf("The member data structure for %O is: %O",
			    ME, _u));
		return 1;
	case "remove":
		if (sizeof(args) > 1
		    // we disable this check so we can also
		    // remove routes, not just single users.
		    //&& member(_u, args[1])
		    ) {
			// this admin command quietly removes a user
			log_file("BEHAVIOUR", "[%s] %O removes %s from %O\n",
			    ctime(), previous_object(), args[1], ME);
			// this can trigger a _failure_destruct_circuit
			// should provide origin here, huh? don't have it!
			// let the user make it up..
			remove_member(args[1], sizeof(args) > 2 && args[2]);
			// apparently it's pointless if we don't save it
			save();
			return 1;
		}
		sendmsg(source, "_warning_usage_remove",
		    "Usage: /remove <member> [<origin>]");
		return 1;
	}
#endif
	return 0;
}

// amountOnly used by news.c by inheritance
makeMembers(amountOnly) {
	if (sizeof(_u) == 0)
	    return ({ "_none", ([ "_amount_members" : 0 ]) });
	else
	if (amountOnly || sizeof(_u) > MAX_VISIBLE_USERS)
	    return ({ "_amount", ([ "_amount_members" : sizeof(_u) ]) });
	else
	    return ({ "", ([
		 "_list_members" : objects(),	// _tab
		 "_list_members_nicks" : names(),   // _tab
	    ]) });
}

// also called from net/usercmd.i and tn/user
showMembers(verbosity, person) {
	array(mixed) a = makeMembers();
	string auto = verbosity & VERBOSITY_AUTOMATIC ? "_automatic" : "";

	P4(("showMembers for %O. verbosity %O.\n", person, verbosity))
	sendmsg(person, "_status_place_members"+ a[0] + auto,
	    0, ([ "_nick_place" : MYNICK, ]) + a[1] );
	return 1;
}

showStatus(verbosity, al, person, mc, data, vars) {
	if (verbosity & VERBOSITY_UNIFORMS) {
		// should room status be compatible to person description?
		sendmsg(person,
// similar code also in net/person.c
#ifdef IRC_PATH
		    "_status_place_identification_aliases",
		    "PSYC Identification of [_nick_place]: [_identification]"
		    "\nAliases: [_identification_alias]",
#else
		    "_status_place_identification",
		    "PSYC Identification of [_nick_place]: [_identification]",
#endif
		    	([ "_identification": identification,
#ifdef IRC_PATH
			   "_identification_alias":
# ifdef ONION_HTTP
			     ONION_HTTP +"/"+ pathName() +" "+
# endif
# ifdef ONION_IRC
			     ONION_IRC +"/"+ MYNICK +" "+
# endif
# if HAS_PORT(HTTP_PORT, HTTP_PATH) || HAS_PORT(HTTPS_PORT, HTTP_PATH)
#  ifdef PRO_PATH
			       ((tls_available() && HTTPS_URL) || HTTP_URL)
#  else
				// problem with POST over https apparently..
			       (HTTP_URL)
#  endif
				+ "/"+ pathName() +" "+
# endif
# ifdef SIP_PATH
		//	     "sip:#"+ MYLOWERNICK +"@"+ SERVER_HOST +" "+
# endif
# ifdef _host_XMPP
			     "xmpp:*"+ MYLOWERNICK +"@"+ _host_XMPP +" "+
# else
#  ifdef JABBER_PATH
			     "xmpp:*"+ MYLOWERNICK +"@"+ SERVER_HOST +" "+
#  endif
# endif
# ifdef __TLS__
			     "ircs://"
# else
			     "irc://"
# endif
				+ SERVER_HOST +"/"+ MYNICK,
#endif
#ifdef JABBER_PATH
			   "_identification_scheme_XMPP":
# ifdef _host_XMPP
			     "*"+ MYLOWERNICK +"@" _host_XMPP,
# else
			     "*"+ MYLOWERNICK +"@" SERVER_HOST,
# endif
#endif
			    "_nick_place": MYNICK ]) );
	}
#ifdef PLACE_TOPIC
	if (verbosity & VERBOSITY_TOPIC) showTopic(person, 0, OFFICIAL);
#endif
	if (al) {
#ifdef PLACE_PUBLIC_COMMAND
		if (verbosity & VERBOSITY_PUBLICIZED && v("public")) {
			sendmsg(person, "_status_place_public",
			    "[_nick_place] publicized by [_nick].",
			    ([ "_nick" : v("public"),
			 "_nick_place" : MYNICK ]) );
		}
#endif
		// tiehosts ?
#ifdef PLACE_LOGGING
		if (verbosity & VERBOSITY_LOGGING && v("logging")) {
			sendmsg(person, "_status_place_logging",
			    "Logging activated by [_nick].",
			    ([ "_nick" : v("logging"),
			 "_nick_place" : MYNICK ]) );
		}
#endif
	}
#ifdef PLACE_MASQUERADE
	if (verbosity & VERBOSITY_MASQUERADE
#ifdef PLACE_MASQUERADE_COMMAND
	    && qMasquerade()
#endif
	) {
		string ni = snames[person];

		if (ni) sendmsg(person, "_status_place_nick_local",
		    0, ([ "_nick_local" : ni, "_nick_place" : MYNICK ]));
		else sendmsg(person, "_status_place_masquerade",
		    "Masquerading in [_nick_place] is permitted. Try out the /nick command.",
		       	([ "_nick_place" : MYNICK ]));
	}
#endif
#ifdef PLACE_FILTERS
# ifndef VOLATILE
	if (v("_filter_presence") && verbosity & VERBOSITY_FILTER) {
		sendmsg(person, "_status_place_filter_presence",
		    "Presence noise silenced by [_nick].",
		    ([ "_nick" : v("_filter_presence"),
		 "_nick_place" : MYNICK ]) );
	}
# endif
#endif
#ifdef PLACE_HISTORY
	if (verbosity & VERBOSITY_HISTORY && qHistoryGlimpse() && mc
//	   && !abbrev("_echo_place_enter_automatic", mc)
	   && !abbrev("_echo_place_enter_other", mc)	// TODO
//	   && !abbrev("_request_status", mc)
	   ) {
		logView(qHistoryGlimpse(), person);
	}
#endif
	return 1;
}

names() { return m_values(_u); }	// used by irc/user, applet/user
					// place/owned and place/storic
objects() { return m_indices(_u); }	// used by place/owned

size() { return sizeof(_u); }		// netsize() uses this

// this is overridden in more complex rooms to provide continous status output
memberInfo() { return _u; }		// used by showRoom() in http/user

psycName() {
	ASSERT("psycName", stringp(MYNICK), MYNICK)
	return "@"+MYLOWERNICK;
}

pathName() {
	ASSERT("pathName", stringp(MYNICK), MYNICK)
	return "@"+MYNICK;
}

// inheritance hooks
leave(source, mc, data, vars) { return 1; }
enter(source, mc, data, vars) {	// mayEnter?
        string t, ni;

	// muss der _nick_local auch legal sein? TODO
	if (mappingp(vars)) ni = vars["_nick"];
	if ( !(t = legal_name(ni)) || stricmp(t, ni) ) {
		P2(("illegal name %O vs %O in %O\n", ni, t, ME))
		sendmsg(source, "_error_illegal_name_person_place", 0,
		  ([ "_nick_place" : MYNICK, "_nick" : ni ])); 
		return 0;
	}
	return 1;
}

// we shouldn't get here for _filter_conversation rooms (news etc)
// btw. should all "after" hooks be named onSomething() or hasSomethinged() ?
onEnter(source, mc, data, vars) {
	// this does not include _other which is issued on /c - that's good
	int verbosity = abbrev("_echo_place_enter_automatic", mc)
		? VERBOSITY_ENTER_AUTOMATIC + VERBOSITY_AUTOMATIC
	       	: VERBOSITY_ENTER;
#ifndef ENTER_MEMBERS
	if (verbosity & VERBOSITY_MEMBERS) showMembers(verbosity, source);
#endif
#ifdef PLACE_HISTORY
	if (vars["_amount_history"]) {
	    int max = qHistoryGlimpse();
	    int amount = to_int(vars["_amount_history"]);
	    logView(amount > max ? max : amount, source);
	}
#endif
	showStatus(verbosity, boss(source), source, mc, data, vars);
}

// onError hook
error(source, mc, data, vars) {
	P2 (("%O « unexpected msg(%O,%s,%O,%O)\n",
	     ME, source, mc, data, vars))
	return 1; 
}

qAllowExternal() { return 0; }	// mayExternal hook

qInstance() { return 0; }

qDescription(source, vars, nick) {
			// should thus be renamed
	mapping dv = ([ "_topic": v("topic") || "", "_nick": MYNICK ]);
	mixed k, l;

	// should distinguish members from strangers..?
	foreach (k, l: vMapping()) {
		// st00pid simple way of distinguishing exportable vars
		if (k[0] == '_') dv[k] = l;
	}
	P3(("%O qDesc returns %O\n", ME, dv))
	return dv;
}

// this is usually done using sName() or load()
//object compile() { return ME; }

#ifndef DONT_REWRITE_NICKS
sendmsg(target, mc, data, vars, source, showingLog, callback) {
	// some usage: sendmsg calls do not provide vars.
	// change it there, or change it here?
	// actually here we get to 'else' which is nice too
	if (!vars) vars = ([]);
	else if (vars["_nick"] && _u[source] && vars["_nick"] != _u[source]) {
		P1(("rewriting %O into %O\n", vars["_nick"],  _u[source]))
		vars["_nick"] = _u[source];
	}
	return ::sendmsg(target, mc, data, vars, source, showingLog, callback); 
}
#else
# echo OOPS... DONT_REWRITE_NICKS is on!
#endif

#ifdef SIGS
_request_set(source, mc, data, vars, b) {
	string k;

	PT(("set(%O, %O, %O, %O, %O) called\n", source, mc, data, vars, b))
	if (k = vars["_key"])
	    // pass on to a subhandler
	    if (call_signature(source, "_request_set_"+ k, data, vars, b))
	    	return 1;

	sendmsg(source, "_warning_usage_place", "Usage: /place <variable> [<value>]");
	return 1;
}

_request_set_default_text(source, mc, data, vars, b) {
    unless (qOwner(SNICKER)) return 0;
    string key = vars["_key"];
    string value = vars["_value"];

    if (strlen(value)) {
	vSet(key, value);
	save();
    }

    sendmsg(source, "_info_set_place_" + key, "Setting \"[_key_set]\" is \"[_value]\".", (["_key_set": key, "_value": v(key)]));
    return 1;
}

_request_set_default_list(source, mc, data, vars, b, list) {
    unless (qOwner(SNICKER)) return 0;
    string key = vars["_key"];
    string value;

    foreach (string item : list) {
	if (item == vars["_value"]) {
	    value = vars["_value"];
	    break;
	}
    }

    if (strlen(value)) {
	vSet(key, value);
	save();
    } else if (strlen(vars["_value"])) {
	sendmsg(source, "_error_invalid_setting_value",
		"Sorry, that is not a valid value for the [_key_set] setting. Valid values are: [_values].",
		([ "_key_set": key, "_values": implode(list, ", ") ]) );
	return 1;
    }

    sendmsg(source, "_info_set_place_" + key, "Setting \"[_key_set]\" is \"[_value]\".", (["_key_set": key, "_value": v(key)]));
    return 1;
}

_request_set_default_bool(source, mc, data, vars, b) {
    unless (qOwner(SNICKER)) return 0;
    string key = vars["_key"];
    string value = vars["_value"];

    if (is_true(value)) {
	vSet(key, 1);
	save();
    } else if (is_false(value)) {
	vSet(key, 0);
	save();
    }

    sendmsg(source, "_info_set_place_" + key, "Setting \"[_key_set]\" is [_value].", (["_key_set": key, "_value": v(key) ? "on" : "off"]));
    return 1;
}


#ifdef PLACE_OWNED
_request_owners(source, mc, data, vars, b) {
	mixed t;
	P1(("_request_owners(%O, %O, %O, %O, %O)\n", source, mc, data, vars, b))
	// this kind of 3 different policies logic needs to be integrated TODO
	if (v("owners") &&! (b || vars["_INTERNAL_trust"] > 5
#ifdef _flag_trust_place_owners
	       	|| qOwner(SNICKER)
#endif
		)) return;
	// not sure if _value is needed here
	t = vars["_list_owners"] || vars["_value"];	// _tab
	// should check for legal nicks & uniforms
	// should provide for a way to make a place unowned again   TODO
	if (pointerp(t)) t = mkmapping(t);
	else if (stringp(t)) t = mkmapping(explode(t, " "));
	if (mappingp(t) && sizeof(t)) vSet("owners", t);
	sendmsg(source, "_echo_place_owners",
	    "The owner list of [_nick_place] is [_list_owners].",
		  ([ "_list_owners" : m_indices(v("owners")),
		      "_nick_place" : MYNICK ]) );
	return 1;
}

_request_kick(source, mc, data, vars, b) {
	mixed target, t, handler;

	P1(("_request_kick(%O, %O, %O, %O, %O)\n", source, mc, data, vars, b))
	//unless (source) source = previous_object();
	unless (qOwner(SNICKER)) return;
	if (vars["_person"]) {
		target = find_person(vars["_person"])
		       	|| lower_case(vars["_person"]);
		if (objectp(target)) {
//		    if (member(objects(), target) == -1) {
//			return;
//		    }
		    t = target->qName();
		    handler = 0;
		} else {
//		    if (member(names(), target) == -1) {
//			return;
//		    }
		    t = target;
		    // lower_case should be unnecessary here.. but who cares
		    handler = find_target_handler(lower_case(
#ifdef UNL_ROUTING
							     uni2unl[t] ||
#endif
							     t));
		}
		PT(("%O KICK %O in %O? banned: %O\n",
		    ME, target, names(), banned))
		// allow to elrid someone even if he isn't here right now
		banned[lower_case(t)] = vars["_person"];
		// but if he is, kick him, too
		if (member(objects(), target) != -1)
		    // TODO: irc fehlt das format hierfuer
		    // und.. oops.. der betroffene empfängt das nicht!!
		    sendmsg(ME,
#ifdef SPEC                  
                             "_request_context_leave"
#else                        
                             "_request_leave"
#endif
			     "_banned",
			"[_nick] got banned from [_nick_place]", ([
				"_nick" : t,
				"_nick_place" : MYNICK,
				"_INTERNAL_origin" : handler
			   ]), target);
	}
	sendmsg(source, "_status_place_banned",
		"These bozos are banned: [_list_banned]",   // _tab
		 ([ "_list_banned" : m_indices(banned) ]) );
	return 1;
}
#endif

# ifdef PLACE_STYLE_COMMAND
// this could turn into a generic _request_set*** as it does the
// default thing to do: store the setting.
_request_set_style(source, mc, data, vars, b) {
	if (qOwner(SNICKER)) {
		string value = vars["_uniform_style"] || vars["_value"];
		if (value == "-") {
		    vDel("_uniform_style", value);
		    save();
		} else if (value && (value = legal_url(value, "http"))) {
		    vSet("_uniform_style", value);
		    save();
		} else if (value) {
		    sendmsg(source,
			    "_error_illegal_scheme",
			    "That is not a valid [_scheme] URL for a file.",
			    ([ "_scheme" : "http" ]));
		    return 1;
		}
		sendmsg(source, "_status_place_uniform_style",
			"Style file [_uniform_style] is in use here.",
			([ "_uniform_style" :
			   v("_uniform_style") || "-" ]));
		return 1;
	}
	return 0;
}
# endif
#endif

#define complainMembership(source)			\
	sendmsg(source, "_error_necessary_membership",	\
	"You need to enter [_nick_place] first.",	\
			 ([ "_nick_place" : MYNICK ]) )

#ifdef PLACE_MAY_HISTORY
// only provide this hook if PLACE_MAY_HISTORY was defined above.
// this hook can then be overridden using #define MAY_HISTORY in
// place.gen should you ever need it.. otherwise MAY_HISTORY will
// have no effect. since that is my current default, i will not
// document MAY_HISTORY.
//
int mayHistory(source, mc, data, vars, b) {
	if (MEMBER(source)) return 1;
	complainMembership(source);
	return 0;
}
#endif

#ifdef PLACE_HISTORY
_request_history(source, mc, data, vars, b) {
	// it's good to have separate vars in the protocol
	// but logView() doesn't want to know..
	P3(("_request_history(%O,%O,%O,%O,%O)\n",
	    source, mc, data, vars, b))
# ifdef SIGS
#  ifdef PLACE_MAY_HISTORY
	unless (mayHistory(source, mc, data, vars, b)) return;
#  else
	unless (MEMBER(source)) return complainMembership(source);
#  endif
# endif
	logView(vars["_match"] || vars["_parameter"] || vars["_amount"],
	    source, 0, vars["_offset"]);
	sendmsg(source, "_echo_history"); // indicate end of history
	return 1;
}
#endif

#ifdef PLACE_PUBLIC_COMMAND
// should we use v("public") and ->vQuery("public") only? no, bad idea.
// then an operator can change a #define PUBLIC room into non-public.
// let's keep this mixed behaviour where v("public") can be overridden
// by place.gen.
qPublic() { return v("public"); }
qPublicName() { return qPublic() ? MYNICK : 0; }

#ifdef SIGS
_request_public(source, mc, data, vars, b) {
	// API to be decided..
	string a = vars["_flag_public"] || vars["_value"];
#else
sPublic(a) {
	object source = previous_object();
#endif
	string state;

	unless (stringp(a) && strlen(a)) {
#ifdef SIGS
		showStatus(VERBOSITY_PUBLICIZED, b, source, 0, data, vars);
#endif
		return 1;
	}
#ifdef SIGS
	// this *could* go into a mayPublic() if anyone cares..
	if (b <= 20) {
		sendmsg(source, "_error_necessary_privilege", 0,
		    ([ "_command": "public" ]) );
		return 1;
	}
#endif
	if (a == "on" || a == "yes") {
		if (qPublic()) {
			sendmsg(source, "_warning_place_set_public_on",
			    "This room is already public.");
			return 1;
		}
		vSet("public", UNIFORM(source));
	} else if (a == "off" || a == "no") {
		unless (qPublic()) {
			sendmsg(source, "_warning_place_set_public_off",
			    "This room is already private.");
			return 1;
		}
		vDel("public");
	} else {
		sendmsg(source, "_warning_usage_public",
		    "Usage: /public [yes|no]");
		return 1;
	}
	save();
	state = v("public") ? "on" : "off";
	log_file("PUBLIC", "[%s] %O %s %O (%O)\n",
	    ctime(), source, state, MYNICK, ME);
	sendmsg(source, "_echo_place_set_public_"+state,
		"You make this room "+
		(v("public") ? "public" : "private") +".");
	return 1;
}
#endif

#ifdef PLACE_MASQUERADE
# ifdef SIGS
_request_masquerade(source, mc, data, vars, b) {
	// API to be decided..
	string a = vars["_flag_masquerade"] || vars["_value"];
# else
sMasquerade(a) {
	object source = previous_object();
# endif
	string state;

	unless (stringp(a) && strlen(a)) {
# ifdef SIGS
		showStatus(VERBOSITY_MASQUERADE, b, source, 0, data, vars);
# endif
		return 1;
	}
# ifdef SIGS
	if (b < 1) {
		// this *could* go into a mayMasquerade() if anyone cares..
		sendmsg(source, "_error_necessary_privilege", 0,
		    ([ "_command": "masquerade" ]) );
		return 1;
	}
# endif
# ifdef PLACE_MASQUERADE_COMMAND
	if (a == "on" || a == "yes") {
		if (qMasquerade()) {
			sendmsg(source, "_warning_place_set_masquerade_on",
			    "This room is already in a masquerade.");
			return 1;
		}
		vSet("masquerade", UNIFORM(source));
	} else if (a == "off" || a == "no") {
		unless (qMasquerade()) {
			sendmsg(source, "_warning_place_set_masquerade_off",
			    "This room already isn't in a masquerade.");
			return 1;
		}
		vDel("masquerade");
		snames = ([ ]);	    // important detail  ;)
	} else {
		sendmsg(source, "_warning_usage_masquerade",
		    "Usage: /masquerade [yes|no]");
		return 1;
	}
	save();
	state = v("masquerade") ? "on" : "off";
	log_file("MASQUERADE", "[%s] %O %s %O (%O)\n",
	    ctime(), source, state, MYNICK, ME);
	sendmsg(source, "_echo_place_set_masquerade_"+state,
		    "You "+ (v("masquerade") ? "en" : "dis")
		    +"able masquerading.");
# else
	sendmsg(source, "_warning_place_set_masquerade_on_always",
	    "This room is always in a masquerade.");
# endif // PLACE_MASQUERADE_COMMAND
	return 1;
}

# ifdef SIGS
_request_nick_local(source, mc, data, vars, b) {
	string a;
	string ni;

# ifdef PLACE_MASQUERADE_COMMAND
	unless (qMasquerade()) {
		sendmsg(source, "_error_disabled_masquerade");
		return 1;
	}
# endif
       	ni = vars["_nick"];
	ASSERT("_request_nick_local (source has nick)",
	       stringp(ni) && strlen(ni), ni)
	a = vars["_nick_local"] || vars["_value"];
	unless (stringp(a) && strlen(a) && stricmp(a, ni)) {
		ni = snames[source];
		if (ni) {
			sendmsg(source, "_echo_place_nick_removed",
			    0, ([ "_nick_local" : ni ]));
			snames = m_delete(snames, source);
		} else sendmsg(source, "_status_place_nick_local_none");
			// w("_warning_usage_nick", "Usage: /nick (Mask)");
		return 1;
	}
	if (vars["_INTERNAL_stuss"]) {
		sendmsg(source, "_warning_usage_nick", "Usage: /nick (Mask)");
		return 1;
	}
	snames[source] = a;
# ifndef PLACE_MASQUERADE_SECRET
	castmsg(source, "_notice_place_masquerade",
	    "[_nick] now masquerades as [_nick_local].",
	     ([ "_nick" : ni, "_nick_local" : a ]));
# else
				// FIXME
	previous_object()->w("_echo_place_nick",
	    "You are now masquerading as [_nick_local].",
		([ "_nick_local" : snames[source] ]));
# endif
	return 1;
}
# endif	// SIGS
#endif	// PLACE_MASQUERADE

#ifdef PLACE_OWNED
/* SOME NOTES ON AIDES
 *
 * Aides are (in the context of owned rooms) privileged users, which the
 * room owners (or at least one of them) put some special trust in.
 * Therefore aides have more rights than ordinary users, but less than
 * the owners. In a default owned room, aides have no more rights than
 * the one to set the topic. This is for the following reasons:
 *
 * * Even owned rooms have few privileged commands, most of them deal with
 *   aides - room owners can /mandate someone (make him an aide),
 *   request a list of aides and such.
 * * Elrid (which gets you rid of a malicious user) is, beside of the
 *   aides-related commands the only privileged command, which aides
 *   cannot use, as elrid is a really powerful command. Once you elrided
 *   someone, he cannot join the room again (with his current identity). A
 *   server restart is needed to clear the list of elridded identities. So
 *   elrid is in no case a fun command like KICK on IRC, but the last resort
 *   against really malicious users. Ignoring bad behaving users, or talking
 *   to them is highly preferred to an elrid.
 *   So as an elrid cannot be undone by simple means, it should be up to the
 *   room owner(s) to decide what people will be denied to access the room
 *
 * You might ask: What are aides good for then? Setting topics isn't a
 * quite fulfilling task after all, is it?
 * No of course it is not. Aides were originally designed for special
 * crafted places, like psyc://psyced.org/@GoodAdvice, which is quite
 * similar to fortune, except for it is better and generates webpages
 * containing the fortunes and such. As it wasn't acceptable to let anybody
 * add fortunes and neither that only owners add fortunes a special rank
 * was needed: Aides. In that special environment of GoodAdvice, aides
 * are allowed to add fortunes, to go through the list of all existing
 * fortunes, to search for existing ones and to delete fortunes they added
 * themselves. Owners can delete all fortunes, no matter who added them,
 * which was not a power the usual team members should be able to use.
 *
 * So, as the example describes, aides are a rank for special-crafted
 * rooms building up on owned rooms, which do need more levels than owner
 * and user. Should you want to write your own special crafted room with
 * extra-features nobody but you ever imagined, consider using qAide()
 * and such to give your friends privileged access to all the extra-
 * functions you invented.
 */

sAide(whom) {
    string t;
    int ret;
    mapping aides = v("aides") || ([]);

#if 0
    // change local uniform to nick ... isn't really correct like this
    array(mixed) u = parse_uniform(whom);
    if (u && is_localhost(u[UHost])) whom = u[UResource];
#else
    object o = psyc_object(whom);
    if (o) whom = o->qName();
#endif

    t = lower_case(whom);
    if (aides[t]) {
	aides -= ([ t ]);
	ret = 1;
    } else {
	aides[t] = 1;
	ret = 2;
    }
    
    vSet("aides", aides);
    save();
    return ret;
}

listAides(source) {
    if (mappingp(v("aides")))
	sendmsg(source, "_status_place_aides",
	     "This room knows the following aides: [_aides]", ([ 
		  "_aides" : v("aides")
	      ]) );
    else
	sendmsg(source, "_status_place_aides_none",
	     "No aides defined in this owned room.");
    return 1;
}

qAide(snicker, aidesonly) {
// never call with objectp.. use SNICKER
//  if (objectp(whom)) whom = whom->qName();

    snicker = lower_case(snicker);	// should we enforce SNICKER to be lc? yes!
    if (!aidesonly && sizeof(v("owners")) && member(v("owners"), snicker)) return 4;
    unless (mappingp(v("aides"))) return 0;
    return v("aides")[snicker];
}

qOwner(snicker) { return member(v("owners"), lower_case(snicker)); }
#endif

qMember(snicker) {
    P3((">> qMember(%O) in _u: %O\n", snicker, _u))
    return member(_u, snicker);
}