From 8f05f2d6f45b60f65420376f127f49fa2d1a7bd1 Mon Sep 17 00:00:00 2001 From: Michael Jerris Date: Mon, 8 Jun 2009 16:33:59 +0000 Subject: [PATCH] remove generated file git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@13673 d0543943-73ff-0310-b7d9-9358b9ac24b2 --- libs/iksemel/doc/iksemel | 1627 -------------------------------------- 1 file changed, 1627 deletions(-) delete mode 100644 libs/iksemel/doc/iksemel diff --git a/libs/iksemel/doc/iksemel b/libs/iksemel/doc/iksemel deleted file mode 100644 index 31843b972e..0000000000 --- a/libs/iksemel/doc/iksemel +++ /dev/null @@ -1,1627 +0,0 @@ -Bu iksemel, makeinfo sürümü 4.8 tarafından, ./iksemel.texi'den -üretilmiştir. - - -File: iksemel, Node: Top, Up: (dir) - -iksemel Programmers Manual -************************** - -Copyright (C) 2001-2003 Gu"rer O"zen - - This is a free document; you can redistribute it and/or modify it -under the terms of the GNU General Public License as published by the -Free Software Foundation; either version 2, or (at your option) any -later version.You may obtain a copy of the GNU General Public License -from the Free Software Foundation by visiting their Web site or by -writing to the Free Software Foundation, Inc., 59 Temple Place - Suite -330, Boston, MA 02111-1307, USA. - -* Menu: - -* Introduction:: - -* Tutorials:: - -* Development:: - -* Datatype Index:: - -* Function Index:: - - -File: iksemel, Node: Introduction, Next: Tutorials, Up: Top - -1 Introduction -************** - -iksemel is an XML (eXtensible Markup Language) parser library designed -for Jabber applications. It is coded in ANSI C for POSIX compatible -environments, thus highly portable. It is free software released under -the GNU Lesser General Public License. - - The purprose of this manual is to tell you how to use the facilities -of the iksemel library. Manual is written with the assumption that you -are familiar with the C programming language, basic programming -concepts, XML and Jabber protocol. - -1.1 Compiling the Library -========================= - -You need to install MinGW (`http://mingw.org') under Windows to be able -to compile iksemel. Although not tested by the author, Cygwin should -work equally well. - - Library can be built with: - - ./configure - make - - If you want to make a self test: - - make test - - Now you can install it with: - - make install - -1.2 Using iksemel in Applications -================================= - -You need to include `iksemel.h' file in your source to access library -API. You can do this with: - - `#include "iksemel.h"' - - Now you can use iksemel functions and compile your source. In able -to link your compiled object files and generate your executable -program, you have to link with iksemel library. This can be done with: - - gcc -o myprg src1.o src2.o src3.o -liksemel - - iksemel registers itself with pkg-config while installing, so if you -are using autotools in your program, you can simply check the -availability of iksemel and configure your build process accordingly -with: - - PKG_CHECK_MODULES(IKSEMEL,iksemel,,exit) - - This would result in IKSEMEL_LIBS and IKSEMEL_CFLAGS substitution -variables set to correct values. - - -File: iksemel, Node: Tutorials, Next: Development, Prev: Introduction, Up: Top - -2 Tutorials -*********** - -* Menu: - -* Parsing an XML Document:: - -* Working with XML Trees:: - -* XML Streams:: - -* Writing a Jabber Client:: - -* Utility Functions:: - - -File: iksemel, Node: Parsing an XML Document, Next: Working with XML Trees, Up: Tutorials - -2.1 Parsing an XML Document -=========================== - -iksemel parser sequentally processes the XML document. Each encountered -XML element (i.e. tags, character data, comments, processing -instructions, etc.) is reported to your application by calling the -hook functions you have provided. This type of interface is called SAX -(serial access) interface. - - Parser stores its state in a small structure. This structure is -referenced by `iksparser' type, and managed with following functions: - - -- İşlev: iksparser* iks_sax_new (void* USER_DATA, iksTagHook* - TAGHOOK, iksCDataHook* CDATAHOOK); - This function allocates and initializes a parser structure. If - allocation fails, NULL value is returned. USER_DATA is passed - directly to hook functions. - - -- Typedef: iksTagHook - int iksTagHook (void* USER_DATA, char* NAME, char** ATTS, int - TYPE); - - This function is called when a tag parsed. NAME is the name of the - tag. If tag has no attributes ATTS is NULL, otherwise it contains - a null terminated list of pointers to tag's attributes and their - values. If return value isn't `IKS_OK', it is passed immediately - to the caller of the `iks_parse'. - - TYPE is one of the following: - `IKS_OPEN' - Opening tag, i.e. - - `IKS_CLOSE' - Closing tag, i.e. - - `IKS_SINGLE' - Standalone tag, i.e. - - -- Typedef: iksCDataHook - int iksCDataHook (void* USER_DATA, char* DATA, size_t LEN); - - DATA is a pointer to the character data. Encoding is UTF-8 and it - isn't terminated with a null character. Size of the data is given - with LEN in bytes. This function can be called several times with - smaller sized data for a single string. If return value isn't - `IKS_OK', it is passed immediately to the caller of the - `iks_parse'. - - -- İşlev: int iks_parse (iksparser* PRS, char *DATA, size_t LEN, int - FiNiSH); - You give XML document to the parser with this function. DATA is a - LEN bytes string. If LEN is zero, data must be a null terminated - string. - - If FiNiSH value is zero, parser waits for more data later. If you - want to finish parsing without giving data, call it like: - iks_parse (my_parser, NULL, 0, 1); - - You should check the return value for following conditions: - `IKS_OK' - There isn't any problem. - - `IKS_NOMEM' - Not enough memory. - - `IKS_BADXML' - Document is not well-formed. - - `IKS_HOOK' - Your hook decided that there is an error. - - -- İşlev: void iks_parser_delete (iksparser* PRS); - This function frees parser structure and associated data. - - Now we have learned how to create and use a sax parser. Lets parse a -simple XML document. Write following code into a `test.c' file. - - #include - #include - - int pr_tag (void *udata, char *name, char **atts, int type) - { - switch (type) { - case IKS_OPEN: - printf ("TAG <%s>\n", name); - break; - case IKS_CLOSE: - printf ("TAG \n", name); - break; - case IKS_SINGLE: - printf ("TAG <%s/>\n", name); - break; - } - if (atts) { - int i = 0; - while (atts[i]) { - printf (" ATTRIB %s='%s'\n", atts[i], atts[i+1]); - i += 2; - } - } - return IKS_OK; - } - - enum ikserror pr_cdata (void *udata, char *data, size_t len) - { - int i; - printf ("CDATA ["); - for (i = 0; i < len; i++) - putchar (data[i]); - printf ("]\n"); - return IKS_OK; - } - - int main (int argc, char *argv[]) - { - iksparser *p; - p = iks_sax_new (NULL, pr_tag, pr_cdata); - switch (iks_parse (p, argv[1], 0, 1)) { - case IKS_OK: - puts ("OK"); - break; - case IKS_NOMEM: - puts ("Not enough memory"); - exit (1); - case IKS_BADXML: - puts ("XML document is not well-formed"); - exit (2); - case IKS_HOOK: - puts ("Our hooks didn't like something"); - exit (2); - } - iks_parser_delete (p); - return 0; - } - - Now compile and test it with: - - gcc -o test test.c -liksemel - ./test "Hello
World!" - ./test "" - -Error Handling -============== - -XML standart states that once an error is detected, the processor must -not continue normal processing (i.e. it must not pass character data or -markup information to the application). So iksemel stops processing -immediately when it encounters a syntax error, or one of your hook -functions return any one value than `IKS_OK', and `iks_parse' function -returns with the error code. - - Since it is useful for debugging, iksemel provides functions to get -position of the error. Position is usually at the starting character -for syntax errors. Since your hooks are called after whole element -(i.e. markup or character data) is passed, position is at the end of -the erroneous element for `IKS_HOOK' errors. - - -- İşlev: unsigned long iks_nr_bytes (iksparser* PRS); - Returns how many number of bytes parsed. - - -- İşlev: unsigned long iks_nr_lines (iksparser* PRS); - Returns how many number of lines parsed. - - If you want to parse another document with your parser again, you -should use the following function to reset your parser. - - -- İşlev: void iks_parser_reset (iksparser* PRS); - Resets the parser's internal state. - - -File: iksemel, Node: Working with XML Trees, Next: XML Streams, Prev: Parsing an XML Document, Up: Tutorials - -2.2 Working with XML Trees -========================== - -SAX interface uses very little memory, but it forces you to access XML -documents sequentally. In many cases you want to keep a tree like -representation of XML document in memory and want to access and modify -its content randomly. - - iksemel provides functions for efficiently creating such trees either -from documents or programmaticaly. You can access and modify this tree -and can easily generate a new XML document from the tree. - - This is called DOM (Document Object Model) interface. - -* Menu: - -* Memory Management:: - -* Creating a Tree:: - -* Accessing the Tree:: - -* Converting a Tree into an XML Document:: - -* Parsing an XML Document into a Tree:: - - -File: iksemel, Node: Memory Management, Next: Creating a Tree, Up: Working with XML Trees - -2.2.1 Memory Management ------------------------ - -Since keeping whole document content uses a lot of memory and requires -many calls to OS's memory allocation layer, iksemel uses a simple object -stack system for minimizing calls to the `malloc' function and releasing -all the memory associated with a tree in a single step. - - A parsed XML tree contains following objects: -`Nodes' - These are basic blocks of document. They can contain a tag, - attribute pair of a tag, or character data. Tag nodes can also - contain other nodes as children. Node structure has a small fixed - size depending on the node type. - -`Names' - Names of tags and attributes. They are utf-8 encoded small strings. - -`Character Data' - They are similar to names but usually much bigger. - - iksemel's object stack has two separate areas for keeping these data -objects. Meta chunk contains all the structures and aligned data, -while the data chunk contains strings. Each chunk starts with a choosen -size memory block, then when necessary more blocks allocated for -providing space. Unless there is a big request, each block is double -the size of the previous block, thus real memory needs are quickly -reached without allocating too many blocks, or wasting memory with too -big blocks. - - -- Typedef: ikstack - This is a structure defining the object stack. Its fields are - private and subject to change with new iksemel releases. - - -- İşlev: ikstack * iks_stack_new (size_t META_CHUNK, size_t - DATA_CHUNK); - Creates an object stack. META_CHUNK is the initial size of the - data block used for structures and aligned data. DATA_CHUNK is the - initial size of the data block used for strings. They are both in - byte units. - - These two initial chunks and a small object stack structure is - allocated in one `malloc' call for optimization purproses. - - -- İşlev: void * iks_stack_alloc (ikstack * STACK, size_t SiZE); - Allocates SiZE bytes of space from the object stack's meta chunk. - Allocated space is aligned on platform's default alignment - boundary and isn't initialized. Returns a pointer to the space, or - NULL if there isn't enough space available and allocating a new - block fails. - - -- İşlev: void * iks_stack_strdup (ikstack * STACK, const char * - SRC, size_t LEN); - Copies given string SRC into the object stack's data chunk. - Returns a pointer to the new string, or NULL if there isn't enough - space in the stack. If LEN is zero string must be null terminated. - - -- İşlev: void iks_stack_delete (ikstack * STACK); - Gives all memory associated with object stack to the system. - - Since character data sections are usually parsed in separate blocks, -a growable string implementation is necessary for saving memory. - - -- İşlev: char * iks_stack_strcat (ikstack *STACK, char *OLD, size_t - OLD_LEN, const char *SRC, size_t SRC_LEN); - This function appends the string SRC to the string OLD in the - stack's data chunk. If OLD is NULL it behaves like - `iks_stack_strdup'. Otherwise OLD has to be a string created with - `iks_stack_strdup' or `iks_stack_strcat' functions. - - If OLD_LEN or SRC_LEN is zero, corresponding string must be null - terminated. - - Since string can be moved into another block of the data chunk, - you must use the returned value for new string, and must not - reference to OLD anymore. Return value can be NULL if there isn't - enough space in stack, and allocating a new block fails. - - -File: iksemel, Node: Creating a Tree, Next: Accessing the Tree, Prev: Memory Management, Up: Working with XML Trees - -2.2.2 Creating a Tree ---------------------- - - -- Typedef: iks - This is a structure defining a XML node. Its fields are private - and only accessed by following functions. - - -- İşlev: iks* iks_new (const char *NAME); - Creates an object stack and creates a IKS_TAG type of node with - given tag name inside the stack. Tag name is also copied into the - stack. Returns the node pointer, or NULL if there isn't enough - memory. - - -- İşlev: iks* iks_new_within (const char *NAME, ikstack* STACK); - Creates a IKS_TAG type of node with the given tag name. Node and - tag name is allocated inside the given object stack. Returns the - node pointer, or NULL if there isn't enough memory. - - -- İşlev: iks* iks_insert (iks *X, const char *NAME); - Creates a IKS_TAG type of node with the given tag name. Node and - tag name is allocated inside the X node's object stack and linked - to X as a child node. Returns the node pointer, or NULL if there - isn't enough memory. - - -- İşlev: iks* iks_insert_cdata (iks* X, const char* DATA, size_t - LEN); - Creates a IKS_CDATA type of node with given character data. Node is - allocated inside the X node's object stack and linked to X as a - child node. Data is copied as well. If LEN is zero data must be a - null terminated string. Returns the node pointer, or NULL if there - isn't enough memory. - - -- İşlev: iks* iks_insert_attrib (iks* X, const char* NAME, const - char* VALUE); - Creates a IKS_ATTRIBUTE type of node with given attribute name and - the value. Node is allocated inside the X node's object stack and - linked to X as an attribute node. Attribute name and value is - copied as well. Returns the node pointer, or NULL if there isn't - enough memory. - - Reinserting another value with same attribute name changes an - attribute's value. If VALUE is NULL, attribute is removed from the - tag. - - -- İşlev: iks* iks_insert_node (iks* X, iks* Y); - Links node Y to node X as a child node. Nodes are not copied - between object stacks, be careful. - - -- İşlev: void iks_hide (iks *X); - Changes the links of the other nodes so that X becomes invisible. - It stays in the same object stack with neighbour nodes, be careful. - - -- İşlev: void iks_delete (iks *X); - Frees the object stack of the node X. - - Now lets create a tree representation of following XML document: - - - song lyrichigh - - here is the correct version: - i just don't see why i should even care - it's not dark yet, but it's getting there - - - - here is the code: - - iks *x, *y, *z; - - x = iks_new ("message"); - iks_insert_attrib (x, "type", "chat"); - iks_insert_attrib (x, "from", "bob@bd.com"); - iks_insert_cdata (x, "\n", 1); - iks_insert_cdata (iks_insert (x, "subject"), "song lyric", 10); - iks_insert_cdata (iks_insert (x, "priority"), "high", 4); - iks_insert_cdata (x, "\n", 1); - y = iks_insert (x, "body"); - iks_insert_cdata (y, "\n", 1); - z = iks_insert (y, "em"); - iks_insert_attrib (z, "style", "underline"); - iks_insert_cdata (z, "here is the correct version", 0); - iks_insert_cdata (y, "\n", 1); - iks_insert_cdata (y, "i just don't see why", 0); - iks_insert_cdata (y, "i should even care\n", 0); - iks_insert_cdata (y, "it's not dark yet,", 0); - iks_insert_cdata (y, "but it's getting there\n", 0); - iks_insert_cdata (x, "\n", 1); - - Notice how newlines are inserted for proper formatting of document. -They aren't necessary for representing data, but they make it easier to -read document for humans. - - Also notice how `iks_insert' and `iks_insert_cdata' chained. - - There are also functions for duplicating xml trees. They are: - - -- İşlev: iks * iks_copy (iks* X); - Creates a full copy of the tree in a newly created object stack. - - -- İşlev: iks * iks_copy_within (iks* X, ikstack *S); - Creates a full copy of the tree in given object stack. - - -File: iksemel, Node: Accessing the Tree, Next: Converting a Tree into an XML Document, Prev: Creating a Tree, Up: Working with XML Trees - -2.2.3 Accessing a Tree ----------------------- - -Basic access functions allow you to move on the tree: - - -- İşlev: iks* iks_next (iks* X); - - -- İşlev: iks* iks_prev (iks* X); - - -- İşlev: iks* iks_parent (iks* X); - - -- İşlev: iks* iks_child (iks* X); - - -- İşlev: iks* iks_attrib (iks* X); - - These functions return a pointer to the next, previous, parent, -first child, and first attribute node of the given node X. If that node -doesn't exist or X is NULL, a NULL value is returned. - - -- İşlev: iks * iks_root (iks *X); - Returns the topmost parent node of the X. - - -- İşlev: iks* iks_next_tag (iks* X); - - -- İşlev: iks* iks_prev_tag (iks* X); - - -- İşlev: iks* iks_first_tag (iks* X); - - These functions return a pointer to the next, previous, first child -node of the given node X. Only tag nodes are considered, other type of -the nodes are skipped. If such a node doesn't exist or X is NULL, a -NULL value is returned. - - Another group of functions allow you to access specific information -and content of the nodes: - - -- İşlev: ikstack* iks_stack (iks* X); - Returns the object stack which node X stays. - - -- İşlev: enum ikstype iks_type (iks* X); - Returns the type of the node. - - `IKS_TAG' - Node is a tag and can contain child nodes and attributes. - - `IKS_CDATA' - Node contains character data. - - `IKS_ATTRIBUTE' - Node contains an attribute and its value. - - -- İşlev: char* iks_name (iks* X); - Returns the name of the tag for nodes with the type IKS_TAG. - Returns an attribute's name for nodes of type IKS_ATTRIBUTE. - - -- İşlev: char* iks_cdata (iks* X); - Returns a pointer to node's character data if available, NULL - otherwise. Returns an attribute's value for nodes of type - IKS_ATTRIBUTE. - - -- İşlev: size_t iks_cdata_size (iks *X); - Returns the size of the node's character data in bytes. - - -- İşlev: int iks_has_children (iks *X); - Returns a non-zero value if node X has a child node. - - -- İşlev: int iks_has_attribs (iks *X); - Returns a non-zero value if node X has attributes. - - Last group of the functions simplifies finding and accessing the -content of a specific node: - - -- İşlev: iks* iks_find (iks *X, const char *NAME); - Searches a IKS_TAG type of node with NAME as tag name in child - nodes of X. Returns a pointer to the node if found, NULL otherwise. - - -- İşlev: char* iks_find_cdata (iks* X, const char* NAME); - Searches a IKS_TAG type of node with NAME as tag name in child - nodes of X. Returns a pointer to the character data of the node's - first child node if found, NULL otherwise. - - -- İşlev: char* iks_find_attrib (iks* X, const char* NAME); - Searches an attribute with given name in attributes of the X. - Returns a pointer to attribute value if found, NULL otherwise. - - -- İşlev: iks * iks_find_with_attrib (iks *X, const char *TAGNAME, - const char *ATTRNAME, const char *VALUE); - Searches for a child tag of X which has an attribute with name - ATTRNAME and value VALUE. If TAGNAME isn't NULL, name of the tag - must also match. Returns a pointer to the node if found, NULL - otherwise. - - Here is an example which demonstrates accessing file names in a -fictitious XML playlist file: - - - - /home/madcat/download/matrix_rev_trailer.mpg - 1:17 - - - /home/madcat/anim/clementine_ep1.rm - 22:00 - - - /home/madcat/anim/futurama/ep101.avi - /home/madcat/subs/futurama/ep101.txt - 30:00 - - - - - - - and here is the code: - - #include - #include - - int main (int argc, char *argv[]) - { - iks *x, *y; - int e; - - if (argc < 2) { - printf ("usage: %s ", argv[0]); - return 0; - } - e = iks_load (argv[1], &x); - if (e != IKS_OK) { - printf ("parse error %d\n", e); - return 1; - } - if (iks_find (x, "repeat")) puts ("repeat mode enabled"); - y = iks_child (x); - while (y) { - if (iks_type (y) == IKS_TAG - && strcmp (iks_name (y), "item") == 0) { - printf ("Filename: [%s]\n", iks_find_cdata (y, "name")); - } - y = iks_next (y); - } - iks_delete (x); - return 0; - } - - -File: iksemel, Node: Converting a Tree into an XML Document, Next: Parsing an XML Document into a Tree, Prev: Accessing the Tree, Up: Working with XML Trees - -2.2.4 Converting a Tree to an XML Document ------------------------------------------- - -There is a function for converting given XML tree into a null -terminated string. - - -- İşlev: char * iks_string (ikstack* STACK, iks* X); - Converts given tree into a string. String is created inside the - given object stack. Returns a pointer to the string, or NULL if - there isn't enough memory available. - - If STACK is NULL, string is created inside an `iks_malloc'ed - buffer. You can free it later with `iks_free' function. - - Here is an example which builds a tree and print it. - - iks *x; - char *t; - - x = iks_new ("test"); - iks_insert_cdata (iks_insert (x, "a"), "1234", 4); - iks_insert (x, "br"); - iks_insert_cdata (x, "1234", 4); - t = iks_string (iks_stack (x), x); - puts (t); - iks_delete (x); - - -File: iksemel, Node: Parsing an XML Document into a Tree, Prev: Converting a Tree into an XML Document, Up: Working with XML Trees - -2.2.5 Parsing a Document into a Tree ------------------------------------- - -If you want to automatically convert an XML document into a tree, you -can use iksemel's DOM parser. It is created with following function: - - -- İşlev: iksparser* iks_dom_new (iks **iKSPTR); - Creates a DOM parser. A pointer to the created XML tree is put - into the variable pointed by iKSPTR. Returns a pointer to the - parser, or NULL is there isn't enough memory. - - Usage is same as SAX parser. You feed the data with `iks_parse', and -if there isn't an error, you can access to your tree from variable -`*iksptr'. - - Here is a simple example: - - iks *x; - iksparser *p; - - p = iks_dom_new (&x); - if (IKS_OK != iks_parse (p, "bcd", 9, 1)) { - puts ("parse error"); - } - /* x is useable after that point */ - - /* this will print 'bcd' */ - printf ("%s\n", iks_cdata (iks_child (x))); - - If you know the size of the file ahead, or you have an approximate -idea, you can tell this to the dom parser for choosing a better memory -allocation strategy. Here is the function for this. - - -- İşlev: void iks_set_size_hint (iksparser *PRS, size_t - APPROX_SiZE); - Parser PRS must be a dom type parser. APPROX_SiZE is the expected - size of the xml document. Parser chooses its chunk size based on - this information. Helps performance while processing big files. - - If you already have your XML document in memory, you can simply parse -it with: - - -- İşlev: iks * iks_tree (const char *XML_STR, size_t LEN, int *ERR); - This function parses the buffer pointed by XML_STR. If LEN is zero - buffer is considered as a null terminated utf8 string. Returns the - parsed tree, or NULL if there is an error. If ERR is not NULL, - actual error code (returned by iks_parse) is put there. - - Most of the times you want to load your configuration (or similar) -files directly into trees. iksemel provides two functions to greatly -simplify this: - - -- İşlev: int iks_load (const char *FNAME, iks **XPTR); - Loads the XML file. Tree is placed into the variable pointed by - XPTR. - - -- İşlev: int iks_save (const char *FNAME, iks *X); - Converts tree X into a string and saves to the file. - - Both functions return same error codes as `iks_parse'. Some -additional error codes are defined for indicating file problems. They -are: - -`IKS_FILE_NOFILE' - A file with the given name doesn't exist. - -`IKS_FILE_NOACCESS' - Cannot open file. Possibly a permission problem. - -`IKS_FILE_RWERR' - Read or write operation failed. - - Here is a simple example which parses a file and saves it into -another: - - iks *x; - - if (IKS_OK != iks_load ("file1.xml", &x)) { - puts ("loading error"); - } - if (IKS_OK != iks_save ("file2.xml", x)) { - puts ("saving error"); - } - - -File: iksemel, Node: XML Streams, Next: Writing a Jabber Client, Prev: Working with XML Trees, Up: Tutorials - -2.3 XML Streams -=============== - -XML streams function as containers for any XML chunks sent -asynchronously between network endpoints. They are used for -asyncronously exchanging relatively small payload of structured -information between entities. - - A stream is initiated by one of hosts connecting to the other, and -sending a tag. Receiving entity replies with a second -XML stream back to the initiating entity within the same connection. -Each unit of information is send as a direct child tag of the - tag. Stream is closed with . - - XML streams use a subset of XML. Specifically they should not contain -processing instructions, non-predefined entities, comments, or DTDs. - - Jabber protocol uses XML streams for exchanging messages, presence -information, and other information like authorization, search, time and -version queries, protocol extensions. - - iksemel provides you a stream parser, which automatically handles -connection to the server, and calls your hook function with incoming -information parsed and converted to an XML tree. - - You can create such a parser with: - - -- İşlev: iksparser* iks_stream_new (char* NAME_SPACE, void* - USER_DATA, iksStreamHook* STREAMHOOK); - Allocates and initalizes a stream parser. NAME_SPACE indicates the - stream type, jabber clients use "jabber:client" namespace. - USER_DATA is passed directly to your hook function. - - -- Typedef: iksStreamHook - int iksStreamHook (void* USER_DATA, int TYPE, iks* NODE); - - Depending on the value of the TYPE, NODE contains: - `IKS_NODE_START' - Got the tag, namespace, stream id and other - information is contained in the NODE. - - `IKS_NODE_NORMAL' - A first level child of the tag is received. - NODE contains the parsed tag. If you are connected to a - jabber server, you can get , , or - tags. - - `IKS_NODE_ERROR' - Got a tag, details can be accessed from NODE. - - `IKS_NODE_STOP' - tag is received or connection is closed, - NODE is `NULL'. - - Freeing the node with `iks_delete' is up to you. - - You can manually feed this parser with `iks_parse' function, but -using iksemel's connection facilities is easier for most of the cases. - - This functions return `IKS_OK' for success. Error codes of -`iks_parse' are used in same manner. Following additional codes are -defined for network related problems: - -`IKS_NET_NODNS' - Hostname lookup failed. Possible reasons: hostname is incorrect, - you are not online, your dns server isn't accessible. - -`IKS_NET_NOSOCK' - Socket cannot created. - -`IKS_NET_NOCONN' - Connection attemp failed. Possible reasons: host is not an XML - stream server, port number is wrong, server is busy or closed for - the moment. - -`IKS_NET_RWERR' - `send' or `recv' call is failed when attempting to exchange the - data with the server. You should close the connection with - `iks_disconnect' after getting this error from data transfer - functions. - - -- İşlev: int iks_connect_tcp (iksparser *PRS, const char *SERVER, - int PORT); - This function connects the parser to a server and sends stream - header for you. SERVER is the host name of the server and PORT is - the tcp port number which server is listening to. You can use - `IKS_JABBER_PORT' macro for the default jabber client port (5222). - - -- İşlev: int iks_connect_fd (iksparser *PRS, int FD); - Attaches parser to an already opened connection. FD is the socket - descriptor. Note that `iks_disconnect' doesn't close the socket - for this kind of connection, opening and closing of the socket is - up to your application. Stream header is not sent automatically. - You can use `iks_send_header' function for sending it. - - -- İşlev: void iks_disconnect (iksparser *PRS); - Closes connection to the server, and frees connection resources. - - After successfully connecting to a server, you can use following -functions for exchanging information with server. - - -- İşlev: int iks_recv (iksparser* PRS, int TiMEOUT); - If TiMEOUT is `-1', waits until some data arrives from server, and - process the data. Your stream hook can be called if a complete - chunk is arrived. - - If TiMEOUT is a positive integer, `iks_recv' returns if no data - arrives for TiMEOUT seconds. - - If TiMEOUT is zero, `iks_recv' checks if there is any data waiting - at the network buffer, and returns without waiting for data. - - -- İşlev: int iks_fd (iksparser* PRS); - Returns the file descriptor of the connected socket. You can use - this in your `select' function or some other input loop to act - whenever some data from the server arrives. This value of only - valid between a successful `iks_connect_tcp' and `iks_disconnect'. - - -- İşlev: int iks_send (iksparser* PRS, iks* X); - Converts the tree given in X to a string, and sends to the server. - String is created inside the object stack of X. - - -- İşlev: int iks_send_raw (iksparser* PRS, char* XMLSTR); - Sends the string given in XMLSTR to the server. - - -- İşlev: int iks_send_header (iksparser *PRS, char *TO); - Sends the stream header. TO is the name of the server. Normally - `iks_connect_tcp' function calls this for you. This is only useful - if you are using `iks_connect_fd'. - - Sometimes it is useful to log incoming and outgoing data to your -parser for debugging your applications. iksemel provides a logging -facility for you. - - -- İşlev: void iks_set_log_hook (iksparser* PRS, iksLogHook* - LOGHOOK); - Sets the log function for your stream parser. You can't use this - function on any other type of parser. - - -- Typedef: iksLogHook - void iksLogHook (void* USER_DATA, const char* DATA, size_t SiZE, - int iS_iNCOMiNG); - - USER_DATA is same value which you give with `iks_stream_new'. - DATA is SiZE bytes of data. Be very careful that this data may be - coming from other side of the connection and can contain malicius - bytes. It isn't checked by iksemel yet, so you should check it - yourself before displaying or passing to other systems in your - application or computer. If iS_iNCOMiNG is a non-zero value, data - is incoming from server, otherwise it is outgoing to the server. - - -File: iksemel, Node: Writing a Jabber Client, Next: Utility Functions, Prev: XML Streams, Up: Tutorials - -2.4 Writing a Jabber Client -=========================== - -* Menu: - -* Security:: - -* Packets:: - -* Packet Filter:: - -* Creating Common Packets:: - - -File: iksemel, Node: Security, Next: Packets, Up: Writing a Jabber Client - -2.4.1 Security --------------- - -iksemel supports TLS protocol for encrypted communication and SASL -protocol for authentication. TLS is handled by gnutls library. - - -- İşlev: int iks_has_tls (void); - If iksemel is compiled with gnutls library, this function returns - a non-zero value indicating you can try encrypted connection with - the server. - - -- İşlev: int iks_start_tls (iksparser* PRS); - Starts a TLS handshake over already connected parser. Returns - IKS_OK or one of the IKS_NET_ errors. If handshake succeeds you'll - get another stream header from server. - - -- İşlev: int iks_is_secure (iksparser* PRS); - Returns a non-zero value if a secure connection is fully - established between server. - - -- İşlev: int iks_start_sasl (iksparser* PRS, enum ikssasltype TYPE, - char* USERNAME, char* PASS); - Starts SASL operation. - - See tools/iksroster.c for a good example. - - -File: iksemel, Node: Packets, Next: Packet Filter, Prev: Security, Up: Writing a Jabber Client - -2.4.2 Packets -------------- - -iksemel can parse a jabber XML node and provide you a public packet -structure which contains information like node type and subtype, id, -namespace, sender's jabber id, etc. - - This handles a lot of node parsing for you. Packets are also used in -the packet filter subsystem. - - -- İşlev: ikspak * iks_packet (iks *X); - Takes a node from stream and extracts information from it to a - packet structure. Structure is allocated inside the node's object - stack. - - `ikspak' structure has following fields: - -`iks *x;' - This is a pointer to the node. - -`iksid *from;' - Sender's jabber id in parsed form. See below for `iksid' structure. - -`iks *query;' - A pointer to the tag for IQ nodes. - -`char *ns;' - Namespace of the content for IQ nodes. - -`char *id;' - ID of the node. - -`enum ikspaktype type;' - Type of the node. Possible types are: - - `IKS_PAK_NONE' - Unknown node. - - `IKS_PAK_MESSAGE' - Message node. - - `IKS_PAK_PRESENCE' - Presence node with presence publishing operation. - - `IKS_PAK_S10N' - Presence node with subscription operation. - - `IKS_PAK_IQ' - IQ node. - -`enum iksubtype subtype;' - Sub type of the node. Sub types for message nodes: - - `IKS_TYPE_NONE' - A normal message. - - `IKS_TYPE_CHAT' - Private chat message. - - `IKS_TYPE_GROUPCHAT' - Multi user chat message. - - `IKS_TYPE_HEADLINE' - Message from a news source. - - `IKS_TYPE_ERROR' - Message error. - - Sub types for IQ nodes: - - `IKS_TYPE_GET' - Asks for some information. - - `IKS_TYPE_SET' - Request for changing information. - - `IKS_TYPE_RESULT' - Reply to get and set requests. - - `IKS_TYPE_ERROR' - IQ error. - - Sub types for subscription nodes: - - `IKS_TYPE_SUBSCRIBE,' - Asks for subscribing to the presence. - - `IKS_TYPE_SUBSCRIBED,' - Grants subscription. - - `IKS_TYPE_UNSUBSCRIBE,' - Asks for unsubscribing to the presence. - - `IKS_TYPE_UNSUBSCRIBED,' - Cancels subscription. - - `IKS_TYPE_ERROR' - Presence error. - - Sub types for presence nodes: - - `IKS_TYPE_PROBE,' - Asks presence status. - - `IKS_TYPE_AVAILABLE,' - Publishes entity as available. More information can be found - in `show' field. - - `IKS_TYPE_UNAVAILABLE' - Publishes entity as unavailable. More information can be - found in `show' field. - -`enum ikshowtype show;' - Presence state for the presence nodes. - - `IKS_SHOW_UNAVAILABLE' - Entity is unavailable. - - `IKS_SHOW_AVAILABLE' - Entity is available. - - `IKS_SHOW_CHAT' - Entity is free for chat. - - `IKS_SHOW_AWAY' - Entity is away for a short time. - - `IKS_SHOW_XA' - Entity is away for a long time. - - `IKS_SHOW_DND' - Entity doesn't want to be disturbed. - - iksemel has two functions to parse and compare jabber IDs. - - -- İşlev: iksid * iks_id_new (ikstack *S, const char *JiD); - Parses a jabber id into its parts. `iksid' structure is created - inside the S object stack. - - `iksid' structure has following fields: - -`char *user;' - User name. - -`char *server;' - Server name. - -`char *resource;' - Resource. - -`char *partial;' - User name and server name. - -`char *full;' - User name, server name and resource. - - You can access this fields and read their values. Comparing two -parsed jabber ids can be done with: - - -- İşlev: int iks_id_cmp (iksid *A, iksid *B, int PARTS); - Compares PARTS of A and B. Part values are: - - `IKS_ID_USER' - - `IKS_ID_SERVER' - - `IKS_ID_RESOURCE' - - - You can combine this values with `or' operator. Some common - combinations are predefined for you: - - `IKS_ID_PARTIAL' - `IKS_ID_USER | IKS_ID_SERVER' - - `IKS_ID_FULL' - `IKS_ID_USER | IKS_ID_SERVER | IKS_ID_RESOURCE' - - Return value is `0' for equality. If entities are not equal a - combination of part values showing different parts is returned. - - -File: iksemel, Node: Packet Filter, Next: Creating Common Packets, Prev: Packets, Up: Writing a Jabber Client - -2.4.3 Packet Filter -------------------- - -Packet filter handles routing incoming packets to related functions. - - -- İşlev: iksfilter * iks_filter_new (void); - Creates a new packet filter. - - -- İşlev: void iks_filter_packet (iksfilter *F, ikspak *PAK); - Feeds the filter with given packet. Packet is compared to - registered rules and hook functions of the matching rules are - called in most matched to least matched order. - - -- İşlev: void iks_filter_delete (iksfilter *F); - Frees filter and rules. - - Rules are created with following function: - - -- İşlev: iksrule * iks_filter_add_rule (iksfilter *F, iksFilterHook - *FiLTERHOOK, void *USER_DATA, ...); - Adds a rule to the filter F. USER_DATA is passed directly to your - hook function FiLTERHOOK. - - A rule consist of one or more type and value pairs. Possible types: - `IKS_RULE_ID' - Compares `char *' value to packet ids. - - `IKS_RULE_FROM' - Compares `char *' value to packet senders. - - `IKS_RULE_FROM_PARTIAL' - Compares `char *' value to packet sender. Ignores resource - part of jabber id. - - `IKS_RULE_NS' - Compares `char *' value to namespace of iq packets. - - `IKS_RULE_TYPE' - Compares `int' value to packet types. - - `IKS_RULE_SUBTYPE' - Compares `int' value to packet sub types. - - `IKS_RULE_DONE' - Terminates the rule pairs. - - Here is an example which creates a filter and adds three rules: - iksfilter *f; - - f = iks_filter_new (); - iks_filter_add_rule (f, on_msg, NULL, - IKS_RULE_TYPE, IKS_PAK_MESSAGE, - IKS_RULE_DONE); - iks_filter_add_rule (f, on_auth_result, NULL, - IKS_RULE_TYPE, IKS_PAK_IQ, - IKS_RULE_SUBTYPE, IKS_TYPE_RESULT, - IKS_RULE_ID, "auth", - IKS_RULE_DONE); - iks_filter_add_rule (f, on_roster_push, NULL, - IKS_RULE_TYPE, IKS_PAK_IQ, - IKS_RULE_SUBTYPE, IKS_TYPE_SET, - IKS_RULE_NS, "jabber:iq:roster", - IKS_RULE_DONE); - - -- Typedef: iksFilterHook - int iksFilterHook (void *user_data, ikspak *pak); - - Your hook is called with your USER_DATA and matching packet PAK. - You can return two different values from your hook: - `IKS_FILTER_PASS' - Packet is forwarded to least matching rules. - - `IKS_FILTER_EAT' - Filtering process for the packet ends. - - You can remove the rules with following functions: - - -- İşlev: void iks_filter_remove_rule (iksfilter *F, iksrule *RULE); - Removes the rule from filter. - - -- İşlev: void iks_filter_remove_hook (iksfilter *F, iksFilterHook - *FiLTERHOOK); - Remove the rules using FiLTERHOOK function from filter. - - -File: iksemel, Node: Creating Common Packets, Prev: Packet Filter, Up: Writing a Jabber Client - -2.4.4 Creating Common Packets ------------------------------ - -A usual jabber network traffic contains many similar XML constructs. -iksemel provides several utility functions for creating them. They all -generate an XML tree, so you can add or modify some parts of the tree, -and send to server then. - - -- İşlev: iks * iks_make_auth (iksid *iD, const char *PASS, const - char *SiD); - Creates an authorization packet. iD is your parsed jabber id, and - PASS is your password. - - If stream id SiD isn't NULL, SHA1 authentication is used, - otherwise password is attached in plain text. You can learn stream - id from `IKS_STREAM_START' packet in your stream hook like this: - - char *sid; - - if (type == IKS_STREAM_START) { - sid = iks_find_attrib (node, "id"); - } - - -- İşlev: iks * iks_make_msg (enum iksubtype TYPE, const char *TO, - const char *BODY); - Creates a message packet. TYPE is the message type, TO is jabber id - of the recipient, BODY is the message. - - -- İşlev: iks * iks_make_s10n (enum iksubtype TYPE, const char *TO, - const char *MSG); - Creates a presence packet for subscription operations. TYPE is - operation, TO is jabber id of the recipient, MSG is a small - message for introducing yourself, or explaning the reason of why - you are subscribing or unsubscribing. - - -- İşlev: iks * iks_make_pres (enum ikshowtype SHOW, const char - *STATUS); - Creates a presence packet for publishing your presence. SHOW is - your presence state and STATUS is a message explaining why you are - not available at the moment, or what you are doing now. - - -- İşlev: iks * iks_make_iq (enum iksubtype TYPE, const char *XMLNS); - Creates an IQ packet. TYPE is operation type and XMLNS is the - namespace of the content. You usually have to add real content to - the tag before sending this packet. - - -File: iksemel, Node: Utility Functions, Prev: Writing a Jabber Client, Up: Tutorials - -2.5 Utility Functions -===================== - -2.5.1 Memory Utilities ----------------------- - - -- İşlev: void * iks_malloc (size_t SiZE); - - -- İşlev: void iks_free (void *PTR); - - These are wrappers around ANSI malloc and free functions used by the -iksemel library itself. You can free the output of iks_string (only if -you passed it a NULL stack) with iks_free for example. That is important -if you are using a malloc debugger in your application but not in -iksemel or vice versa. - -2.5.2 String Utilities ----------------------- - - -- İşlev: char * iks_strdup (const char *SRC); - - -- İşlev: int iks_strcmp (const char *A, const char *B); - - -- İşlev: int iks_strcasecmp (const char *A, const char *B); - - -- İşlev: int iks_strncmp (const char *A, const char *B, size_t N); - - -- İşlev: int iks_strncasecmp (const char *A, const char *B, size_t - N); - - -- İşlev: size_t iks_strlen (const char *SRC); - - These functions work exactly like their ANSI equivalents except that -they allow NULL values for string pointers. If SRC is NULL, iks_strdup -and iks_strlen returns zero. If A or B is NULL in string comparisation -functions they return -1. - - Their usefulness comes from the fact that they can chained with DOM -traversing functions like this: - - if (iks_strcmp (iks_find_attrib (x, "id"), "x1") == 0) count++; - - That example works even x doesn't have an 'id' attribute and -iks_find_attrib returns NULL. So you don't need to use temporary -variables in such situations. - -2.5.3 SHA1 Hash ---------------- - -Secure Hash Algorithm (SHA1) is used in the Jabber authentication -protocol for encoding your password when sending to the server. This -is normally handled by iks_make_auth() function, but if you want to -handle it manually, or if you need a good hash function for other -purproses you can use these functions. - - -- İşlev: iksha* iks_sha_new (void); - Allocates a structure for keeping calculation values and the state. - - -- İşlev: void iks_sha_reset (iksha *SHA); - Resets the state of the calculation. - - -- İşlev: void iks_sha_hash (iksha *SHA, const unsigned char *DATA, - int LEN, int FiNiSH); - Calculates the hash value of the given data. If FiNiSH is non - zero, applies the last step of the calculation. - - -- İşlev: void iks_sha_print (iksha *SHA, char *HASH); - Prints the result of a finished calculation into the buffer - pointed by HASH in hexadecimal string form. Buffer must be at - least 40 bytes long. String is not null terminated. - - -- İşlev: void iks_sha (const char *DATA, char *HASH); - Calculates the hash value of DATA and prints into HASH. This is a - helper function for simple hash calculations. It calls other - functions for the actual work. - - -File: iksemel, Node: Development, Next: Datatype Index, Prev: Tutorials, Up: Top - -3 Development -************* - -This chapter contains information on plan, procedure and standarts of -iksemel development. - -3.1 Roadmap -=========== - -There are three main functions iksemel tries to provide to applications: - * A generic XML parser with SAX and DOM interfaces. - - * XML stream client and server functionality. - - * Utilities for Jabber clients. - - Goal of the iksemel is providing these functions while supporting -embedded environments, keeping usage simple, and having a robust -implementation. - - Some decisions are made to reach this goal: - - Code is written in ANSI C with a single dependency on C library. -Instead of using expat or libxml, a simple built-in parser is used. -Similarly glib and gnu only features of glibc (like object stacks) are -avoided and built-in memory and string utilities are used. This may -seem like code duplication but since they are optimized for iksemel and -only a few kb in size, it isn't a big disadvantage. - - Code is placed files in a modular fashion, and different modules -don't depend on others' internal details. This allows taking unneeded -functionality out when building for low resource situations. - - It is tried to give functions names which are consistent, clear and -short. - - API is documented with texinfo for high quality printed output and -info file output for fast and simple access during application -development. Instead of using an autogenerated system or simply listing -function descriptions, a task oriented tutorial approach is used. - -3.2 Coding Style -================ - -Here is a short list describing preferred coding style for iksemel. -Please keep in mind when sending patches. - - * Indentation is done with tabs. Aligning is done with spaces. - - * Placement of braces is K&R style. - - * Function names are put at the start of line. - - * Function names are lowercase. - - * Words of the function names are separated with underscore - character. - - * Structure and variable names are lowercase. - - * Macro and enumarations names are uppercase. - - * Exported library API is contained in the single iksemel.h file. - - * Exported function names start with iks_ - - * Exported structure and type names start with iks - - * Exported macro and enumaration names start with IKS_ - - Here is an example: - - int - iks_new_func (char *text) - { - int i; - - i = an_internal_func (text); - if (IKS_SOME_VALUE == i) { - iks_some_func (text); - i++; - } - return i; - } - -3.3 Resources -============= - - * RFC 2279, UTF-8 format `http://www.ietf.org/rfc/rfc2279.txt' - - * W3C Recommendation, Extensible Markup Language 1.0 - `http://www.w3.org/TR/REC-xml' - - * Annotated XML Specification `http://www.xml.com/axml/testaxml.htm' - - * Jabber Protocol Documents `http://www.jabber.org/protocol/' - - -File: iksemel, Node: Datatype Index, Next: Function Index, Prev: Development, Up: Top - -Datatype Index -************** - -[index] -* Menu: - -* iks: Creating a Tree. (line 7) -* iksCDataHook: Parsing an XML Document. - (line 42) -* iksfilter: Packet Filter. (line 8) -* iksFilterHook: Packet Filter. (line 68) -* iksid: Packets. (line 142) -* iksLogHook: XML Streams. (line 143) -* ikspak: Packets. (line 18) -* iksparser: Parsing an XML Document. - (line 12) -* iksrule: Packet Filter. (line 21) -* iksStreamHook: XML Streams. (line 37) -* ikstack: Memory Management. (line 34) -* iksTagHook: Parsing an XML Document. - (line 22) -* ikstype: Accessing the Tree. (line 45) - - -File: iksemel, Node: Function Index, Prev: Datatype Index, Up: Top - -Function Index -************** - -[index] -* Menu: - -* iks_attrib: Accessing the Tree. (line 17) -* iks_cdata: Accessing the Tree. (line 59) -* iks_cdata_size: Accessing the Tree. (line 64) -* iks_child: Accessing the Tree. (line 15) -* iks_connect_fd: XML Streams. (line 92) -* iks_connect_tcp: XML Streams. (line 86) -* iks_copy: Creating a Tree. (line 101) -* iks_copy_within: Creating a Tree. (line 104) -* iks_delete: Creating a Tree. (line 56) -* iks_disconnect: XML Streams. (line 99) -* iks_dom_new: Parsing an XML Document into a Tree. - (line 10) -* iks_fd: XML Streams. (line 116) -* iks_filter_add_rule: Packet Filter. (line 23) -* iks_filter_delete: Packet Filter. (line 17) -* iks_filter_new: Packet Filter. (line 9) -* iks_filter_packet: Packet Filter. (line 12) -* iks_filter_remove_hook: Packet Filter. (line 85) -* iks_filter_remove_rule: Packet Filter. (line 81) -* iks_find: Accessing the Tree. (line 76) -* iks_find_attrib: Accessing the Tree. (line 85) -* iks_find_cdata: Accessing the Tree. (line 80) -* iks_find_with_attrib: Accessing the Tree. (line 90) -* iks_first_tag: Accessing the Tree. (line 30) -* iks_free: Utility Functions. (line 12) -* iks_has_attribs: Accessing the Tree. (line 70) -* iks_has_children: Accessing the Tree. (line 67) -* iks_has_tls: Security. (line 10) -* iks_hide: Creating a Tree. (line 52) -* iks_id_cmp: Packets. (line 163) -* iks_id_new: Packets. (line 139) -* iks_insert: Creating a Tree. (line 22) -* iks_insert_attrib: Creating a Tree. (line 37) -* iks_insert_cdata: Creating a Tree. (line 29) -* iks_insert_node: Creating a Tree. (line 48) -* iks_is_secure: Security. (line 20) -* iks_load: Parsing an XML Document into a Tree. - (line 56) -* iks_make_auth: Creating Common Packets. - (line 13) -* iks_make_iq: Creating Common Packets. - (line 45) -* iks_make_msg: Creating Common Packets. - (line 28) -* iks_make_pres: Creating Common Packets. - (line 40) -* iks_make_s10n: Creating Common Packets. - (line 33) -* iks_malloc: Utility Functions. (line 10) -* iks_name: Accessing the Tree. (line 55) -* iks_new: Creating a Tree. (line 11) -* iks_new_within: Creating a Tree. (line 17) -* iks_next: Accessing the Tree. (line 9) -* iks_next_tag: Accessing the Tree. (line 26) -* iks_nr_bytes: Parsing an XML Document. - (line 161) -* iks_nr_lines: Parsing an XML Document. - (line 164) -* iks_packet: Packets. (line 14) -* iks_parent: Accessing the Tree. (line 13) -* iks_parse: Parsing an XML Document. - (line 53) -* iks_parser_delete: Parsing an XML Document. - (line 75) -* iks_parser_reset: Parsing an XML Document. - (line 170) -* iks_prev: Accessing the Tree. (line 11) -* iks_prev_tag: Accessing the Tree. (line 28) -* iks_recv: XML Streams. (line 105) -* iks_root: Accessing the Tree. (line 23) -* iks_save: Parsing an XML Document into a Tree. - (line 60) -* iks_sax_new: Parsing an XML Document. - (line 17) -* iks_send: XML Streams. (line 122) -* iks_send_header: XML Streams. (line 129) -* iks_send_raw: XML Streams. (line 126) -* iks_set_log_hook: XML Streams. (line 139) -* iks_set_size_hint: Parsing an XML Document into a Tree. - (line 38) -* iks_sha: Utility Functions. (line 75) -* iks_sha_hash: Utility Functions. (line 66) -* iks_sha_new: Utility Functions. (line 59) -* iks_sha_print: Utility Functions. (line 70) -* iks_sha_reset: Utility Functions. (line 62) -* iks_stack: Accessing the Tree. (line 40) -* iks_stack_alloc: Memory Management. (line 48) -* iks_stack_delete: Memory Management. (line 61) -* iks_stack_new: Memory Management. (line 39) -* iks_stack_strcat: Memory Management. (line 68) -* iks_stack_strdup: Memory Management. (line 56) -* iks_start_sasl: Security. (line 25) -* iks_start_tls: Security. (line 15) -* iks_strcasecmp: Utility Functions. (line 27) -* iks_strcmp: Utility Functions. (line 25) -* iks_strdup: Utility Functions. (line 23) -* iks_stream_new: XML Streams. (line 32) -* iks_string: Converting a Tree into an XML Document. - (line 10) -* iks_strlen: Utility Functions. (line 34) -* iks_strncasecmp: Utility Functions. (line 32) -* iks_strncmp: Utility Functions. (line 29) -* iks_tree: Parsing an XML Document into a Tree. - (line 46) -* iks_type: Accessing the Tree. (line 43) - - - -Tag Table: -Node: Top84 -Node: Introduction766 -Node: Tutorials2545 -Node: Parsing an XML Document2791 -Node: Working with XML Trees8616 -Node: Memory Management9441 -Node: Creating a Tree13078 -Node: Accessing the Tree17347 -Node: Converting a Tree into an XML Document22198 -Node: Parsing an XML Document into a Tree23208 -Node: XML Streams26189 -Node: Writing a Jabber Client32736 -Node: Security32988 -Node: Packets33991 -Node: Packet Filter38179 -Node: Creating Common Packets41070 -Node: Utility Functions43107 -Node: Development45943 -Node: Datatype Index48873 -Node: Function Index50166 - -End Tag Table