#include <stdlib.h>
#include <glib.h>
#include <gmodule.h>
#include <check.h>
#include <string.h>
#include "bitlbee.h"
#include "user.h"
#include "testsuite.h"
START_TEST(test_user_add)
irc_t *irc = torture_irc();
user_t *user;
user = user_add(irc, "foo");
fail_if(user == NULL);
fail_if(strcmp(user->nick, "foo") != 0);
fail_unless(user_find(irc, "foo") == user);
END_TEST
START_TEST(test_user_add_exists)
irc_t *irc = torture_irc();
user_t *user;
user = user_add(irc, "foo");
fail_if(user == NULL);
user = user_add(irc, "foo");
fail_unless(user == NULL);
END_TEST
START_TEST(test_user_add_invalid)
irc_t *irc = torture_irc();
user_t *user;
user = user_add(irc, ":foo");
fail_unless(user == NULL);
END_TEST
START_TEST(test_user_del_invalid)
irc_t *pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <stdio.h>
#include <setjmp.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <syslog.h>
#include <strings.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#ifndef __CYGWIN__
#include <arpa/nameser.h>
#include <resolv.h>
#endif
#include <sys/time.h>
#include <time.h>
#include "xmlparse.h"
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif /* HAVE_CONFIG_H */
/*
** Arrange to use either varargs or stdargs
*/
#define MAXSHORTSTR 203 /* max short string length */
#define QUAD_T unsigned long long
#ifdef __STDC__
#include <stdarg.h>
# define VA_LOCAL_DECL va_list ap;
# define VA_START(f) va_start(ap, f)
# define VA_END va_end(ap)
#else /* __STDC__ */
# include <varargs.h>
# define VA_LOCAL_DECL va_list ap;
# define VA_START(f) va_start(ap)
# define VA_END va_end(ap)
#endif /* __STDC__ */
#ifndef INCL_LIBXODE_H
#define INCL_LIBXODE_H
#ifdef __cplusplus
extern "C" {
#endif
#ifndef HAVE_SNPRINTF
extern int ap_snprintf(char *, size_t, const char *, ...);
#define snprintf ap_snprintf
#endif
#ifndef HAVE_VSNPRINTF
extern int ap_vsnprintf(char *, size_t, const char *, va_list ap);
#define vsnprintf ap_vsnprintf
#endif
#define ZONE zonestr(__FILE__,__LINE__)
char *zonestr(char *file, int line);
/* --------------------------------------------------------- */
/* */
/* Pool-based memory management routines */
/* */
/* --------------------------------------------------------- */
#undef POOL_DEBUG
/*
flip these, this should be a prime number for top # of pools debugging
#define POOL_DEBUG 40009
*/
/* pheap - singular allocation of memory */
struct pheap
{
void *block;
int size, used;
};
/* pool_cleaner - callback type which is associated
with a pool entry; invoked when the pool entry is
free'd */
typedef void (*pool_cleaner)(void *arg);
/* pfree - a linked list node which stores an
allocation chunk, plus a callback */
struct pfree
{
pool_cleaner f;
void *arg;
struct pheap *heap;
struct pfree *next;
};
/* pool - base node for a pool. Maintains a linked list
of pool entries (pfree) */
typedef struct pool_struct
{
int size;
struct pfree *cleanup;
struct pheap *heap;
#ifdef POOL_DEBUG
char name[8], zone[32];
int lsize;
} _pool, *pool;
#define pool_new() _pool_new(ZONE)
#define pool_heap(i) _pool_new_heap(i,ZONE)
#else
} _pool, *pool;
#define pool_heap(i) _pool_new_heap(i,NULL)
#define pool_new() _pool_new(NULL)
#endif
pool _pool_new(char *zone); /* new pool :) */
pool _pool_new_heap(int size, char *zone); /* creates a new memory pool with an initial heap size */
void *pmalloc(pool p, int size); /* wrapper around malloc, takes from the pool, cleaned up automatically */
void *pmalloc_x(pool p, int size, char c); /* Wrapper around pmalloc which prefils buffer with c */
void *pmalloco(pool p, int size); /* YAPW for zeroing the block */
char *pstrdup(pool p, const char *src); /* wrapper around strdup, gains mem from pool */
void pool_stat(int full); /* print to stderr the changed pools and reset */
void pool_cleanup(pool p, pool_cleaner f, void *arg); /* calls f(arg) before the pool is freed during cleanup */
void pool_free(pool p); /* calls the cleanup functions, frees all the data on the pool, and deletes the pool itself */
/* --------------------------------------------------------- */
/* */
/* Socket helper stuff */
/* */
/* --------------------------------------------------------- */
#ifndef MAXHOSTNAMELEN
#define MAXHOSTNAMELEN 64
#endif
#define NETSOCKET_SERVER 0
#define NETSOCKET_CLIENT 1
#define NETSOCKET_UDP 2
#ifndef WIN32
int make_netsocket(u_short port, char *host, int type);
struct in_addr *make_addr(char *host);
int set_fd_close_on_exec(int fd, int flag);
#endif
/* --------------------------------------------------------- */
/* */
/* SHA calculations */
/* */
/* --------------------------------------------------------- */
#if (SIZEOF_INT == 4)
typedef unsigned int uint32;
#elif (SIZEOF_SHORT == 4)
typedef unsigned short uint32;
#else
typedef unsigned int uint32;
#endif /* HAVEUINT32 */
int sha_hash(int *data, int *hash);
int sha_init(int *hash);
char *shahash(char *str); /* NOT THREAD SAFE */
void shahash_r(const char* str, char hashbuf[40]); /* USE ME */
int strprintsha(char *dest, int *hashval);
/* --------------------------------------------------------- */
/* */
/* Hashtable functions */
/* */
/* --------------------------------------------------------- */
typedef int (*KEYHASHFUNC)(const void *key);
typedef int (*KEYCOMPAREFUNC)(const void *key1, const void *key2);
typedef int (*TABLEWALKFUNC)(void *user_data, const void *key, void *data);
typedef void *HASHTABLE;
HASHTABLE ghash_create(int buckets, KEYHASHFUNC hash, KEYCOMPAREFUNC cmp);
void ghash_destroy(HASHTABLE tbl);
void *ghash_get(HASHTABLE tbl, const void *key);
int ghash_put(HASHTABLE tbl, const void *key, void *value);
int ghash_remove(HASHTABLE tbl, const void *key);
int ghash_walk(HASHTABLE tbl, TABLEWALKFUNC func, void *user_data);
int str_hash_code(const char *s);
/* --------------------------------------------------------- */
/* */
/* XML escaping utils */
/* */
/* --------------------------------------------------------- */
char *strescape(pool p, char *buf); /* Escape <>&'" chars */
/* --------------------------------------------------------- */
/* */
/* String pools (spool) functions */
/* */
/* --------------------------------------------------------- */
struct spool_node
{
char *c;
struct spool_node *next;
};
typedef struct spool_struct
{
pool p;
int len;
struct spool_node *last;
struct spool_node *first;
} *spool;
spool spool_new(pool p); /* create a string pool */
void spooler(spool s, ...); /* append all the char * args to the pool, terminate args with s again */
char *spool_print(spool s); /* return a big string */
void spool_add(spool s, char *str); /* add a single char to the pool */
char *spools(pool p, ...); /* wrap all the spooler stuff in one function, the happy fun ball! */
/* --------------------------------------------------------- */
/* */
/* xmlnodes - Document Object Model */
/* */
/* --------------------------------------------------------- */
#define NTYPE_TAG 0
#define NTYPE_ATTRIB 1
#define NTYPE_CDATA 2
#define NTYPE_LAST 2
#define NTYPE_UNDEF -1
/* --------------------------------------------------------------------------
Node structure. Do not use directly! Always use accessor macros
and methods!
-------------------------------------------------------------------------- */
typedef struct xmlnode_t
{
char* name;
unsigned short type;
char* data;
int data_sz;
int complete;
pool p;
struct xmlnode_t* parent;
struct xmlnode_t* firstchild;
struct xmlnode_t* lastchild;
struct xmlnode_t* prev;
struct xmlnode_t* next;
struct xmlnode_t* firstattrib;
struct xmlnode_t* lastattrib;
} _xmlnode, *xmlnode;
/* Node creation routines */
xmlnode xmlnode_wrap(xmlnode x,const char* wrapper);
xmlnode xmlnode_new_tag(const char* name);
xmlnode xmlnode_new_tag_pool(pool p, const char* name);
xmlnode xmlnode_insert_tag(xmlnode parent, const char* name);
xmlnode xmlnode_insert_cdata(xmlnode parent, const char* CDATA, unsigned int size);
xmlnode xmlnode_insert_tag_node(xmlnode parent, xmlnode node);
void xmlnode_insert_node(xmlnode parent, xmlnode node);
xmlnode xmlnode_str(char *str, int len);
xmlnode xmlnode_file(char *file);
xmlnode xmlnode_dup(xmlnode x); /* duplicate x */
xmlnode xmlnode_dup_pool(pool p, xmlnode x);
/* Node Memory Pool */
pool xmlnode_pool(xmlnode node);
xmlnode _xmlnode_new(pool p, const char *name, unsigned int type);
/* Node editing */
void xmlnode_hide(xmlnode child);
void xmlnode_hide_attrib(xmlnode parent, const char *name);
/* Node deletion routine, also frees the node pool! */
void xmlnode_free(xmlnode node);
/* Locates a child tag by name and returns it */
xmlnode xmlnode_get_tag(xmlnode parent, const char* name);
char* xmlnode_get_tag_data(xmlnode parent, const char* name);
/* Attribute accessors */
void xmlnode_put_attrib(xmlnode owner, const char* name, const char* value);
char* xmlnode_get_attrib(xmlnode owner, const char* name);
void xmlnode_put_expat_attribs(xmlnode owner, const char** atts);
/* Bastard am I, but these are fun for internal use ;-) */
void xmlnode_put_vattrib(xmlnode owner, const char* name, void *value);
void* xmlnode_get_vattrib(xmlnode owner, const char* name);
/* Node traversal routines */
xmlnode xmlnode_get_firstattrib(xmlnode parent);
xmlnode xmlnode_get_firstchild(xmlnode parent);
xmlnode xmlnode_get_lastchild(xmlnode parent);
xmlnode xmlnode_get_nextsibling(xmlnode sibling);
xmlnode xmlnode_get_prevsibling(xmlnode sibling);
xmlnode xmlnode_get_parent(xmlnode node);
/* Node information routines */
char* xmlnode_get_name(xmlnode node);
char* xmlnode_get_data(xmlnode node);
int xmlnode_get_datasz(xmlnode node);
int xmlnode_get_type(xmlnode node);
int xmlnode_has_children(xmlnode node);
int xmlnode_has_attribs(xmlnode node);
/* Node-to-string translation */
char* xmlnode2str(xmlnode node);
/* Node-to-terminated-string translation
-- useful for interfacing w/ scripting langs */
char* xmlnode2tstr(xmlnode node);
int xmlnode_cmp(xmlnode a, xmlnode b); /* compares a and b for equality */
int xmlnode2file(char *file, xmlnode node); /* writes node to file */
/* Expat callbacks */
void expat_startElement(void* userdata, const char* name, const char** atts);
void expat_endElement(void* userdata, const char* name);
void expat_charData(void* userdata, const char* s, int len);
/* SHA.H */
/*
* The contents of this file are subject to the Mozilla Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is SHA 180-1 Header File
*
* The Initial Developer of the Original Code is Paul Kocher of
* Cryptography Research. Portions created by Paul Kocher are
* Copyright (C) 1995-9 by Cryptography Research, Inc. All
* Rights Reserved.
*
* Contributor(s):
*
* Paul Kocher
*
* Alternatively, the contents of this file may be used under the
* terms of the GNU General Public License Version 2 or later (the
* "GPL"), in which case the provisions of the GPL are applicable
* instead of those above. If you wish to allow use of your
* version of this file only under the terms of the GPL and not to
* allow others to use your version of this file under the MPL,
* indicate your decision by deleting the provisions above and
* replace them with the notice and other provisions required by
* the GPL. If you do not delete the provisions above, a recipient
* may use your version of this file under either the MPL or the
* GPL.
*/
typedef struct {
unsigned long H[5];
unsigned long W[80];
int lenW;
unsigned long sizeHi,sizeLo;
} SHA_CTX;
void shaInit(SHA_CTX *ctx);
void shaUpdate(SHA_CTX *ctx, unsigned char *dataIn, int len);
void shaFinal(SHA_CTX *ctx, unsigned char hashout[20]);
void shaBlock(unsigned char *dataIn, int len, unsigned char hashout[20]);
/* END SHA.H */
#ifdef __cplusplus
}
#endif
#endif /* INCL_LIBXODE_H */
