Ticket #51: jabberd2-cleanup1.diff

c2s/authreg.c

@@ -50 +50 @@
 extern int ar_anon_init(authreg_t);
 #endif
 
-char *module_names[] = {
+static const char *module_names[] = {
 #ifdef STORAGE_MYSQL
     "mysql",
 #endif

c2s/authreg_mysql.c

@@ -319 +319 @@
 }
 
 /** Provide a configuration parameter or default value. */
-char * _ar_mysql_param( config_t c, char * key, char * def ) {
+static char * _ar_mysql_param( config_t c, char * key, char * def ) {
     char * value = config_get_one( c, key, 0 );
     if( value == NULL )
       return def;
@@ -332 +332 @@
 /* one each, in order, of the one character sprintf types that are */
 /* expected to follow the escape characters '%' in the template. */
 /* Returns 0 on success, or an error message on failures. */
-char * _ar_mysql_check_template( char * template, char * types ) {
+static char * _ar_mysql_check_template( char * template, char * types ) {
     int pScan = 0;
     int pType = 0;
     char c;
@@ -368 +368 @@
 /* required parameter placeholders.  If there is an error, it is   */
 /* written to the error log. */
 /* Returns 0 on success, or 1 on errors. */
-int _ar_mysql_check_sql( authreg_t ar, char * sql, char * types ) {
+static int _ar_mysql_check_sql( authreg_t ar, char * sql, char * types ) {
   char * error;
 
   error = _ar_mysql_check_template( sql, types );

mio/mio.c

@@ -74 +74 @@
 #define MIO_DEBUG 0
 #endif
 #define mio_debug if(MIO_DEBUG) _mio_debug
-void _mio_debug(int line, const char *msgfmt, ...)
+static void _mio_debug(int line, const char *msgfmt, ...)
 {
     va_list ap;
     va_start(ap,msgfmt);
@@ -102 +102 @@
 }
 
 /** internally accept an incoming connection from a listen sock */
-void _mio_accept(mio_t m, int fd)
+static void _mio_accept(mio_t m, int fd)
 {
     struct sockaddr_storage serv_addr;
     socklen_t addrlen = (socklen_t) sizeof(serv_addr);
@@ -154 +154 @@
 }
 
 /** internally change a connecting socket to a normal one */
-void _mio_connect(mio_t m, int fd)
+static void _mio_connect(mio_t m, int fd)
 {
     mio_type_t type = FD(m,fd).type;
 

router/aci.c

@@ -91 +91 @@
 }
 
 /** see if a username is in an acl */
-int aci_check(xht aci, char *type, char *name) {
+int aci_check(xht aci, const char *type, const char *name) {
     aci_user_t list, scan;
 
     log_debug(ZONE, "checking for '%s' in acl 'all'", name);

router/main.c

@@ -23 +23 @@
 static sig_atomic_t router_shutdown = 0;
 static sig_atomic_t router_logrotate = 0;
 
-void router_signal(int signum)
+static void router_signal(int signum)
 {
     router_shutdown = 1;
 }
 
-void router_signal_hup(int signum)
+static void router_signal_hup(int signum)
 {
     router_logrotate = 1;
 }

router/router.h

@@ -185 +185 @@
 
 xht     aci_load(router_t r);
 void    aci_unload(xht aci);
-int     aci_check(xht acls, char *type, char *name);
+int     aci_check(xht acls, const char *type, const char *name);
 
 int     user_table_load(router_t r);
 void    user_table_unload(router_t r);

sm/mod_iq_vcard.c

@@ -37 +37 @@
  * using real foaf profiles, we'll have bigger things to worry about :)
  */
 
-static char *_iq_vcard_map[] = {
+static const char *_iq_vcard_map[] = {
     "FN",           "fn",
     "NICKNAME",     "nickname",
     "URL",          "url",
@@ -64 +64 @@
     os_t os;
     os_object_t o;
     int i = 0, elem;
-    char *vkey, *dkey, *vskey, ekey[10], cdata[4096];
+    char ekey[10], cdata[4096];
+    const char *vkey, *dkey, *vskey;
 
     log_debug(ZONE, "building object from packet");
 
@@ -107 +108 @@
     pkt_t pkt;
     os_object_t o;
     int i = 0, elem;
-    char *vkey, *dkey, *vskey, ekey[10], *dval;
+    char ekey[10], *dval;
+    const char *vkey, *dkey, *vskey;
     
     log_debug(ZONE, "building packet from object");
 

sm/pres.c

@@ -37 +37 @@
  */
 
 /** select a new top session based on current session presence */
-void _pres_top(user_t user) {
+static void _pres_top(user_t user) {
     sess_t scan;
 
     user->top = NULL;

sm/storage.c

@@ -52 +52 @@
 extern st_ret_t st_sqlite_init(st_driver_t);
 #endif
 
-static char *st_driver_names[] = {
+static const char *st_driver_names[] = {
 #ifdef STORAGE_DB
     "db",
 #endif
@@ -445 +445 @@
     return f;
 }
 
-int _storage_match(st_filter_t f, os_object_t o, os_t os) {
+static int _storage_match(st_filter_t f, os_object_t o, os_t os) {
     void *val;
     os_type_t ot;
     st_filter_t scan;

sx/error.c

@@ -21 +21 @@
 #include "sx.h"
 
 /** if you change these, reflect your changes in the defines in sx.h */
-static char *_stream_errors[] = {
+static const char *_stream_errors[] = {
     "bad-format",
     "bad-namespace-prefix",
     "conflict",
@@ -50 +50 @@
 };
 
 /** send an error */
-void _sx_error(sx_t s, int err, char *text) {
+void _sx_error(sx_t s, int err, const char *text) {
     int len = 0;
     sx_buf_t buf;
 
@@ -85 +85 @@
     s->want_write = 1;
 }
 
-void sx_error(sx_t s, int err, char *text) {
+void sx_error(sx_t s, int err, const char *text) {
     assert(s != NULL);
     assert(err >= 0 && err < stream_err_LAST);
 

sx/ssl.h

@@ -25 +25 @@
 
 #ifdef HAVE_SSL
 
+#include <openssl/md5.h>
 #include <openssl/ssl.h>
 #include <openssl/err.h>
 

sx/sx.c

@@ -199 +199 @@
    if len>0 but data is NULL, the buffer will contain that many bytes
    of garbage, to be overwritten by caller. otherwise, data pointed to
    by 'data' will be copied into buf */
-sx_buf_t _sx_buffer_new(char *data, int len, _sx_notify_t notify, void *notify_arg) {
+sx_buf_t _sx_buffer_new(const char *data, int len, _sx_notify_t notify, void *notify_arg) {
     sx_buf_t buf;
 
     buf = (sx_buf_t) malloc(sizeof(struct _sx_buf_st));
@@ -298 +298 @@
 }
 
 /** debug macro helpers */
-void __sx_debug(char *file, int line, const char *msgfmt, ...) {
+void __sx_debug(const char *file, int line, const char *msgfmt, ...) {
     va_list ap;
     char *pos, message[MAX_DEBUG];
     int sz;
@@ -316 +316 @@
     fflush(stderr);
 }
 
-int __sx_event(char *file, int line, sx_t s, sx_event_t e, void *data) {
+int __sx_event(const char *file, int line, sx_t s, sx_event_t e, void *data) {
     int ret;
 
     _sx_debug(file, line, "tag %d event %d data 0x%x", s->tag, e, data);

sx/sx.h

@@ -166 +166 @@
 sx_plugin_t                 sx_env_plugin(sx_env_t env, sx_plugin_init_t init, ...);
 
 /* send errors and close stuff */
-void                        sx_error(sx_t s, int err, char *text);
+void                        sx_error(sx_t s, int err, const char *text);
 void                        sx_close(sx_t s);
 void                        sx_kill(sx_t s);
 
@@ -197 +197 @@
 int                         _sx_chain_nad_read(sx_t s, nad_t nad);
 
 /* buffer utilities */
-sx_buf_t                    _sx_buffer_new(char *data, int len, _sx_notify_t notify, void *notify_arg);
+sx_buf_t                    _sx_buffer_new(const char *data, int len, _sx_notify_t notify, void *notify_arg);
 void                        _sx_buffer_free(sx_buf_t buf);
 void                        _sx_buffer_clear(sx_buf_t buf);
 void                        _sx_buffer_alloc_margin(sx_buf_t buf, int before, int after);
@@ -213 +213 @@
 void                        _sx_reset(sx_t s);
 
 /* send errors and close stuff */
-void                        _sx_error(sx_t s, int err, char *text);
+void                        _sx_error(sx_t s, int err, const char *text);
 void                        _sx_close(sx_t s);
 
 /** read/write plugin chain */
@@ -347 +347 @@
 #define ZONE __FILE__,__LINE__
 
 /** helper functions for macros when we're debugging */
-void        __sx_debug(char *file, int line, const char *msgfmt, ...);
+void        __sx_debug(const char *file, int line, const char *msgfmt, ...);
 
 /** helper and internal macro for firing the callback */
-int         __sx_event(char *file, int line, sx_t s, sx_event_t e, void *data);
+int         __sx_event(const char *file, int line, sx_t s, sx_event_t e, void *data);
 #define _sx_event(s,e,data) __sx_event(ZONE, s, e, data)
 
 #ifdef SX_DEBUG

util/config.c

@@ -72 +72 @@
 }
 
 /** turn an xml file into a config hash */
-int config_load(config_t c, char *file)
+int config_load(config_t c, const char *file)
 {
     struct build_data bd;
     FILE *f;
@@ -232 +232 @@
 }
 
 /** get the config element for this key */
-config_elem_t config_get(config_t c, char *key)
+config_elem_t config_get(config_t c, const char *key)
 {
     return xhash_get(c->hash, key);
 }
 
 /** get config value n for this key */
-char *config_get_one(config_t c, char *key, int num)
+char *config_get_one(config_t c, const char *key, int num)
 {
     config_elem_t elem = xhash_get(c->hash, key);
 
@@ -252 +252 @@
 }
 
 /** how many values for this key? */
-int config_count(config_t c, char *key)
+int config_count(config_t c, const char *key)
 {
     config_elem_t elem = xhash_get(c->hash, key);
 
@@ -263 +263 @@
 }
 
 /** get an attr for this value */
-char *config_get_attr(config_t c, char *key, int num, char *attr)
+char *config_get_attr(config_t c, const char *key, int num, const char *attr)
 {
     config_elem_t elem = xhash_get(c->hash, key);
 

util/jid.c

@@ -79 +79 @@
 }
 
 /** do stringprep on the pieces */
-int jid_prep_pieces(prep_cache_t pc, char *node, char *domain, char *resource) {
+static int jid_prep_pieces(prep_cache_t pc, char *node, char *domain, char *resource) {
 #ifdef HAVE_IDN
     char str[1024], *prep;
 

util/log.c

@@ -50 +50 @@
     { NULL, -1 }
 };
 
-static int _log_facility(char *facility) {
+static int _log_facility(const char *facility) {
     log_facility_t *lp;
 
     if (facility == NULL) {
@@ -64 +64 @@
     return lp->number;
 }
 
-log_t log_new(log_type_t type, char *ident, char *facility)
+log_t log_new(log_type_t type, const char *ident, const char *facility)
 {
     log_t log;
     int fnum = 0;
@@ -168 +168 @@
 
 #ifdef DEBUG
 /** debug logging */
-void debug_log(char *file, int line, const char *msgfmt, ...)
+void debug_log(const char *file, int line, const char *msgfmt, ...)
 {
     va_list ap;
     char *pos, message[MAX_DEBUG];

util/nad.c

@@ -67 +67 @@
 #define BLOCKSIZE 1024
 
 /** internal: do and return the math and ensure it gets realloc'd */
-int _nad_realloc(void **oblocks, int len)
+static int _nad_realloc(void **oblocks, int len)
 {
     void *nblocks;
     int nlen;
@@ -85 +85 @@
 #define NAD_SAFE(blocks, size, len) if((size) > len) len = _nad_realloc((void**)&(blocks),(size));
 
 /** internal: append some cdata and return the index to it */
-int _nad_cdata(nad_t nad, const char *cdata, int len)
+static int _nad_cdata(nad_t nad, const char *cdata, int len)
 {
     NAD_SAFE(nad->cdata, nad->ccur + len, nad->clen);
 
@@ -95 +95 @@
 }
 
 /** internal: create a new attr on any given elem */
-int _nad_attr(nad_t nad, int elem, int ns, const char *name, const char *val, int vallen)
+static int _nad_attr(nad_t nad, int elem, int ns, const char *name, const char *val, int vallen)
 {
     int attr;
 
@@ -598 +598 @@
     return ns;
 }
 
-void _nad_escape(nad_t nad, int data, int len, int flag)
+static void _nad_escape(nad_t nad, int data, int len, int flag)
 {
     char *c;
     int ic;
@@ -686 +686 @@
 }
 
 /** internal recursive printing function */
-int _nad_lp0(nad_t nad, int elem)
+static int _nad_lp0(nad_t nad, int elem)
 {
     int attr;
     int ndepth;

util/pool.c

@@ -69 +69 @@
 }
 
 /** free a heap */
-void _pool_heap_free(void *arg)
+static void _pool_heap_free(void *arg)
 {
     struct pheap *h = (struct pheap *)arg;
 
@@ -78 +78 @@
 }
 
 /** mem should always be freed last */
-void _pool_cleanup_append(pool p, struct pfree *pf)
+static void _pool_cleanup_append(pool p, struct pfree *pf)
 {
     struct pfree *cur;
 
@@ -96 +96 @@
 }
 
 /** create a cleanup tracker */
-struct pfree *_pool_free(pool p, pool_cleaner f, void *arg)
+static struct pfree *_pool_free(pool p, pool_cleaner f, void *arg)
 {
     struct pfree *ret;
 
@@ -110 +110 @@
 }
 
 /** create a heap and make sure it get's cleaned up */
-struct pheap *_pool_heap(pool p, int size)
+static struct pheap *_pool_heap(pool p, int size)
 {
     struct pheap *ret;
     struct pfree *clean;

util/stanza.c

@@ -23 +23 @@
 /* stanza manipulation */
 
 typedef struct _stanza_error_st {
-    char        *name;
-    char        *type;
-    char        *code;
+    const char  *name;
+    const char  *type;
+    const char  *code;
 } *stanza_error_t;
 
 /** if you change these, reflect your changes in the defines in util.h */

util/str.c

@@ -91 +91 @@
         return atoi(a);
 }
 
-char *j_attr(const char** atts, char *attr)
+char *j_attr(const char** atts, const char *attr)
 {
     int i = 0;
 
@@ -127 +127 @@
     return s;
 }
 
-void _spool_add(spool s, char *goodstr)
+static void _spool_add(spool s, char *goodstr)
 {
     struct spool_node *sn;
 
@@ -353 +353 @@
     return temp;
 }
 
-char *zonestr(char *file, int line)
+static char *zonestr(char *file, int line)
 {
     static char buff[64];
     int i;

util/util.h

@@ -163 +163 @@
 int j_strncasecmp(const char *a, const char *b, int i); /* provides NULL safe strncasecmp wrapper */
 int j_strlen(const char *a); /* provides NULL safe strlen wrapper */
 int j_atoi(const char *a, int def); /* checks for NULL and uses default instead, convienence */
-char *j_attr(const char** atts, char *attr); /* decode attr's (from expat) */
+char *j_attr(const char** atts, const char *attr); /* decode attr's (from expat) */
 char *j_strnchr(const char *s, int c, int n); /* like strchr, but only searches n chars */
 
 /** old convenience function, now in str.c */
@@ -399 +399 @@
 
 typedef struct log_facility_st
 {
-    char        *facility;
+    const char  *facility;
     int         number;
 } log_facility_t;
 
-extern log_t    log_new(log_type_t type, char *ident, char *facility);
+extern log_t    log_new(log_type_t type, const char *ident, const char *facility);
 extern void     log_write(log_t log, int level, const char *msgfmt, ...);
 extern void     log_free(log_t log);
 
@@ -574 +574 @@
 };
 
 extern config_t         config_new(void);
-extern int              config_load(config_t c, char *file);
-extern config_elem_t    config_get(config_t c, char *key);
-extern char             *config_get_one(config_t c, char *key, int num);
-extern int              config_count(config_t c, char *key);
-extern char             *config_get_attr(config_t c, char *key, int num, char *attr);
+extern int              config_load(config_t c, const char *file);
+extern config_elem_t    config_get(config_t c, const char *key);
+extern char             *config_get_one(config_t c, const char *key, int num);
+extern int              config_count(config_t c, const char *key);
+extern char             *config_get_attr(config_t c, const char *key, int num, const char *attr);
 extern void             config_free(config_t);
 
 
@@ -745 +745 @@
 /* debug logging */
 int get_debug_flag(void);
 void set_debug_flag(int v);
-void debug_log(char *file, int line, const char *msgfmt, ...);
+void debug_log(const char *file, int line, const char *msgfmt, ...);
 #define ZONE __FILE__,__LINE__
 #define MAX_DEBUG 8192
 

util/xdata.c

@@ -133 +133 @@
 }
 
 /** option insertion */
-void xdata_option_new(xdata_field_t xdf, char *value, int lvalue, char *label, int llabel) {
+static void xdata_option_new(xdata_field_t xdf, char *value, int lvalue, char *label, int llabel) {
     xdata_option_t xdo;
 
     assert((int) xdf);

util/xhash.c

@@ -25 +25 @@
  * This function uses the ELF hashing algorithm as reprinted in 
  * Andrew Binstock, "Hashing Rehashed," Dr. Dobb's Journal, April 1996.
  */
-int _xhasher(const char *s, int len)
+static int _xhasher(const char *s, int len)
 {
     /* ELF hash uses unsigned chars and unsigned arithmetic for portability */
     const unsigned char *name = (const unsigned char *)s;
@@ -45 +45 @@
 }
 
 
-xhn _xhash_node_new(xht h, int index)
+static xhn _xhash_node_new(xht h, int index)
 {
     xhn n;
     int i = index % h->prime;
@@ -66 +66 @@
 }
 
 
-xhn _xhash_node_get(xht h, const char *key, int len, int index)
+static xhn _xhash_node_get(xht h, const char *key, int len, int index)
 {
     xhn n;
     int i = index % h->prime;