int
_imp_oasis_load(ImpDoc *doc)
{
ImpPage *page;
iks *x, *pres;
int i;
pres = iks_find(iks_find(doc->content, "office:body"), "office:presentation");
if (!pres) return IMP_NOTIMP;
x = iks_find(pres, "draw:page");
if (!x) return IMP_NOTIMP;
i = 0;
for (; x; x = iks_next_tag(x)) {
if (strcmp(iks_name(x), "draw:page") == 0) {
page = iks_stack_alloc(doc->stack, sizeof(ImpPage));
if (!page) return IMP_NOMEM;
memset(page, 0, sizeof(ImpPage));
page->page = x;
page->nr = ++i;
page->name = iks_find_attrib(x, "draw:name");
page->doc = doc;
if (!doc->pages) doc->pages = page;
page->prev = doc->last_page;
if (doc->last_page) doc->last_page->next = page;
doc->last_page = page;
}
}
doc->nr_pages = i;
doc->get_geometry = get_geometry;
doc->render_page = render_page;
return 0;
}
// public API, inits stream instance; a particular namespace is to be
// used with Jabber, see the constant defined in the public header
//
// note that interestingly, the mainline version allocates both an
// iksparser and stream_data, but returns the parser rather than
// stream_data -- perhaps the idea is to provide the parsing interface
// regardless of what the data source is, just creating a different
// kind of parser
ikss_Stream *
ikss_Stream_new (char *name_space, void *user_data, iksStreamHook *streamHook, ikss_NotifyFunc* notifyFunc)
{
ikss_Stream *self;
ikstack *s;
s = iks_stack_new (DEFAULT_STREAM_CHUNK_SIZE, 0);
if (NULL == s) return NULL;
self = iks_stack_alloc (s, sizeof (ikss_Stream));
if (!self) {
iks_stack_delete(s);
return NULL;
}
memset (self, 0, sizeof (ikss_Stream));
self->s = s;
// This creates the parser, placing the object into "s" memory. Note
// that self->prs now takes ownership of "s", and iks_parser_delete
// will delete it.
self->prs = iks_sax_extend (s, self, (iksTagHook *)tagHook, (iksCDataHook *)cdataHook, (iksDeleteHook *)deleteHook);
if (!self->prs) {
iks_stack_delete(s);
return NULL;
}
self->name_space = name_space;
self->user_data = user_data;
self->streamHook = streamHook;
self->notifyFunc = notifyFunc;
return self;
}
iksparser *
iks_sax_extend (ikstack *s, void *user_data, iksTagHook *tagHook, iksCDataHook *cdataHook, iksDeleteHook *deleteHook)
{
iksparser *prs;
prs = iks_stack_alloc (s, sizeof (iksparser));
if (NULL == prs) return NULL;
memset (prs, 0, sizeof (iksparser));
prs->s = s;
prs->user_data = user_data;
prs->tagHook = tagHook;
prs->cdataHook = cdataHook;
prs->deleteHook = deleteHook;
return prs;
}
iksparser *
iks_stream_new (char *name_space, void *user_data, iksStreamHook *streamHook)
{
ikstack *s;
struct stream_data *data;
s = iks_stack_new (DEFAULT_STREAM_CHUNK_SIZE, 0);
if (NULL == s) return NULL;
data = iks_stack_alloc (s, sizeof (struct stream_data));
memset (data, 0, sizeof (struct stream_data));
data->s = s;
data->prs = iks_sax_extend (s, data, (iksTagHook *)tagHook, (iksCDataHook *)cdataHook, (iksDeleteHook *)deleteHook);
data->name_space = name_space;
data->user_data = user_data;
data->streamHook = streamHook;
return data->prs;
}
iks *
iks_new_within (const char *name, ikstack *s)
{
iks *x;
size_t len;
if (name) len = sizeof (struct iks_tag); else len = sizeof (struct iks_cdata);
x = iks_stack_alloc (s, len);
if (!x) return NULL;
memset (x, 0, len);
x->s = s;
x->type = IKS_TAG;
if (name) {
IKS_TAG_NAME (x) = iks_stack_strdup (s, name, 0);
if (!IKS_TAG_NAME (x)) return NULL;
}
return x;
}
char *
iks_unescape (ikstack *s, char *src, size_t len)
{
int i,j;
char *ret;
if (!s || !src) return NULL;
if (!strchr (src, '&')) return src;
if (len == -1) len = strlen (src);
ret = iks_stack_alloc (s, len + 1);
if (!ret) return NULL;
for (i=j=0; i<len; i++) {
if (src[i] == '&') {
i++;
if (strncmp (&src[i], "amp;", 4) == 0) {
ret[j] = '&';
i += 3;
} else if (strncmp (&src[i], "quot;", 5) == 0) {
ret[j] = '"';
i += 4;
} else if (strncmp (&src[i], "apos;", 5) == 0) {
ret[j] = '\'';
i += 4;
} else if (strncmp (&src[i], "lt;", 3) == 0) {
ret[j] = '<';
i += 2;
} else if (strncmp (&src[i], "gt;", 3) == 0) {
ret[j] = '>';
i += 2;
} else {
ret[j] = src[--i];
}
} else {
ret[j] = src[i];
}
j++;
}
ret[j] = '\0';
return ret;
}
iks *
iks_insert_attrib (iks *x, const char *name, const char *value)
{
iks *y;
if (!x) return NULL;
y = IKS_TAG_ATTRIBS (x);
while (y) {
if (strcmp (name, IKS_ATTRIB_NAME (y)) == 0) break;
y = y->next;
}
if (NULL == y) {
if (!value) return NULL;
y = iks_stack_alloc (x->s, sizeof (struct iks_attrib));
if (!y) return NULL;
memset (y, 0, sizeof (struct iks_attrib));
y->type = IKS_ATTRIBUTE;
y->s = x->s;
IKS_ATTRIB_NAME (y) = iks_stack_strdup (x->s, name, 0);
if (!IKS_ATTRIB_NAME (y)) return NULL;
y->parent = x;
if (!IKS_TAG_ATTRIBS (x)) IKS_TAG_ATTRIBS (x) = y;
if (IKS_TAG_LAST_ATTRIB (x)) {
IKS_TAG_LAST_ATTRIB (x)->next = y;
y->prev = IKS_TAG_LAST_ATTRIB (x);
}
IKS_TAG_LAST_ATTRIB (x) = y;
}
if (value) {
IKS_ATTRIB_VALUE (y) = iks_stack_strdup (x->s, value, 0);
if (!IKS_ATTRIB_VALUE (y)) return NULL;
} else {
if (y->next) y->next->prev = y->prev;
if (y->prev) y->prev->next = y->next;
if (IKS_TAG_ATTRIBS (x) == y) IKS_TAG_ATTRIBS (x) = y->next;
if (IKS_TAG_LAST_ATTRIB (x) == y) IKS_TAG_LAST_ATTRIB (x) = y->prev;
}
return y;
}
int iks_connect_fd(iksparser *prs, int fd)
{
#ifdef USE_DEFAULT_IO
struct stream_data *data = iks_user_data(prs);
if(!data->buf)
{
data->buf = iks_stack_alloc(data->s, NET_IO_BUF_SIZE);
if(NULL == data->buf) return IKS_NOMEM;
}
data->sock = (void *) fd;
data->flags |= SF_FOREIGN;
data->trans = &iks_default_transport;
return IKS_OK;
#else
return IKS_NET_NOTSUPP;
#endif
}
int iks_connect_with(iksparser *prs, const char *server, int port, const char *server_name, ikstransport *trans)
{
struct stream_data *data = iks_user_data(prs);
int ret;
if(!trans->connect) return IKS_NET_NOTSUPP;
if(!data->buf)
{
data->buf = iks_stack_alloc(data->s, NET_IO_BUF_SIZE);
if(NULL == data->buf) return IKS_NOMEM;
}
ret = trans->connect(prs, &data->sock, server, port);
if(ret) return ret;
data->trans = trans;
return iks_send_header(prs, server_name);
}
iksid *
iks_id_new (ikstack *s, const char *jid)
{
iksid *id;
char *src, *tmp;
/* FIXME: add jabber id validity checks to this function */
/* which characters are allowed in id parts? */
if (!jid) return NULL;
id = iks_stack_alloc (s, sizeof (iksid));
if (!id) return NULL;
memset (id, 0, sizeof (iksid));
/* skip scheme */
if (strncmp ("jabber:", jid, 7) == 0) jid += 7;
id->full = iks_stack_strdup (s, jid, 0);
src = id->full;
/* split resource */
tmp = strchr (src, '/');
if (tmp) {
id->partial = iks_stack_strdup (s, src, tmp - src);
id->resource = tmp + 1;
src = id->partial;
} else {
id->partial = src;
}
/* split user */
tmp = strchr (src, '@');
if (tmp) {
id->user = iks_stack_strdup (s, src, tmp - src);
src = ++tmp;
}
id->server = src;
return id;
}
int iks_connect_async_with(iksparser *prs, const char *server, int port, const char *server_name, ikstransport *trans, void *notify_data, iksAsyncNotify *notify_func)
{
struct stream_data *data = iks_user_data(prs);
int ret;
if(NULL == trans->connect_async)
return IKS_NET_NOTSUPP;
if(!data->buf)
{
data->buf = iks_stack_alloc(data->s, NET_IO_BUF_SIZE);
if(NULL == data->buf) return IKS_NOMEM;
}
ret = trans->connect_async(prs, &data->sock, server, server_name, port, notify_data, notify_func);
if(ret) return ret;
data->trans = trans;
data->server = server_name;
return IKS_OK;
}
char *
iks_escape (ikstack *s, char *src, size_t len)
{
char *ret;
int i, j, nlen;
if (!src || !s) return NULL;
if (len == -1) len = strlen (src);
nlen = len;
for (i=0; i<len; i++) {
switch (src[i]) {
case '&': nlen += 4; break;
case '<': nlen += 3; break;
case '>': nlen += 3; break;
case '\'': nlen += 5; break;
case '"': nlen += 5; break;
}
}
if (len == nlen) return src;
ret = iks_stack_alloc (s, nlen + 1);
if (!ret) return NULL;
for (i=j=0; i<len; i++) {
switch (src[i]) {
case '&': memcpy (&ret[j], "&", 5); j += 5; break;
case '\'': memcpy (&ret[j], "'", 6); j += 6; break;
case '"': memcpy (&ret[j], """, 6); j += 6; break;
case '<': memcpy (&ret[j], "<", 4); j += 4; break;
case '>': memcpy (&ret[j], ">", 4); j += 4; break;
default: ret[j++] = src[i];
}
}
ret[j] = '\0';
return ret;
}
int
ikss_Stream_connect (ikss_Stream *self, const char *server, int port, int iapId)
{
int ret;
if (!self->recv_buf) {
self->recv_buf = iks_stack_alloc (self->s, NET_IO_BUF_SIZE);
if (NULL == self->recv_buf) return IKS_NOMEM;
}
// asynchronous, so does not complete immediately; self->sock
// however gets set here or not, right away, so that we will
// know if something is outstanding, and have a way of
// cancelling that something
ret = ikst_Connect (&self->sock,
server, port, iapId,
self, transportCallback);
if (ret) return ret;
self->server = server;
return IKS_OK;
}
void * Stack::allocStack( Stack *stack, size_t size )
{
return iks_stack_alloc( stack->stack, size);
}
// Note that "s" may be NULL, in which case strings are not allocated
// from the stack, and in which case the caller is responsible for
// freeing any returned string.
char *
iks_string (ikstack *s, iks *x)
{
size_t size;
int level, dir;
iks *y, *z;
char *ret, *t;
if (!x) return NULL;
if (x->type == IKS_CDATA) {
if (s) {
return iks_stack_strdup (s, IKS_CDATA_CDATA (x), IKS_CDATA_LEN (x));
} else {
ret = iks_malloc (IKS_CDATA_LEN (x));
memcpy (ret, IKS_CDATA_CDATA (x), IKS_CDATA_LEN (x));
return ret;
}
}
size = 0;
level = 0;
dir = 0;
y = x;
while (1) {
if (dir==0) {
if (y->type == IKS_TAG) {
size++;
size += strlen (IKS_TAG_NAME (y));
for (z = IKS_TAG_ATTRIBS (y); z; z = z->next) {
size += 4 + strlen (IKS_ATTRIB_NAME (z))
+ escape_size (IKS_ATTRIB_VALUE (z), strlen (IKS_ATTRIB_VALUE (z)));
}
if (IKS_TAG_CHILDREN (y)) {
size++;
y = IKS_TAG_CHILDREN (y);
level++;
continue;
} else {
size += 2;
}
} else {
size += escape_size (IKS_CDATA_CDATA (y), IKS_CDATA_LEN (y));
}
}
z = y->next;
if (z) {
if (0 == level) {
if (IKS_TAG_CHILDREN (y)) size += 3 + strlen (IKS_TAG_NAME (y));
break;
}
y = z;
dir = 0;
} else {
y = y->parent;
level--;
if (level >= 0) size += 3 + strlen (IKS_TAG_NAME (y));
if (level < 1) break;
dir = 1;
}
}
if (s) ret = iks_stack_alloc (s, size + 1);
else ret = iks_malloc (size + 1);
if (!ret) return NULL;
t = ret;
level = 0;
dir = 0;
while (1) {
if (dir==0) {
if (x->type == IKS_TAG) {
*t++ = '<';
t = my_strcat (t, IKS_TAG_NAME (x), 0);
y = IKS_TAG_ATTRIBS (x);
while (y) {
*t++ = ' ';
t = my_strcat (t, IKS_ATTRIB_NAME (y), 0);
*t++ = '=';
*t++ = '\'';
t = escape (t, IKS_ATTRIB_VALUE (y), strlen (IKS_ATTRIB_VALUE (y)));
*t++ = '\'';
y = y->next;
}
if (IKS_TAG_CHILDREN (x)) {
*t++ = '>';
x = IKS_TAG_CHILDREN (x);
level++;
continue;
} else {
*t++ = '/';
*t++ = '>';
}
} else {
t = escape (t, IKS_CDATA_CDATA (x), IKS_CDATA_LEN (x));
}
}
y = x->next;
if (y) {
if (0 == level) {
if (IKS_TAG_CHILDREN (x)) {
*t++ = '<';
*t++ = '/';
t = my_strcat (t, IKS_TAG_NAME (x), 0);
*t++ = '>';
}
break;
}
x = y;
dir = 0;
} else {
x = x->parent;
level--;
if (level >= 0) {
*t++ = '<';
*t++ = '/';
t = my_strcat (t, IKS_TAG_NAME (x), 0);
*t++ = '>';
}
if (level < 1) break;
dir = 1;
}
}
*t = '\0';
return ret;
}
ikspak *
iks_packet (iks *x)
{
ikspak *pak;
ikstack *s;
char *tmp;
s = iks_stack (x);
pak = iks_stack_alloc (s, sizeof (ikspak));
if (!pak) return NULL;
memset (pak, 0, sizeof (ikspak));
pak->x = x;
tmp = iks_find_attrib (x, "from");
if (tmp) pak->from = iks_id_new (s, tmp);
pak->id = iks_find_attrib (x, "id");
tmp = iks_find_attrib (x, "type");
if (strcmp (iks_name (x), "message") == 0) {
pak->type = IKS_PAK_MESSAGE;
if (tmp) {
if (strcmp (tmp, "chat") == 0)
pak->subtype = IKS_TYPE_CHAT;
else if (strcmp (tmp, "groupchat") == 0)
pak->subtype = IKS_TYPE_GROUPCHAT;
else if (strcmp (tmp, "headline") == 0)
pak->subtype = IKS_TYPE_HEADLINE;
else if (strcmp (tmp, "error") == 0)
pak->subtype = IKS_TYPE_ERROR;
}
} else if (strcmp (iks_name (x), "presence") == 0) {
pak->type = IKS_PAK_S10N;
if (tmp) {
if (strcmp (tmp, "unavailable") == 0) {
pak->type = IKS_PAK_PRESENCE;
pak->subtype = IKS_TYPE_UNAVAILABLE;
pak->show = IKS_SHOW_UNAVAILABLE;
} else if (strcmp (tmp, "probe") == 0) {
pak->type = IKS_PAK_PRESENCE;
pak->subtype = IKS_TYPE_PROBE;
} else if(strcmp(tmp, "subscribe") == 0)
pak->subtype = IKS_TYPE_SUBSCRIBE;
else if(strcmp(tmp, "subscribed") == 0)
pak->subtype = IKS_TYPE_SUBSCRIBED;
else if(strcmp(tmp, "unsubscribe") == 0)
pak->subtype = IKS_TYPE_UNSUBSCRIBE;
else if(strcmp(tmp, "unsubscribed") == 0)
pak->subtype = IKS_TYPE_UNSUBSCRIBED;
else if(strcmp(tmp, "error") == 0)
pak->subtype = IKS_TYPE_ERROR;
} else {
pak->type = IKS_PAK_PRESENCE;
pak->subtype = IKS_TYPE_AVAILABLE;
tmp = iks_find_cdata (x, "show");
pak->show = IKS_SHOW_AVAILABLE;
if (tmp) {
if (strcmp (tmp, "chat") == 0)
pak->show = IKS_SHOW_CHAT;
else if (strcmp (tmp, "away") == 0)
pak->show = IKS_SHOW_AWAY;
else if (strcmp (tmp, "xa") == 0)
pak->show = IKS_SHOW_XA;
else if (strcmp (tmp, "dnd") == 0)
pak->show = IKS_SHOW_DND;
}
}
} else if (strcmp (iks_name (x), "iq") == 0) {
iks *q;
pak->type = IKS_PAK_IQ;
if (tmp) {
if (strcmp (tmp, "get") == 0)
pak->subtype = IKS_TYPE_GET;
else if (strcmp (tmp, "set") == 0)
pak->subtype = IKS_TYPE_SET;
else if (strcmp (tmp, "result") == 0)
pak->subtype = IKS_TYPE_RESULT;
else if (strcmp (tmp, "error") == 0)
pak->subtype = IKS_TYPE_ERROR;
}
for (q = iks_child (x); q; q = iks_next (q)) {
if (IKS_TAG == iks_type (q)) {
char *ns;
ns = iks_find_attrib (q, "xmlns");
if (ns) {
pak->query = q;
pak->ns = ns;
break;
}
}
}
}
return pak;
}
