mirror of git://git.psyced.org/git/psyced
276 lines
8.1 KiB
OpenEdge ABL
276 lines
8.1 KiB
OpenEdge ABL
// included by TCP circuit *and* UDP daemon // vim:syntax=lpc
|
|
|
|
volatile mapping routing = shared_memory("routing");
|
|
|
|
// processes routing header variable assignments
|
|
// basic version does no state
|
|
mixed process_routing_modifiers(mapping rvars, mapping vars) {
|
|
foreach (mixed vname : m_indices(rvars)) {
|
|
if (!routing[vname]) {
|
|
DISPATCHERROR("illegal varname in routing header")
|
|
}
|
|
|
|
switch (rvars[vname, 1]) {
|
|
case C_GLYPH_MODIFIER_ASSIGN:
|
|
// TODO: delete if empty?
|
|
if (mappingp(instate))
|
|
instate[vname] = rvars[vname];
|
|
// fall thru
|
|
case C_GLYPH_MODIFIER_SET:
|
|
vars[vname] = rvars[vname];
|
|
break;
|
|
case C_GLYPH_MODIFIER_AUGMENT:
|
|
case C_GLYPH_MODIFIER_DIMINISH:
|
|
case C_GLYPH_MODIFIER_QUERY:
|
|
DISPATCHERROR("header modifier with glyph other than ':' or '=', this is not implemented")
|
|
break;
|
|
default:
|
|
DISPATCHERROR("header modifier with unknown glyph")
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (mappingp(instate))
|
|
vars += instate;
|
|
return 1;
|
|
}
|
|
|
|
mixed process_entity_modifiers(mapping evars, mapping vars, mapping cstate) {
|
|
// apply evars to context state
|
|
foreach (mixed vname : m_indices(evars)) {
|
|
if (routing[vname] || abbrev("_INTERNAL", vname)) {
|
|
DISPATCHERROR("illegal varname in entity header")
|
|
}
|
|
|
|
if (!mappingp(cstate) && evars[vname, 1] != C_GLYPH_MODIFIER_SET) {
|
|
DISPATCHERROR("entity modifier with glyph other than ':' and there's no _context set")
|
|
}
|
|
|
|
switch (evars[vname, 1]) { // the glyph
|
|
case C_GLYPH_MODIFIER_ASSIGN:
|
|
// TODO: delete if empty?
|
|
cstate[vname] = evars[vname];
|
|
// fall thru
|
|
case C_GLYPH_MODIFIER_SET:
|
|
vars[vname] = evars[vname];
|
|
break;
|
|
case C_GLYPH_MODIFIER_AUGMENT:
|
|
if (!abbrev("_list", vname)) {
|
|
DISPATCHERROR("psyc modifier + with non-list arg")
|
|
}
|
|
// FIXME: duplicates?
|
|
cstate[vname] += evars[vname];
|
|
PT(("current state is %O, augment %O\n", cstate[vname], evars[vname]))
|
|
break;
|
|
case C_GLYPH_MODIFIER_DIMINISH:
|
|
if (!abbrev("_list", vname)) {
|
|
DISPATCHERROR("psyc modifier + with non-list arg")
|
|
}
|
|
PT(("current state is %O, diminish %O\n", cstate[vname], evars[vname]))
|
|
foreach(mixed item : evars[vname])
|
|
cstate[vname] -= ({ item });
|
|
PT(("after dim: %O\n", cstate[vname]))
|
|
break;
|
|
case C_GLYPH_MODIFIER_QUERY:
|
|
DISPATCHERROR("psyc modifier ? not implemented")
|
|
}
|
|
}
|
|
|
|
if (mappingp(cstate))
|
|
vars += cstate;
|
|
return 1;
|
|
}
|
|
|
|
mixed process_var_types(mapping evars) {
|
|
string family;
|
|
int glyph;
|
|
|
|
// FIXME: i dont like this block... maybe we decode each variable
|
|
// when setting it?
|
|
// that would also fit with 0 as varname deletion
|
|
// below
|
|
foreach (mixed vname : m_indices(evars)) {
|
|
// psyc type conversion implementation ( http://about.psyc.eu/Type )
|
|
// this does not support register_type() yet, but it is feasible
|
|
PSYC_TRY(vname) {
|
|
case "_uniform":
|
|
case "_page":
|
|
case "_entity":
|
|
if (!parse_uniform(evars[vname]))
|
|
croak("_error_illegal_uniform");
|
|
break;
|
|
case "_nick":
|
|
if (!legal_name(evars[vname]))
|
|
croak("_error_illegal_nick");
|
|
break;
|
|
PSYC_SLICE_AND_REPEAT
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void dispatch(mapping rvars, mapping evars, mixed method, mixed body) {
|
|
string vname;
|
|
mixed vop; // value operation
|
|
string t;
|
|
mapping vars = ([ ]);
|
|
|
|
PT((">> dispatch(%O, %O, %O, %O)\n", rvars, evars, method, body))
|
|
|
|
// check that method is a valid keyword
|
|
if (method && !legal_keyword(method)) {
|
|
DISPATCHERROR("non legal method");
|
|
}
|
|
|
|
// FIXME: this can happen earlier, e.g. in parse.c after
|
|
// process_header
|
|
// check _source/_context
|
|
// this check can be skipped if _source and _context are empty
|
|
if ((t = rvars["_context"] || rvars["_source"])) {
|
|
array(mixed) u;
|
|
unless (u = parse_uniform(t)) {
|
|
DISPATCHERROR("logical source is not a uniform\n")
|
|
}
|
|
#ifdef PSYC_TCP
|
|
unless (qAuthenticated(u[UHost])) {
|
|
DISPATCHERROR("non-authenticated host\n")
|
|
}
|
|
#else
|
|
// TODO?
|
|
#endif
|
|
}
|
|
|
|
if (!process_routing_modifiers(rvars, vars))
|
|
return;
|
|
|
|
// check that _target is hosted by us
|
|
// this check can be skipped if _target is not set
|
|
if ((t = vars["_target"])) {
|
|
array(mixed) u;
|
|
unless (u = parse_uniform(t)) {
|
|
DISPATCHERROR("target is not a uniform\n")
|
|
}
|
|
// FIXME relaying support here?
|
|
if (!is_localhost(u[UHost])) {
|
|
DISPATCHERROR("target is not configured on this server\n")
|
|
}
|
|
}
|
|
|
|
// FIXME deliver packet
|
|
// this should be a separate function
|
|
PT(("SPYC vars is %O\n", vars))
|
|
PT(("SPYC method %O\nbody %O\n", method, body))
|
|
// delivery rules as usual, but
|
|
if (vars["_context"]) {
|
|
mixed context;
|
|
mixed cstate;
|
|
mixed source, target;
|
|
|
|
if (vars["_source"]) {
|
|
P0(("invalid _context %O with _source %O\n",
|
|
context, vars["_source"]))
|
|
DISPATCHERROR("invalid usage of context with _source");
|
|
}
|
|
|
|
context = find_context(vars["_context"]);
|
|
if (!objectp(context)) {
|
|
P0(("context %O not found?!\n", vars["_context"]))
|
|
return;
|
|
}
|
|
|
|
cstate = context->get_state();
|
|
process_entity_modifiers(evars, vars, cstate);
|
|
// FIXME: is it legal to do this if this has _target?
|
|
// there should be no mods then anyway
|
|
// It can have only entity vars, so no _target.
|
|
context->commit_state(cstate);
|
|
|
|
if (vars["_target"]) {
|
|
// FIXME: delivery copycat from below
|
|
// beware: source is set to 0 here as it may not be present
|
|
unless (target = psyc_object(vars["_target"]))
|
|
// FIXME: this doesn't handle remote objects properly!
|
|
target = find_psyc_object(parse_uniform(vars["_target"]));
|
|
PT(("target is %O\n", target))
|
|
// FIXME: net/entity can not yet deal with 0 method
|
|
//
|
|
if (objectp(context)) {
|
|
context->msg(0, method || "", body, vars, 0, target);
|
|
} else {
|
|
// FIXME: proper croak back to sender here
|
|
P0(("context %O for unicast to %O not found???\n", target))
|
|
}
|
|
} else {
|
|
if (vars["_source_relay"]) {
|
|
mixed localrelay;
|
|
if ((localrelay = psyc_object(vars["_source_relay"]))) {
|
|
P0(("local relay %O\n", localrelay))
|
|
vars["_source_relay"] = localrelay;
|
|
} else { // NORMALIZE UNIFORM
|
|
vars["_source_relay"] = lower_case(vars["_source_relay"]);
|
|
}
|
|
}
|
|
if (objectp(context)) {
|
|
// do we need more local object detection here?
|
|
context -> castmsg(source, method || "", body, vars);
|
|
} else {
|
|
// empty contexts are not bad currently
|
|
// in the current implementation it only means that no one
|
|
// interested in that context is online right now
|
|
// FIXME: lines above are about the old stuff where we did
|
|
// not have context state
|
|
}
|
|
}
|
|
} else {
|
|
process_entity_modifiers(evars, vars, 0);
|
|
|
|
if (!vars["_target"] && !vars["_source"]) {
|
|
#ifdef PSYC_TCP
|
|
circuit_msg(method, vars, body);
|
|
#else
|
|
P1(("Ignoring a rootMsg from UDP: %O,%O,%O\n", method, vars, body))
|
|
#endif
|
|
} else {
|
|
string source;
|
|
mixed target;
|
|
if (!vars["_source"]) {
|
|
#if 0
|
|
// FIXME: where to set netloc in active
|
|
if (!netloc) { // set in sender after _request_features
|
|
// FIXME: this is wrong
|
|
DISPATCHERROR("Did you forget to request circuit features?");
|
|
}
|
|
source = netloc;
|
|
#else
|
|
source = netloc || query_ip_name(ME);
|
|
#endif
|
|
} else {
|
|
// FIXME: a macro NORMALIZE_UNIFORM that may do lower_case please
|
|
// not a simple lower_case
|
|
source = lower_case(vars["_source"]);
|
|
}
|
|
// source was checked either via x509 or dns before
|
|
// so it is 'safe' to do this
|
|
register_target(source);
|
|
|
|
// deliver FIXME same code above
|
|
if (!vars["_target"]) {
|
|
target = find_object(NET_PATH "root");
|
|
} else {
|
|
unless (target = psyc_object(vars["_target"]))
|
|
// FIXME: this doesn't handle remote objects properly!
|
|
target = find_psyc_object(parse_uniform(vars["_target"]));
|
|
}
|
|
PT(("target is %O\n", target))
|
|
// FIXME: net/entity can not yet deal with 0 method
|
|
if (objectp(target))
|
|
target->msg(source, method || "", body, vars);
|
|
else {
|
|
// FIXME: proper croak back to sender here
|
|
P0(("target %O not found???\n", target))
|
|
}
|
|
}
|
|
}
|
|
::dispatch(rvars, evars, method, body);
|
|
}
|