yong-stropheruby 0.0.5

data/ext/hash.c

@@ -0,0 +1,278 @@
+/* hash.c
+** strophe XMPP client library -- hash table implementation
+** 
+** Copyright (C) 2005-2008 OGG, LLC. All rights reserved.
+**
+**  This software is provided AS-IS with no warranty, either express
+**  or implied.
+**
+**  This software is distributed under license and may not be copied,
+**  modified or distributed except as expressly authorized under the
+**  terms of the license contained in the file LICENSE.txt in this
+**  distribution.
+*/
+
+/** @file
+ *  Hash tables.
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "strophe.h"
+#include "common.h"
+#include "hash.h"
+
+/* private types */
+typedef struct _hashentry_t hashentry_t;
+
+struct _hashentry_t {
+    hashentry_t *next;
+    char *key;
+    void *value;
+};
+
+struct _hash_t {
+    unsigned int ref;
+    xmpp_ctx_t *ctx;
+    hash_free_func free;
+    int length;
+    int num_keys;
+    hashentry_t **entries;
+};
+
+struct _hash_iterator_t {
+    unsigned int ref;
+    hash_t *table;
+    hashentry_t *entry;
+    int index;
+};
+   
+/** allocate and initialize a new hash table */
+hash_t *hash_new(xmpp_ctx_t * const ctx, const int size,
+		 hash_free_func free)
+{
+    hash_t *result = NULL;
+
+    result = xmpp_alloc(ctx, sizeof(hash_t));
+    if (result != NULL) {
+	result->entries = xmpp_alloc(ctx, size * sizeof(hashentry_t *));
+	if (result->entries == NULL) {
+	    xmpp_free(ctx, result);
+	    return NULL;
+	}
+	memset(result->entries, 0, size * sizeof(hashentry_t *));
+	result->length = size;
+
+	result->ctx = ctx;
+	result->free = free;
+	result->num_keys = 0;
+	/* give the caller a reference */
+	result->ref = 1;
+    }
+    
+    return result;
+}
+
+/** obtain a new reference to an existing hash table */
+hash_t *hash_clone(hash_t * const table)
+{
+    table->ref++;
+    return table;
+}
+
+/** release a hash table that is no longer needed */
+void hash_release(hash_t * const table)
+{
+    xmpp_ctx_t *ctx = table->ctx;
+    hashentry_t *entry, *next;
+    int i;
+    
+    if (table->ref > 1)
+	table->ref--;
+    else {
+	for (i = 0; i < table->length; i++) {
+	    entry = table->entries[i];
+	    while (entry != NULL) {
+		next = entry->next;
+		xmpp_free(ctx, entry->key);
+		if (table->free) table->free(ctx, entry->value);
+		xmpp_free(ctx, entry);
+		entry = next;
+	    }
+	}
+	xmpp_free(ctx, table->entries);
+	xmpp_free(ctx, table);
+    }
+}
+
+/** hash a key for our table lookup */
+static int _hash_key(hash_t *table, const char *key)
+{
+   int hash = 0;
+   int shift = 0;
+   const char *c = key;
+
+   while (*c != '\0') {
+	/* assume 32 bit ints */
+	hash ^= ((int)*c++ << shift);
+	shift += 8;
+	if (shift > 24) shift = 0;
+   }
+
+   return hash % table->length;
+}
+
+/** add a key, value pair to a hash table.
+ *  each key can appear only once; the value of any
+ *  identical key will be replaced
+ */
+int hash_add(hash_t *table, const char * const key, void *data)
+{
+   xmpp_ctx_t *ctx = table->ctx;
+   hashentry_t *entry = NULL;
+   int index = _hash_key(table, key);
+
+   /* drop existing entry, if any */
+   hash_drop(table, key);
+
+   /* allocate and fill a new entry */
+   entry = xmpp_alloc(ctx, sizeof(hashentry_t));
+   if (!entry) return -1;
+   entry->key = xmpp_strdup(ctx, key);
+   if (!entry->key) {
+       xmpp_free(ctx, entry);
+       return -1;
+   }
+   entry->value = data;
+   /* insert ourselves in the linked list */
+   /* TODO: this leaks duplicate keys */
+   entry->next = table->entries[index];
+   table->entries[index] = entry;
+   table->num_keys++;
+
+   return 0;
+}
+
+/** look up a key in a hash table */
+void *hash_get(hash_t *table, const char *key)
+{
+   hashentry_t *entry;
+   int index = _hash_key(table, key);
+   void *result = NULL;
+
+   /* look up the hash entry */
+   entry = table->entries[index];
+   while (entry != NULL) {
+	/* traverse the linked list looking for the key */
+	if (!strcmp(key, entry->key)) {
+	  /* match */
+	  result = entry->value;
+	  return result;
+	}
+	entry = entry->next;
+   }
+   /* no match */
+   return result;
+}
+
+/** delete a key from a hash table */
+int hash_drop(hash_t *table, const char *key)
+{
+   xmpp_ctx_t *ctx = table->ctx;
+   hashentry_t *entry, *prev;
+   int index = _hash_key(table, key);
+
+   /* look up the hash entry */
+   entry = table->entries[index];
+   prev = NULL;
+   while (entry != NULL) {
+	/* traverse the linked list looking for the key */
+	if (!strcmp(key, entry->key)) {
+	  /* match, remove the entry */
+	  xmpp_free(ctx, entry->key);
+	  if (table->free) table->free(ctx, entry->value);
+	  if (prev == NULL) {
+	    table->entries[index] = entry->next;
+	  } else {
+	    prev->next = entry->next;
+	  }
+	  xmpp_free(ctx, entry);
+	  table->num_keys--;
+	  return 0;
+	}
+	prev = entry;
+	entry = entry->next;
+   }
+   /* no match */
+   return -1;
+}
+
+int hash_num_keys(hash_t *table)
+{
+    return table->num_keys;
+}
+
+/** allocate and initialize a new iterator */
+hash_iterator_t *hash_iter_new(hash_t *table)
+{
+    xmpp_ctx_t *ctx = table->ctx;
+    hash_iterator_t *iter;
+
+    iter = xmpp_alloc(ctx, sizeof(*iter));
+    if (iter != NULL) {
+	iter->ref = 1;
+	iter->table = hash_clone(table);
+	iter->entry = NULL;
+	iter->index = -1;
+    }
+
+    return iter;
+}
+
+
+/** release an iterator that is no longer needed */
+void hash_iter_release(hash_iterator_t *iter)
+{
+    xmpp_ctx_t *ctx = iter->table->ctx;
+
+    iter->ref--;
+
+    if (iter->ref <= 0) {
+	hash_release(iter->table);
+	xmpp_free(ctx, iter);
+    }
+}
+
+/** return the next hash table key from the iterator.
+    the returned key should not be freed */
+const char * hash_iter_next(hash_iterator_t *iter)
+{
+    hash_t *table = iter->table;
+    hashentry_t *entry = iter->entry;
+    int i = iter->index + 1;
+
+    /* advance until we find the next entry */
+    if (entry != NULL) entry = entry->next;
+    if (entry == NULL) {
+	/* we're off the end of list, search for a new entry */
+	while (i < iter->table->length) {
+	    entry = table->entries[i];
+	    if (entry != NULL) {
+		iter->index = i;
+		break;
+	    }
+	    i++;
+	}
+    }
+
+    if ((entry == NULL) || (i >= table->length)) {
+	/* no more keys! */
+	return NULL;
+    }
+
+    /* remember our current match */
+    iter->entry = entry;
+    return entry->key;
+}
+

