diff options
Diffstat (limited to 'doc/iksemel')
| -rw-r--r-- | doc/iksemel | 235 |
1 files changed, 118 insertions, 117 deletions
diff --git a/doc/iksemel b/doc/iksemel index 31843b9..679116d 100644 --- a/doc/iksemel +++ b/doc/iksemel @@ -1,5 +1,4 @@ -Bu iksemel, makeinfo sürümü 4.8 tarafından, ./iksemel.texi'den -üretilmiştir. +This is iksemel, produced by makeinfo version 4.13 from ./iksemel.texi. File: iksemel, Node: Top, Up: (dir) @@ -122,7 +121,7 @@ hook functions you have provided. This type of interface is called SAX 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* + -- Function: 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 @@ -158,8 +157,8 @@ referenced by `iksparser' type, and managed with following functions: `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); + -- Function: 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. @@ -181,7 +180,7 @@ referenced by `iksparser' type, and managed with following functions: `IKS_HOOK' Your hook decided that there is an error. - -- İşlev: void iks_parser_delete (iksparser* PRS); + -- Function: 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 @@ -267,16 +266,16 @@ 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); + -- Function: unsigned long iks_nr_bytes (iksparser* PRS); Returns how many number of bytes parsed. - -- İşlev: unsigned long iks_nr_lines (iksparser* PRS); + -- Function: 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); + -- Function: void iks_parser_reset (iksparser* PRS); Resets the parser's internal state. @@ -345,7 +344,7 @@ big blocks. 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 + -- Function: 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 @@ -355,27 +354,27 @@ big blocks. 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); + -- Function: 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 * + -- Function: 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); + -- Function: 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); + -- Function: 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 @@ -399,24 +398,24 @@ File: iksemel, Node: Creating a Tree, Next: Accessing the Tree, Prev: Memory 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); + -- Function: 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); + -- Function: 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); + -- Function: 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 + -- Function: 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 @@ -424,7 +423,7 @@ File: iksemel, Node: Creating a Tree, Next: Accessing the Tree, Prev: Memory 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 + -- Function: 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 @@ -436,15 +435,15 @@ File: iksemel, Node: Creating a Tree, Next: Accessing the Tree, Prev: Memory attribute's value. If VALUE is NULL, attribute is removed from the tag. - -- İşlev: iks* iks_insert_node (iks* X, iks* Y); + -- Function: 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); + -- Function: 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); + -- Function: void iks_delete (iks *X); Frees the object stack of the node X. Now lets create a tree representation of following XML document: @@ -489,10 +488,10 @@ read document for humans. There are also functions for duplicating xml trees. They are: - -- İşlev: iks * iks_copy (iks* X); + -- Function: 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); + -- Function: iks * iks_copy_within (iks* X, ikstack *S); Creates a full copy of the tree in given object stack. @@ -503,28 +502,28 @@ File: iksemel, Node: Accessing the Tree, Next: Converting a Tree into an XML D Basic access functions allow you to move on the tree: - -- İşlev: iks* iks_next (iks* X); + -- Function: iks* iks_next (iks* X); - -- İşlev: iks* iks_prev (iks* X); + -- Function: iks* iks_prev (iks* X); - -- İşlev: iks* iks_parent (iks* X); + -- Function: iks* iks_parent (iks* X); - -- İşlev: iks* iks_child (iks* X); + -- Function: iks* iks_child (iks* X); - -- İşlev: iks* iks_attrib (iks* X); + -- Function: 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); + -- Function: iks * iks_root (iks *X); Returns the topmost parent node of the X. - -- İşlev: iks* iks_next_tag (iks* X); + -- Function: iks* iks_next_tag (iks* X); - -- İşlev: iks* iks_prev_tag (iks* X); + -- Function: iks* iks_prev_tag (iks* X); - -- İşlev: iks* iks_first_tag (iks* X); + -- Function: 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 @@ -534,10 +533,10 @@ 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); + -- Function: ikstack* iks_stack (iks* X); Returns the object stack which node X stays. - -- İşlev: enum ikstype iks_type (iks* X); + -- Function: enum ikstype iks_type (iks* X); Returns the type of the node. `IKS_TAG' @@ -549,41 +548,41 @@ and content of the nodes: `IKS_ATTRIBUTE' Node contains an attribute and its value. - -- İşlev: char* iks_name (iks* X); + -- Function: 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); + -- Function: 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); + -- Function: 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); + -- Function: 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); + -- Function: 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); + -- Function: 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); + -- Function: 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); + -- Function: 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, + -- Function: 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 @@ -653,7 +652,7 @@ File: iksemel, Node: Converting a Tree into an XML Document, Next: Parsing an There is a function for converting given XML tree into a null terminated string. - -- İşlev: char * iks_string (ikstack* STACK, iks* X); + -- Function: 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. @@ -683,7 +682,7 @@ File: iksemel, Node: Parsing an XML Document into a Tree, Prev: Converting a T 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); + -- Function: 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. @@ -710,7 +709,7 @@ if there isn't an error, you can access to your tree from variable 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 + -- Function: 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 @@ -719,7 +718,8 @@ allocation strategy. Here is the function for this. 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); + -- Function: 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, @@ -729,11 +729,11 @@ it with: files directly into trees. iksemel provides two functions to greatly simplify this: - -- İşlev: int iks_load (const char *FNAME, iks **XPTR); + -- Function: 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); + -- Function: 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 @@ -791,7 +791,7 @@ information parsed and converted to an XML tree. You can create such a parser with: - -- İşlev: iksparser* iks_stream_new (char* NAME_SPACE, void* + -- Function: 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. @@ -845,27 +845,27 @@ defined for network related problems: `iks_disconnect' after getting this error from data transfer functions. - -- İşlev: int iks_connect_tcp (iksparser *PRS, const char *SERVER, + -- Function: 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); + -- Function: 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); + -- Function: 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); + -- Function: 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. @@ -876,20 +876,20 @@ functions for exchanging information with server. 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); + -- Function: 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); + -- Function: 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); + -- Function: 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); + -- Function: 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'. @@ -898,7 +898,7 @@ functions for exchanging information with server. parser for debugging your applications. iksemel provides a logging facility for you. - -- İşlev: void iks_set_log_hook (iksparser* PRS, iksLogHook* + -- Function: 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. @@ -940,22 +940,22 @@ File: iksemel, Node: Security, Next: Packets, Up: Writing a Jabber Client iksemel supports TLS protocol for encrypted communication and SASL protocol for authentication. TLS is handled by gnutls library. - -- İşlev: int iks_has_tls (void); + -- Function: 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); + -- Function: 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); + -- Function: 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); + -- Function: int iks_start_sasl (iksparser* PRS, enum ikssasltype + TYPE, char* USERNAME, char* PASS); Starts SASL operation. See tools/iksroster.c for a good example. @@ -973,7 +973,7 @@ 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); + -- Function: 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. @@ -1098,7 +1098,7 @@ the packet filter subsystem. iksemel has two functions to parse and compare jabber IDs. - -- İşlev: iksid * iks_id_new (ikstack *S, const char *JiD); + -- Function: 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. @@ -1122,7 +1122,7 @@ the packet filter subsystem. 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); + -- Function: int iks_id_cmp (iksid *A, iksid *B, int PARTS); Compares PARTS of A and B. Part values are: `IKS_ID_USER' @@ -1152,21 +1152,21 @@ File: iksemel, Node: Packet Filter, Next: Creating Common Packets, Prev: Pack Packet filter handles routing incoming packets to related functions. - -- İşlev: iksfilter * iks_filter_new (void); + -- Function: iksfilter * iks_filter_new (void); Creates a new packet filter. - -- İşlev: void iks_filter_packet (iksfilter *F, ikspak *PAK); + -- Function: 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); + -- Function: 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, ...); + -- Function: 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. @@ -1224,10 +1224,10 @@ Packet filter handles routing incoming packets to related functions. You can remove the rules with following functions: - -- İşlev: void iks_filter_remove_rule (iksfilter *F, iksrule *RULE); + -- Function: void iks_filter_remove_rule (iksfilter *F, iksrule *RULE); Removes the rule from filter. - -- İşlev: void iks_filter_remove_hook (iksfilter *F, iksFilterHook + -- Function: void iks_filter_remove_hook (iksfilter *F, iksFilterHook *FiLTERHOOK); Remove the rules using FiLTERHOOK function from filter. @@ -1242,7 +1242,7 @@ 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 + -- Function: 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. @@ -1257,25 +1257,26 @@ and send to server then. sid = iks_find_attrib (node, "id"); } - -- İşlev: iks * iks_make_msg (enum iksubtype TYPE, const char *TO, + -- Function: 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, + -- Function: 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 + -- Function: 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); + -- Function: 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 <query> tag before sending this packet. @@ -1289,9 +1290,9 @@ File: iksemel, Node: Utility Functions, Prev: Writing a Jabber Client, Up: Tu 2.5.1 Memory Utilities ---------------------- - -- İşlev: void * iks_malloc (size_t SiZE); + -- Function: void * iks_malloc (size_t SiZE); - -- İşlev: void iks_free (void *PTR); + -- Function: 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 @@ -1302,18 +1303,18 @@ iksemel or vice versa. 2.5.2 String Utilities ---------------------- - -- İşlev: char * iks_strdup (const char *SRC); + -- Function: char * iks_strdup (const char *SRC); - -- İşlev: int iks_strcmp (const char *A, const char *B); + -- Function: int iks_strcmp (const char *A, const char *B); - -- İşlev: int iks_strcasecmp (const char *A, const char *B); + -- Function: int iks_strcasecmp (const char *A, const char *B); - -- İşlev: int iks_strncmp (const char *A, const char *B, size_t N); + -- Function: int iks_strncmp (const char *A, const char *B, size_t N); - -- İşlev: int iks_strncasecmp (const char *A, const char *B, size_t + -- Function: int iks_strncasecmp (const char *A, const char *B, size_t N); - -- İşlev: size_t iks_strlen (const char *SRC); + -- Function: 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 @@ -1338,23 +1339,23 @@ 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); + -- Function: iksha* iks_sha_new (void); Allocates a structure for keeping calculation values and the state. - -- İşlev: void iks_sha_reset (iksha *SHA); + -- Function: void iks_sha_reset (iksha *SHA); Resets the state of the calculation. - -- İşlev: void iks_sha_hash (iksha *SHA, const unsigned char *DATA, + -- Function: 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); + -- Function: 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); + -- Function: 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. @@ -1531,11 +1532,11 @@ Function Index * 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) + (line 57) * iks_make_auth: Creating Common Packets. (line 13) * iks_make_iq: Creating Common Packets. - (line 45) + (line 46) * iks_make_msg: Creating Common Packets. (line 28) * iks_make_pres: Creating Common Packets. @@ -1565,7 +1566,7 @@ Function Index * iks_recv: XML Streams. (line 105) * iks_root: Accessing the Tree. (line 23) * iks_save: Parsing an XML Document into a Tree. - (line 60) + (line 61) * iks_sax_new: Parsing an XML Document. (line 17) * iks_send: XML Streams. (line 122) @@ -1597,31 +1598,31 @@ Function Index * iks_strncasecmp: Utility Functions. (line 32) * iks_strncmp: Utility Functions. (line 29) * iks_tree: Parsing an XML Document into a Tree. - (line 46) + (line 47) * 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: Top0 +Node: Introduction755 +Node: Tutorials2534 +Node: Parsing an XML Document2780 +Node: Working with XML Trees8611 +Node: Memory Management9436 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 +Node: Accessing the Tree17357 +Node: Converting a Tree into an XML Document22228 +Node: Parsing an XML Document into a Tree23239 +Node: XML Streams26235 +Node: Writing a Jabber Client32792 +Node: Security33044 +Node: Packets34051 +Node: Packet Filter38242 +Node: Creating Common Packets41139 +Node: Utility Functions43191 +Node: Development46040 +Node: Datatype Index48970 +Node: Function Index50263 End Tag Table |