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; }