data/ext/hash.h

@@ -0,0 +1,64 @@
+/* hash.h
+** strophe XMPP client library -- hash table interface
+** 
+** Copyright (C) 2005-2008 OGG, LLC. All rights reserved.
+**
+**  This software is provided AS-IS with no warranty, either express
+**  or implied.
+**
+**  This software is distributed under license and may not be copied,
+**  modified or distributed except as expressly authorized under the
+**  terms of the license contained in the file LICENSE.txt in this
+**  distribution.
+*/
+
+/** @file
+ *  Hash table API.
+*/
+
+#ifndef __LIBSTROPHE_HASH_H__
+#define __LIBSTROPHE_HASH_H__
+
+typedef struct _hash_t hash_t;
+
+typedef void (*hash_free_func)(const xmpp_ctx_t * const ctx, void *p);
+
+/** allocate and initialize a new hash table */
+hash_t *hash_new(xmpp_ctx_t * const ctx, const int size,
+		 hash_free_func free);
+
+/** allocate a new reference to an existing hash table */
+hash_t *hash_clone(hash_t * const table);
+
+/** release a hash table when no longer needed */
+void hash_release(hash_t * const table);
+
+/** add a key, value pair to a hash table.
+ *  each key can appear only once; the value of any
+ *  identical key will be replaced
+ */
+int hash_add(hash_t *table, const char * const key, void *data);
+
+/** look up a key in a hash table */
+void *hash_get(hash_t *table, const char *key);
+
+/** delete a key from a hash table */
+int hash_drop(hash_t *table, const char *key);
+
+/** return the number of keys in a hash */
+int hash_num_keys(hash_t *table);
+
+/** hash key iterator functions */
+typedef struct _hash_iterator_t hash_iterator_t;
+
+/** allocate and initialize a new iterator */
+hash_iterator_t *hash_iter_new(hash_t *table);
+
+/** release an iterator that is no longer needed */
+void hash_iter_release(hash_iterator_t *iter);
+
+/** return the next hash table key from the iterator.
+    the returned key should not be freed */
+const char * hash_iter_next(hash_iterator_t *iter);
+
+#endif /* __LIBXMPPP_HASH_H__ */

data/ext/jid.c

