iks *
iks_find_with_attrib (iks *x, const char *tagname, const char *attrname, const char *value)
{
iks *y;
if (NULL == x) return NULL;
if (tagname) {
for (y = IKS_TAG_CHILDREN (x); y; y = y->next) {
if (IKS_TAG == y->type
&& strcmp (IKS_TAG_NAME (y), tagname) == 0
&& iks_strcmp (iks_find_attrib (y, attrname), value) == 0) {
return y;
}
}
} else {
for (y = IKS_TAG_CHILDREN (x); y; y = y->next) {
if (IKS_TAG == y->type
&& iks_strcmp (iks_find_attrib (y, attrname), value) == 0) {
return y;
}
}
}
return NULL;
}
void
test_id (char *id, char *partial, char *user, char *server, char *resource)
{
iksid *a;
a = iks_id_new (my_stack, id);
if ((a->partial || partial) && iks_strcmp (a->partial, partial) != 0) BUG(a);
if ((a->user || user) && iks_strcmp (a->user, user) != 0) BUG(a);
if ((a->server || server) && iks_strcmp (a->server, server) != 0) BUG(a);
if ((a->resource || resource) && iks_strcmp (a->resource, resource) != 0) BUG(a);
}
static int
iks_sasl_mechanisms (iks *x)
{
int sasl_mech = 0;
while (x) {
if (!iks_strcmp(iks_cdata(iks_child(x)), "DIGEST-MD5"))
sasl_mech |= IKS_STREAM_SASL_MD5;
else if (!iks_strcmp(iks_cdata(iks_child(x)), "PLAIN"))
sasl_mech |= IKS_STREAM_SASL_PLAIN;
x = iks_next_tag(x);
}
return sasl_mech;
}
int
iks_id_cmp (iksid *a, iksid *b, int parts)
{
int diff;
if (!a || !b) return (IKS_ID_RESOURCE | IKS_ID_USER | IKS_ID_SERVER);
diff = 0;
if (parts & IKS_ID_RESOURCE && !(!a->resource && !b->resource) && iks_strcmp (a->resource, b->resource) != 0)
diff += IKS_ID_RESOURCE;
if (parts & IKS_ID_USER && !(!a->user && !b->user) && iks_strcasecmp (a->user, b->user) != 0)
diff += IKS_ID_USER;
if (parts & IKS_ID_SERVER && !(!a->server && !b->server) && iks_strcmp (a->server, b->server) != 0)
diff += IKS_ID_SERVER;
return diff;
}
// iksparser calls this when it has a full tag
//
// Important: Nothing must be done after a self->streamHook invocation
// if the hook returns a non-zero value.
static int
tagHook (ikss_Stream *self, char *name, char **atts, int type)
{
iks *x;
int err;
switch (type) {
case IKS_OPEN:
case IKS_SINGLE:
if (self->current) {
x = iks_insert (self->current, name);
insert_attribs (x, atts);
} else {
x = iks_new (name);
insert_attribs (x, atts);
if (iks_strcmp (name, "stream:stream") == 0) {
err = self->streamHook (self->user_data, IKS_NODE_START, x);
if (err != IKS_OK) return err;
break;
}
}
self->current = x;
if (IKS_OPEN == type) break;
case IKS_CLOSE:
x = self->current;
if (NULL == x) {
err = self->streamHook (self->user_data, IKS_NODE_STOP, NULL);
if (err != IKS_OK) return err;
break;
}
if (NULL == iks_parent (x)) {
self->current = NULL;
if (iks_strcmp (name, "challenge") == 0) {
send_sasl_challenge(self, x);
iks_delete (x);
} else if (iks_strcmp (name, "stream:error") == 0) {
err = self->streamHook (self->user_data, IKS_NODE_ERROR, x);
if (err != IKS_OK) return err;
} else {
err = self->streamHook (self->user_data, IKS_NODE_NORMAL, x);
if (err != IKS_OK) return err;
}
break;
}
self->current = iks_parent (x);
}
return IKS_OK;
}
void
cdata (char *data, ...)
{
iks *x;
va_list ap;
x = my_x;
va_start (ap, data);
while (1) {
char *name = iks_name (x);
char *tmp = va_arg (ap, char*);
if (NULL == tmp) break;
x = iks_find (x, tmp);
if (!x) {
PR_TEST;
printf ("Tag <%s> is not a child of tag <%s>\n", tmp, name);
exit (1);
}
}
if (iks_strcmp ( iks_cdata (iks_child (x)), data) != 0) {
PR_TEST;
printf ("CDATA [%s] not found.\n", data);
exit (1);
}
va_end (ap);
}
void
acl_init(void)
{
iks *policy;
iks *model;
int class_no;
int e;
// parse security policy file
e = iks_load("/etc/comar/security-policy.xml", &policy);
if (e) {
log_error("Cannot process security policy file '%s', error %d\n",
"/etc/comar/security-policy.xml", e);
return;
}
if (iks_strcmp(iks_name(policy), "comarSecurityPolicy") != 0) {
log_error("Not a security policy file '%s'\n",
"/etc/comar/security-policy.xml");
return;
}
// call permissions on the model
model = iks_find(policy, "model");
if (model) {
class_no = -1;
while (model_next_class(&class_no)) {
set_class(model, class_no);
}
}
}
static void
add_groups(iks *tag, int class_no, int level, struct acl_class *ac)
{
iks *x;
// global permissions
for (x = iks_find(tag, "group"); x; x = iks_next_tag(x)) {
if (iks_strcmp(iks_name(x), "group") == 0)
add_group(x, level, ac);
}
// class permissions
x = iks_find_with_attrib(tag, "class", "name", model_get_path(class_no));
for (x = iks_find(x, "group"); x; x = iks_next_tag(x)) {
if (iks_strcmp(iks_name(x), "group") == 0)
add_group(x, level, ac);
}
}
void
attrib (char *att, char *val, ...)
{
iks *x;
va_list ap;
x = my_x;
va_start (ap, val);
while (1) {
char *name = iks_name (x);
char *tmp = va_arg (ap, char*);
if (NULL == tmp) break;
x = iks_find (x, tmp);
if (!x) {
PR_TEST;
printf ("Tag <%s> is not a child of tag <%s>\n", tmp, name);
exit (1);
}
}
if (iks_strcmp (val, iks_find_attrib (x, att)) != 0) {
PR_TEST;
printf ("Attribute '%s' not found.\n", att);
exit (1);
}
va_end (ap);
}
int
iks_stream_features (iks *x)
{
int features = 0;
if (iks_strcmp(iks_name(x), "stream:features"))
return 0;
for (x = iks_child(x); x; x = iks_next_tag(x))
if (!iks_strcmp(iks_name(x), "starttls"))
features |= IKS_STREAM_STARTTLS;
else if (!iks_strcmp(iks_name(x), "bind"))
features |= IKS_STREAM_BIND;
else if (!iks_strcmp(iks_name(x), "session"))
features |= IKS_STREAM_SESSION;
else if (!iks_strcmp(iks_name(x), "mechanisms"))
features |= iks_sasl_mechanisms(iks_child(x));
return features;
}
static int
count_groups(iks *tag, int class_no)
{
iks *x;
unsigned int nr = 0;
// global permissions
for (x = iks_find(tag, "group"); x; x = iks_next_tag(x)) {
if (iks_strcmp(iks_name(x), "group") == 0)
++nr;
}
// class permissions
x = iks_find_with_attrib(tag, "class", "name", model_get_path(class_no));
for (x = iks_find(x, "group"); x; x = iks_next_tag(x)) {
if (iks_strcmp(iks_name(x), "group") == 0)
++nr;
}
return nr;
}
void
string (char *xml)
{
char *tmp;
tmp = iks_string (iks_stack (my_x), my_x);
if (iks_strcmp (tmp, xml) != 0) {
PR_TEST;
printf ("Result: %s\n", tmp);
printf ("Expected: %s\n", xml);
exit (1);
}
}
iks *
iks_make_resource_bind (iksid *id)
{
iks *x, *y, *z;
x = iks_new("iq");
iks_insert_attrib(x, "type", "set");
y = iks_insert(x, "bind");
iks_insert_attrib(y, "xmlns", IKS_NS_XMPP_BIND);
if (id->resource && iks_strcmp(id->resource, "")) {
z = iks_insert(y, "resource");
iks_insert_cdata(z, id->resource, 0);
}
return x;
}
void
prefs_setup (void)
{
iks *x;
memset (&prefs, 0, sizeof (struct prefs_struct));
prefs_chdir (".ulubot");
if (iks_load ("ayarlar.xml", &x) == IKS_OK) {
if (iks_strcmp (iks_name (x), "ulubot") == 0) {
prefs.jid = iks_strdup (iks_find_cdata (x, "id"));
prefs.pass = iks_strdup (iks_find_cdata (x, "password"));
prefs.admin_jid = iks_strdup (iks_find_cdata (x, "admin_id"));
iks_delete (x);
if (prefs.jid && prefs.pass && prefs.admin_jid) return;
}
}
puts (PACKAGE" v"VERSION" sözlük sunucusuna hoşgeldiniz!");
puts ("Hemen bir kaç ayar yapalım:");
prefs.jid = iks_strdup (input ("Botun Jabber hesabı"));
prefs.pass = iks_strdup (input ("Botun Jabber şifresi"));
prefs.admin_jid = iks_strdup (input ("Yöneticinin Jabber hesabı"));
x = iks_new ("ulubot");
iks_insert_cdata (iks_insert (x, "id"), prefs.jid, 0);
iks_insert_cdata (iks_insert (x, "password"), prefs.pass, 0);
iks_insert_cdata (iks_insert (x, "admin_id"), prefs.admin_jid, 0);
if (iks_save ("ayarlar.xml", x) != IKS_OK) {
puts ("Hata: ayarları kaydedemedim!");
}
iks_delete (x);
puts ("Ayarlar tamam.");
}
//! Validates model file
int
db_validate_model(iks *xml, char *filename)
{
/*!
* Validates model file.
*
* @xml Iksemel document
* @return 0 on success, -1 on error
*
*/
iks *iface, *met, *arg;
DBusError bus_error;
dbus_error_init(&bus_error);
// Check root tag
if (iks_strcmp(iks_name(xml), "comarModel") != 0) {
log_error("Not a valid model XML: %s\n", filename);
return -1;
}
for (iface = iks_first_tag(xml); iface; iface = iks_next_tag(iface)) {
// Only "interface" tag is allowed
if (iks_strcmp(iks_name(iface), "interface") != 0) {
log_error("Unknown tag '%s' in XML: %s\n", iks_name(iface), filename);
return -1;
}
// Interfaces must have a "name" attribute
if (!iks_strlen(iks_find_attrib(iface, "name"))) {
log_error("Model with no name in XML: %s\n", filename);
return -1;
}
for (met = iks_first_tag(iface); met; met = iks_next_tag(met)) {
// Only "method" and "signal" tags are allowed
if (iks_strcmp(iks_name(met), "method") == 0 || iks_strcmp(iks_name(met), "signal") == 0) {
// Tags must have a "name" attribute
if (!iks_strlen(iks_find_attrib(met, "name"))) {
log_error("Method/Signal tag without name under '%s' in XML: %s\n", iks_find_attrib(iface, "name"), filename);
return -1;
}
for (arg = iks_first_tag(met); arg; arg = iks_next_tag(arg)) {
if (iks_strcmp(iks_name(arg), "arg") == 0) {
// Arguments must have a "name" attribute
if (!iks_strlen(iks_find_attrib(arg, "name"))) {
log_error("Argument tag with no name under '%s/%s' in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), filename);
return -1;
}
// Arguments must have a "type" attribute
if (!iks_strlen(iks_find_attrib(arg, "type"))) {
log_error("Argument tag without type under '%s/%s' in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), filename);
return -1;
}
// Types must be a valid DBus signature
if (!dbus_signature_validate(iks_find_attrib(arg, "type"), &bus_error)) {
dbus_error_free(&bus_error);
log_error("Argument tag with invalid type (%s/%s/%s) in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), iks_find_attrib(arg, "name"), filename);
return -1;
}
// Types must be single type object
if (!dbus_signature_validate_single(iks_find_attrib(arg, "type"), &bus_error)) {
dbus_error_free(&bus_error);
log_error("Argument tag with a non-single element type (%s/%s/%s) in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), iks_find_attrib(arg, "name"), filename);
return -1;
}
}
else if (iks_strcmp(iks_name(arg), "annotation") == 0) {
// Attributes must have a "name" attribute
if (!iks_strlen(iks_find_attrib(arg, "name"))) {
log_error("Annotation tag without name under '%s' in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), filename);
return -1;
}
}
else {
log_error("Unknown tag '%s' under '%s/%s' in XML: %s\n", iks_name(arg), iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), filename);
return -1;
}
}
}
else {
log_error("Unknown tag '%s' under '%s' in XML: %s\n", iks_name(met), iks_find_attrib(iface, "name"), filename);
return -1;
}
}
}
return 0;
}
//! Imports model file
static int
model_import(const char *model_file)
{
/*!
* Imports model file to node table.
*
* @model_file File to import
* @return 0 on success, -1 on error
*/
iks *obj, *met;
size_t size = 0;
size_t obj_size, met_size;
int obj_no;
int count = 0;
int e;
e = iks_load(model_file, &model_xml);
if (e != 0) {
log_error("XML load error.\n");
return -1;
}
if (iks_strcmp(iks_name(model_xml), "comarModel") != 0) {
log_error("Bad XML: not a Comar model.\n");
return -1;
}
// scan the model
for (obj = iks_first_tag(model_xml); obj; obj = iks_next_tag(obj)) {
if (iks_strcmp(iks_name(obj), "interface") == 0) {
obj_size = iks_strlen(iks_find_attrib(obj, "name"));
if (!obj_size) {
log_error("Bad XML: interface has no name.\n");
return -1;
}
size += obj_size + 1;
++count;
for (met = iks_first_tag(obj); met; met = iks_next_tag(met)) {
if (iks_strcmp(iks_name(met), "method") == 0 || iks_strcmp(iks_name(met), "signal") == 0) {
met_size = iks_strlen(iks_find_attrib(met, "name"));
if (!met_size) {
log_error("Bad XML: method/signal has no name.\n");
return -1;
}
size += obj_size + 1 + met_size + 1;
++count;
iks *arg;
for (arg = iks_first_tag(met); arg; arg = iks_next_tag(arg)) {
if (iks_strcmp(iks_name(arg), "arg") != 0 && iks_strcmp(iks_name(arg), "annotation") != 0) {
log_error("Bad XML: method/signal may contain <arg> or <annotation> only\n");
return -1;
}
}
}
else {
log_error("Bad XML: interface may contain <method> or <signal> only\n");
return -1;
}
}
}
else {
log_error("Bad XML: root node may contain <interface> only\n");
return -1;
}
}
// size is counted to alloc mem for paths
// prepare data structures
if (prepare_tables(count, size) != 0) return -1;
// load model
for (obj = iks_first_tag(model_xml); obj; obj = iks_next_tag(obj)) {
if (iks_strcmp(iks_find_attrib(obj, "name"), "Comar") == 0) {
continue;
}
obj_no = add_node(-1, build_path(obj, NULL), "", N_INTERFACE);
for (met = iks_first_tag(obj); met; met = iks_next_tag(met)) {
if (iks_strcmp(iks_name(met), "method") == 0) {
char *label = iks_find_attrib(met, "access_label");
if (label) {
iks_insert_attrib(met, "access_label", NULL);
}
else {
label = iks_find_attrib(met, "name");
}
add_node(obj_no, build_path(obj, met), label, N_METHOD);
}
else if (iks_strcmp(iks_name(met), "signal") == 0) {
add_node(obj_no, build_path(obj, met), "", N_SIGNAL);
}
}
}
return 0;
}
static int
on_stream (void *ptr, int type, iks *node)
{
iks *x;
ikspak *pak;
switch (type) {
case IKS_NODE_START:
/* x = iks_make_auth (j_user, prefs.pass, iks_find_attrib (node, "id"));
iks_insert_attrib (x, "id", "auth");
iks_send (j_parser, x);
iks_delete (x); */
break;
case IKS_NODE_NORMAL:
if (strcmp("stream:features", iks_name(node)) == 0) {
if (authorized) {
int features;
features = iks_stream_features(node);
if (features & IKS_STREAM_BIND) {
x = iks_make_resource_bind(j_user);
iks_send(j_parser, x);
iks_delete(x);
}
if (features & IKS_STREAM_SESSION) {
x = iks_make_session();
iks_insert_attrib(x, "id", "auth");
iks_send(j_parser, x);
iks_delete(x);
}
} else {
iks_start_sasl(j_parser, IKS_SASL_DIGEST_MD5, j_user->user, prefs.pass);
}
break;
} else if (strcmp("failure", iks_name(node)) == 0) {
log_event ("Hata: SASL başarısız!");
return IKS_HOOK;
} else if (strcmp("success", iks_name(node)) == 0) {
authorized = 1;
iks_send_header(j_parser, j_user->server);
break;
}
pak = iks_packet (node);
if (pak->type == IKS_PAK_MESSAGE) {
// process incoming messages
command_parse (pak->from->partial, iks_find_cdata (node, "body"));
} else if (pak->type == IKS_PAK_S10N) {
// always accept subscriptions
if (pak->subtype == IKS_TYPE_SUBSCRIBE) {
x = iks_make_s10n (IKS_TYPE_SUBSCRIBED, pak->from->full, NULL);
iks_send (j_parser, x);
iks_delete (x);
}
} else if (pak->type == IKS_PAK_IQ) {
if (iks_strcmp (pak->id, "auth") == 0) {
// auth response
if (pak->subtype == IKS_TYPE_RESULT) {
log_event ("Bağlandık.");
x = iks_make_iq (IKS_TYPE_GET, IKS_NS_ROSTER);
iks_send (j_parser, x);
iks_delete (x);
x = iks_make_pres (IKS_SHOW_AVAILABLE, NULL);
iks_send (j_parser, x);
iks_delete (x);
} else {
log_event ("Hata: kullanıcı doğrulama başarısız oldu!");
return IKS_HOOK;
}
}
}
break;
case IKS_NODE_STOP:
case IKS_NODE_ERROR:
log_event ("Hata: XMPP stream hatası!");
return IKS_HOOK;
}
if (node) iks_delete (node);
return IKS_OK;
}
void
r_draw_gradient (ImpRenderCtx *ctx, void *drw_data, iks *node)
{
// GdkGC *gc;
Gradient grad;
char *stil, *tmp;
iks *x;
stil = r_get_style (ctx, node, "draw:fill-gradient-name");
x = iks_find_with_attrib (iks_find (ctx->styles, "office:styles"),
"draw:gradient", "draw:name", stil);
if (x) {
memset (&grad, 0, sizeof (Gradient));
grad.type = -1;
grad.offset_x = 50;
grad.offset_y = 50;
tmp = iks_find_attrib (x, "draw:start-color");
if (tmp) r_parse_color (tmp, &grad.start);
tmp = iks_find_attrib (x, "draw:start-intensity");
if (tmp) {
int val = atoi (tmp);
grad.start.red = grad.start.red * val / 100;
grad.start.green = grad.start.green * val / 100;
grad.start.blue = grad.start.blue * val / 100;
}
tmp = iks_find_attrib (x, "draw:end-color");
if (tmp) r_parse_color (tmp, &grad.end);
tmp = iks_find_attrib (x, "draw:end-intensity");
if (tmp) {
int val = atoi (tmp);
grad.end.red = grad.end.red * val / 100;
grad.end.green = grad.end.green * val / 100;
grad.end.blue = grad.end.blue * val / 100;
}
tmp = iks_find_attrib (x, "draw:angle");
if (tmp) grad.angle = atoi(tmp) % 3600;
tmp = iks_find_attrib (x, "draw:border");
if (tmp) grad.border = atoi(tmp);
tmp = r_get_style (ctx, node, "draw:gradient-step-count");
if (tmp) grad.steps = atoi (tmp);
tmp = iks_find_attrib (x, "draw:cx");
if (tmp) grad.offset_x = atoi (tmp);
tmp = iks_find_attrib (x, "draw:cy");
if (tmp) grad.offset_y = atoi (tmp);
tmp = iks_find_attrib (x, "draw:style");
if (iks_strcmp (tmp, "linear") == 0)
grad.type = GRAD_LINEAR;
else if (iks_strcmp (tmp, "axial") == 0)
grad.type = GRAD_AXIAL;
else if (iks_strcmp (tmp, "radial") == 0)
grad.type = GRAD_RADIAL;
else if (iks_strcmp (tmp, "rectangular") == 0)
grad.type = GRAD_RECTANGULAR;
else if (iks_strcmp (tmp, "ellipsoid") == 0)
grad.type = GRAD_ELLIPTICAL;
else if (iks_strcmp (tmp, "square") == 0)
grad.type = GRAD_SQUARE;
if (grad.type == -1) return;
// gc = ctx->gc;
// ctx->gc = gdk_gc_new (ctx->d);
// gdk_gc_copy (ctx->gc, gc);
if (grad.type == GRAD_LINEAR || grad.type == GRAD_AXIAL)
r_draw_gradient_simple (ctx, drw_data, &grad);
else
r_draw_gradient_complex (ctx, drw_data, &grad);
// g_object_unref (ctx->gc);
// ctx->gc = gc;
}
}
static int
tagHook (struct stream_data *data, char *name, char **atts, int type)
{
iks *x;
int err;
switch (type) {
case IKS_OPEN:
case IKS_SINGLE:
#ifdef HAVE_GNUTLS
if (data->flags & SF_TRY_SECURE) {
if (strcmp (name, "proceed") == 0) {
err = handshake (data);
return err;
} else if (strcmp (name, "failure") == 0){
return IKS_NET_TLSFAIL;
}
}
#elif HAVE_SSL
if (data->flags & SF_TRY_SECURE) {
if (strcmp (name, "proceed") == 0) {
err = handshake (data);
return err;
} else if (strcmp (name, "failure") == 0){
return IKS_NET_TLSFAIL;
}
}
#endif
if (data->current) {
x = iks_insert (data->current, name);
insert_attribs (x, atts);
} else {
x = iks_new (name);
insert_attribs (x, atts);
if (iks_strcmp (name, "stream:stream") == 0) {
err = data->streamHook (data->user_data, IKS_NODE_START, x);
if (err != IKS_OK) return err;
break;
}
}
data->current = x;
if (IKS_OPEN == type) break;
case IKS_CLOSE:
x = data->current;
if (NULL == x) {
err = data->streamHook (data->user_data, IKS_NODE_STOP, NULL);
if (err != IKS_OK) return err;
break;
}
if (NULL == iks_parent (x)) {
data->current = NULL;
if (iks_strcmp (name, "challenge") == 0)
iks_sasl_challenge(data, x);
else if (iks_strcmp (name, "stream:error") == 0) {
err = data->streamHook (data->user_data, IKS_NODE_ERROR, x);
if (err != IKS_OK) return err;
} else {
err = data->streamHook (data->user_data, IKS_NODE_NORMAL, x);
if (err != IKS_OK) return err;
}
break;
}
data->current = iks_parent (x);
}
return IKS_OK;
}
static int tagHook(struct stream_data *data, char *name, char **atts, int type)
{
iks *x;
int err;
switch(type)
{
case IKS_OPEN:
case IKS_SINGLE:
if(data->flags & SF_TRY_SECURE)
{
if(strcmp(name, "proceed") == 0)
{
err = iks_default_tls.handshake(&data->tlsdata,
data->trans, data->sock);
if(err == IKS_OK)
{
data->flags &= (~SF_TRY_SECURE);
data->flags |= SF_SECURE;
iks_send_header(data->prs, data->server);
}
if(err == IKS_AGAIN)
{
data->flags &= (~SF_TRY_SECURE);
data->flags |= SF_SECURE_AGAIN;
err = IKS_OK;
}
return err;
}
else if(strcmp(name, "failure") == 0)
{
return IKS_NET_TLSFAIL;
}
}
if(data->current)
{
x = iks_insert(data->current, name);
insert_attribs(x, atts);
}
else
{
x = iks_new(name);
insert_attribs(x, atts);
if(iks_strcmp(name, "stream:stream") == 0)
{
err = data->streamHook(data->user_data, IKS_NODE_START, x);
if(err != IKS_OK) return err;
break;
}
}
data->current = x;
if(IKS_OPEN == type) break;
case IKS_CLOSE:
x = data->current;
if(NULL == x)
{
err = data->streamHook(data->user_data, IKS_NODE_STOP, NULL);
if(err != IKS_OK) return err;
break;
}
if(NULL == iks_parent(x))
{
data->current = NULL;
if(iks_strcmp(name, "challenge") == 0)
{
iks_sasl_challenge(data, x);
iks_delete(x);
}
else if(iks_strcmp(name, "stream:error") == 0)
{
err = data->streamHook(data->user_data, IKS_NODE_ERROR, x);
if(err != IKS_OK) return err;
}
else
{
err = data->streamHook(data->user_data, IKS_NODE_NORMAL, x);
if(err != IKS_OK) return err;
}
break;
}
data->current = iks_parent(x);
}
return IKS_OK;
}
//! Loads model to database
void
db_load_model(iks *xml, PyObject **py_models)
{
/*!
* Loads models to database
*
* @xml Iksemel document
* @py_models Pointer to models dictionary
*
*/
iks *iface, *met, *arg;
for (iface = iks_first_tag(xml); iface; iface = iks_next_tag(iface)) {
PyObject *py_methods = PyDict_New();
char *iface_name = iks_find_attrib(iface, "name");
for (met = iks_first_tag(iface); met; met = iks_next_tag(met)) {
PyObject *py_tuple = PyTuple_New(4);
// First argument is type. 0 for methods, 1 for signals
if (iks_strcmp(iks_name(met), "method") == 0) {
PyTuple_SetItem(py_tuple, 0, PyInt_FromLong((long) 0));
}
else {
PyTuple_SetItem(py_tuple, 0, PyInt_FromLong((long) 1));
}
// Second argument is PolicyKit action ID
char *action_id = db_action_id(iface_name, met);
PyTuple_SetItem(py_tuple, 1, PyString_FromString(action_id));
// Build argument lists
PyObject *py_args_in = PyList_New(0);
PyObject *py_args_out = PyList_New(0);
int noreply = 0;
for (arg = iks_first_tag(met); arg; arg = iks_next_tag(arg)) {
if (iks_strcmp(iks_name(arg), "attribute") == 0) {
if (iks_strcmp(iks_find_attrib(arg, "name"), "org.freedesktop.DBus.Method.NoReply") == 0) {
if (iks_strcmp(iks_find_attrib(arg, "value"), "true") == 0) {
noreply = 1;
}
}
}
else if (iks_strcmp(iks_name(arg), "arg") == 0) {
if (iks_strcmp(iks_name(met), "method") == 0) {
if (iks_strcmp(iks_find_attrib(arg, "direction"), "out") == 0) {
PyList_Append(py_args_out, PyString_FromString(iks_find_attrib(arg, "type")));
}
else {
PyList_Append(py_args_in, PyString_FromString(iks_find_attrib(arg, "type")));
}
}
else if (iks_strcmp(iks_name(met), "signal") == 0) {
PyList_Append(py_args_out, PyString_FromString(iks_find_attrib(arg, "type")));
}
}
}
if (noreply) {
py_args_out = PyList_New(0);
}
// Third argument is input arguments
PyTuple_SetItem(py_tuple, 2, py_args_in);
// Fourth argument is output arguments
PyTuple_SetItem(py_tuple, 3, py_args_out);
PyDict_SetItemString(py_methods, iks_find_attrib(met, "name"), py_tuple);
}
PyDict_SetItemString(*py_models, iface_name, py_methods);
}
}
int
model_init(void)
{
iks *model;
iks *grp, *obj, *met;
int count = 0;
size_t size = 0;
size_t grp_size, obj_size, met_size;
int grp_no, obj_no;
int e;
// parse model file
e = iks_load(cfg_model_file, &model);
if (e) {
log_error("Cannot process model file '%s'\n", cfg_model_file);
return -1;
}
if (iks_strcmp(iks_name(model), "comarModel") != 0) {
log_error("Not a COMAR model file '%s'\n", cfg_model_file);
return -1;
}
// FIXME: ugly code ahead, split into functions and simplify
// scan the model
for (grp = iks_first_tag(model); grp; grp = iks_next_tag(grp)) {
if (iks_strcmp(iks_name(grp), "group") == 0) {
grp_size = iks_strlen(iks_find_attrib(grp, "name"));
if (!grp_size) {
log_error("Broken COMAR model file '%s'\n", cfg_model_file);
return -1;
}
size += grp_size + 1;
++count;
for (obj = iks_first_tag(grp); obj; obj = iks_next_tag(obj)) {
if (iks_strcmp(iks_name(obj), "class") == 0) {
obj_size = iks_strlen(iks_find_attrib(obj, "name"));
if (!obj_size) {
log_error("Broken COMAR model file '%s'\n", cfg_model_file);
return -1;
}
size += grp_size + obj_size + 2;
++count;
for (met = iks_first_tag(obj); met; met = iks_next_tag(met)) {
if (iks_strcmp(iks_name(met), "method") == 0
|| iks_strcmp(iks_name(met), "notify") == 0) {
met_size = iks_strlen(iks_find_attrib(met, "name"));
if (!met_size) {
log_error("Broken COMAR model file '%s'\n", cfg_model_file);
return -1;
}
size += grp_size + obj_size + met_size + 3;
++count;
}
if (iks_strcmp(iks_name(met), "method") == 0) {
iks *arg;
for (arg = iks_first_tag(met); arg; arg = iks_next_tag(arg)) {
if (iks_strcmp(iks_name(arg), "argument") == 0
|| iks_strcmp(iks_name(arg), "instance") == 0) {
size += iks_cdata_size(iks_child(arg)) + 1;
}
}
}
}
}
}
}
}
// prepare data structures
if (prepare_tables(count, size)) return -1;
// load the model
for (grp = iks_first_tag(model); grp; grp = iks_next_tag(grp)) {
if (iks_strcmp(iks_name(grp), "group") == 0) {
grp_no = add_node(-1, build_path(grp, NULL, NULL), N_GROUP);
for (obj = iks_first_tag(grp); obj; obj = iks_next_tag(obj)) {
if (iks_strcmp(iks_name(obj), "class") == 0) {
obj_no = add_node(grp_no, build_path(grp, obj, NULL), N_CLASS);
for (met = iks_first_tag(obj); met; met = iks_next_tag(met)) {
int no;
if (iks_strcmp(iks_name(met), "method") == 0) {
iks *arg;
char *prof;
no = add_node(obj_no, build_path(grp, obj, met), N_METHOD);
prof = iks_find_attrib(met, "access");
if (prof) {
if (strcmp(prof, "user") == 0)
nodes[no].level = ACL_USER;
if (strcmp(prof, "guest") == 0)
nodes[no].level = ACL_GUEST;
}
prof = iks_find_attrib(met, "profile");
if (prof) {
if (strcmp(prof, "global") == 0)
nodes[no].flags |= P_GLOBAL;
if (strcmp(prof, "package") == 0)
nodes[no].flags |= P_PACKAGE;
}
prof = iks_find_attrib(met, "profileOp");
if (prof) {
if (strcmp(prof, "delete") == 0)
nodes[no].flags |= P_DELETE;
if (strcmp(prof, "startup") == 0)
nodes[no].flags |= P_STARTUP;
}
for (arg = iks_first_tag(met); arg; arg = iks_next_tag(arg)) {
if (iks_strcmp(iks_name(arg), "instance") == 0) {
build_arg(no, 1, iks_cdata(iks_child(arg)));
}
}
for (arg = iks_first_tag(met); arg; arg = iks_next_tag(arg)) {
if (iks_strcmp(iks_name(arg), "argument") == 0) {
char *argname;
argname = iks_cdata(iks_child(arg));
if (argname) {
build_arg(no, 0, argname);
} else {
log_error("Argument name needed in <argument> tag of model.xml\n");
}
}
}
} else if (iks_strcmp(iks_name(met), "notify") == 0) {
no = add_node(obj_no, build_path(grp, obj, met), N_NOTIFY);
if (no >= model_max_notifications)
model_max_notifications = no + 1;
}
}
}
}
}
}
// no need to keep dom tree in memory
iks_delete(model);
return 0;
}
// 客户端解析服务器响应的协商包，从协商包中解析出临时密钥，并使用自己的私钥进行解密
// 服务器端解析客户端发来的协商包，并填充服务器包解析器
int pkg_talk_parse(packet_parser_t *pkg, const char* xml)
{
iks *x, *e, *c;
int result=0;
int dest_len;
if(NULL==xml) return NULL_ERROR;
x = iks_tree (xml, 0, &result);
if(!x) return NULL_ERROR;
if(result != IKS_OK)
{
iks_delete(x);
return IKS_BADXML;
}
if(0 == iks_strcmp("connection",iks_name(x)))
{
char* tmp = NULL;
char *tempkey;
char *output;
tmp = iks_find_attrib(x, "type");
if(NULL != tmp){
if(strcmp(tmp, "create")==0)
set_talk_type(1, pkg); //说明为服务端
else
set_talk_type(0, pkg); //说明为客户端
}
if(1 == pkg->talk_type)
{
//说明本端为服务端
tmp = iks_find_cdata(x, "client-id");
set_client_id(tmp, pkg);
tmp = iks_find_cdata(x, "public-key");
if(SUCCESS != set_talk_crt_public_key(tmp, pkg))
return SET_TALK_CRT_KEY_ERROR;
tmp = iks_find_attrib(iks_find(x,"public-key"), "type");
if(SUCCESS != set_talk_crt_type(tmp, pkg))
return SET_TALK_CRT_TYPE_ERROR;
e = iks_find(x,"encryption");
while( e ){
tmp = iks_find_cdata(e, "allow");
if(SUCCESS == set_transfer_crt_type(tmp, pkg)) break;
e = iks_next(e);
}
// 服务器端设置传输数据使用的临时密钥
set_transfer_crt_key(TRANSFERKEY, pkg);
c = iks_find(x,"compression");
while( c ){
tmp = iks_find_cdata(c, "allow");
if(SUCCESS == set_cps_type(tmp, pkg)) break;
c = iks_next(c);
}
}
else if(0 == pkg->talk_type)
{
// 说明本端为客户端
tempkey = iks_find_cdata(x,"encryption");
output = (char *)calloc(strlen(tempkey)/2+1, 1);
hex2byte(tempkey, strlen(tempkey), (unsigned char *)output);
if (pkg->asym_encrypt_hook == NULL)
{
tempkey = (char *)rsa_encrypt((unsigned char *)output, strlen(tempkey)/2, &dest_len, pkg->curr_ert.ert_keys[1], CRYPT_TYPE_DECRYPT);
}
else
{
tempkey = (char *)pkg->asym_encrypt_hook((unsigned char *)output, strlen(tempkey)/2, &dest_len, pkg->curr_ert.ert_keys[1], CRYPT_TYPE_DECRYPT);
}
free(output);
// 比较服务器端响应的压缩加密方式与客户端请求的是否相同
if( SUCCESS != set_transfer_crt_key(tempkey, pkg))
return SET_TRANSFER_ERT_KEY_ERROR;
free(tempkey);
if( SUCCESS != cmp_transfer_crt_type(iks_find_attrib(iks_find(x, "encryption"), "type"), pkg) )
return CMP_TRANSFER_CRT_TYPE_ERROR;
if( SUCCESS != cmp_cps_type(iks_find_cdata(x, "compression"), pkg) )
return CMP_CPS_TYPE_ERROR;
set_heatbeat("client", iks_find_attrib(iks_find(x, "heartbeat"), "seconds"), pkg);
}
}
//iks_parser_delete (p);
iks_delete(x);
return SUCCESS;
}