@@ -0,0 +1,177 @@
+/* jid.c
+** strophe XMPP client library -- helper functions for parsing JIDs
+**
+** Copyright (C) 2005-2008 OGG, LLC. All rights reserved.
+**
+**  This software is provided AS-IS with no warranty, either express
+**  or implied.
+**
+**  This software is distributed under license and may not be copied,
+**  modified or distributed except as expressly authorized under the
+**  terms of the license contained in the file LICENSE.txt in this
+**  distribution.
+*/
+
+/** @file
+ *  JID creation and parsing.
+ */
+
+#include <string.h>
+
+#include "strophe.h"
+#include "common.h"
+
+/** Create a JID string from component parts node, domain, and resource.
+ *
+ *  @param ctx the Strophe context object
+ *  @param node a string representing the node
+ *  @param domain a string representing the domain.  Required.
+ *  @param resource a string representing the resource
+ *
+ *  @return an allocated string with the full JID or NULL if no domain
+ *      is specified
+ */
+char *xmpp_jid_new(xmpp_ctx_t *ctx, const char *node,
+				    const char *domain,
+				    const char *resource)
+{
+    char *result;
+    int len,nlen,dlen,rlen;
+
+    /* jid must at least have a domain */
+    if (domain == NULL) return NULL;
+
+    /* accumulate lengths */
+    dlen = strlen(domain);
+    nlen = (node) ? strlen(node) + 1 : 0;
+    rlen = (resource) ? strlen(resource) + 1 : 0;
+    len = nlen + dlen + rlen;
+
+    /* concat components */
+    result = xmpp_alloc(ctx, len + 1);
+    if (result != NULL) {
+	if (node != NULL) {
+	    memcpy(result, node, nlen - 1);
+	    result[nlen-1] = '@';
+	}
+        memcpy(result + nlen, domain, dlen);
+	if (resource != NULL) {
+	    result[nlen+dlen] = '/';
+	    memcpy(result+nlen+dlen+1, resource, rlen - 1);
+	}
+	result[nlen+dlen+rlen] = '\0';
+    }
+
+    return result;
+}
+
+/** Create a bare JID from a JID.
+ *  
+ *  @param ctx the Strophe context object
+ *  @param jid the JID
+ *
+ *  @return an allocated string with the bare JID or NULL on an error
+ */
+char *xmpp_jid_bare(xmpp_ctx_t *ctx, const char *jid)
+{
+    char *result;
+    const char *c;
+
+    c = strchr(jid, '/');
+    if (c == NULL) return xmpp_strdup(ctx, jid);
+
+    result = xmpp_alloc(ctx, c-jid+1);
+    if (result != NULL) {
+	memcpy(result, jid, c-jid);
+	result[c-jid] = '\0';
+    }
+
+    return result;
+}
+
+/** Create a node string from a JID.
+ *  
+ *  @param ctx a Strophe context object
+ *  @param jid the JID
+ *
+ *  @return an allocated string with the node or NULL if no node is found
+ *      or an error occurs
+ */
+char *xmpp_jid_node(xmpp_ctx_t *ctx, const char *jid)
+{
+    char *result = NULL;
+    const char *c;
+
+    c = strchr(jid, '@');
+    if (c != NULL) {
+	result = xmpp_alloc(ctx, (c-jid) + 1);
+	if (result != NULL) {
+	    memcpy(result, jid, (c-jid));
+	    result[c-jid] = '\0';
+	}
+    }
+
+    return result;
+}
+
+/** Create a domain string from a JID.
+ *
+ *  @param ctx the Strophe context object
+ *  @param jid the JID
+ *
+ *  @return an allocated string with the domain or NULL on an error
+ */
+char *xmpp_jid_domain(xmpp_ctx_t *ctx, const char *jid)
+{
+    char *result = NULL;
+    const char *c,*s;
+
+    c = strchr(jid, '@');
+    if (c == NULL) {
+	/* no node, assume domain */
+	c = jid;
+    } else {
+	/* advance past the separator */
+	c++;
+    }
+    s = strchr(c, '/');
+    if (s == NULL) {
+	/* no resource */
+	s = c + strlen(c);
+    }
+    result = xmpp_alloc(ctx, (s-c) + 1);
+    if (result != NULL) {
+	memcpy(result, c, (s-c));
+	result[s-c] = '\0';
+    }
+
+    return result;
+}
+
+/** Create a resource string from a JID.
+ *
+ *  @param ctx a Strophe context object
+ *  @param jid the JID
+ *
+ *  @return an allocated string with the resource or NULL if no resource 
+ *      is found or an error occurs
+ */
+char *xmpp_jid_resource(xmpp_ctx_t *ctx, const char *jid)
+{
+    char *result = NULL;
+    const char *c;
+    int len;
+
+    c = strchr(jid, '/');
+    if (c != NULL)  {
+	c++;
+	len = strlen(c);
+	result = xmpp_alloc(ctx, len + 1);
+	if (result != NULL) {
+	    memcpy(result, c, len);
+	    result[len] = '\0';
+	}
+    }
+
+    return result;
+}