conversions to allocation wrappers and various other coding guideliens fixes (issue...
authorRussell Bryant <russell@russellbryant.com>
Mon, 27 Feb 2006 01:37:56 +0000 (01:37 +0000)
committerRussell Bryant <russell@russellbryant.com>
Mon, 27 Feb 2006 01:37:56 +0000 (01:37 +0000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@11231 65c4cc65-6c06-0410-ace0-fbb531ad65f3

indications.c
io.c
jitterbuf.c
jitterbuf.h
loader.c

index e9ca85d..799c192 100644 (file)
@@ -113,10 +113,9 @@ static void playtones_release(struct ast_channel *chan, void *params)
 static void * playtones_alloc(struct ast_channel *chan, void *params)
 {
        struct playtones_def *pd = params;
-       struct playtones_state *ps = malloc(sizeof(struct playtones_state));
-       if (!ps)
+       struct playtones_state *ps;
+       if (!(ps = ast_calloc(1, sizeof(*ps))))
                return NULL;
-       memset(ps, 0, sizeof(struct playtones_state));
        ps->origwfmt = chan->writeformat;
        if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) {
                ast_log(LOG_WARNING, "Unable to set '%s' to signed linear format (write)\n", chan->name);
@@ -300,9 +299,7 @@ int ast_playtones_start(struct ast_channel *chan, int vol, const char *playlst,
                                freq2 = 0;
                }
 
-               d.items = realloc(d.items,(d.nitems+1)*sizeof(struct playtones_item));
-               if (d.items == NULL) {
-                       ast_log(LOG_WARNING, "Realloc failed!\n");
+               if (!(d.items = ast_realloc(d.items, (d.nitems + 1) * sizeof(*d.items)))) {
                        return -1;
                }
                d.items[d.nitems].fac1 = 2.0 * cos(2.0 * M_PI * (freq1 / 8000.0)) * 32768.0;
@@ -433,7 +430,7 @@ static inline void free_zone(struct tone_zone* zone)
                zone->tones = tmp;
        }
        if (zone->ringcadence)
-               free((void*)zone->ringcadence);
+               free(zone->ringcadence);
        free(zone);
 }
 
@@ -547,18 +544,13 @@ int ast_register_indication(struct tone_zone *zone, const char *indication, cons
        }
        if (!ts) {
                /* not there, we have to add */
-               ts = malloc(sizeof(struct tone_zone_sound));
-               if (!ts) {
-                       ast_log(LOG_WARNING, "Out of memory\n");
+               if (!(ts = ast_malloc(sizeof(*ts)))) {
                        ast_mutex_unlock(&tzlock);
                        return -2;
                }
                ts->next = NULL;
        }
-       ts->name = strdup(indication);
-       ts->data = strdup(tonelist);
-       if (ts->name==NULL || ts->data==NULL) {
-               ast_log(LOG_WARNING, "Out of memory\n");
+       if (!(ts->name = ast_strdup(indication)) || !(ts->data = ast_strdup(tonelist))) {
                ast_mutex_unlock(&tzlock);
                return -2;
        }
diff --git a/io.c b/io.c
index 5935c9e..1551fd3 100644 (file)
--- a/io.c
+++ b/io.c
@@ -36,6 +36,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 
 #include "asterisk/io.h"
 #include "asterisk/logger.h"
+#include "asterisk/utils.h"
 
 #ifdef DEBUG_IO
 #define DEBUG DEBUG_M
@@ -82,25 +83,19 @@ struct io_context *io_context_create(void)
 {
        /* Create an I/O context */
        struct io_context *tmp;
-       tmp = malloc(sizeof(struct io_context));
-       if (tmp) {
+       if ((tmp = ast_malloc(sizeof(*tmp)))) {
                tmp->needshrink = 0;
                tmp->fdcnt = 0;
                tmp->maxfdcnt = GROW_SHRINK_SIZE/2;
                tmp->current_ioc = -1;
-               tmp->fds = malloc((GROW_SHRINK_SIZE/2) * sizeof(struct pollfd));
-               if (!tmp->fds) {
+               if (!(tmp->fds = ast_calloc(1, (GROW_SHRINK_SIZE / 2) * sizeof(*tmp->fds)))) {
                        free(tmp);
                        tmp = NULL;
                } else {
-                       memset(tmp->fds, 0, (GROW_SHRINK_SIZE / 2) * sizeof(struct pollfd));
-                       tmp->ior =  malloc((GROW_SHRINK_SIZE / 2) * sizeof(struct io_rec));
-                       if (!tmp->ior) {
+                       if (!(tmp->ior = ast_calloc(1, (GROW_SHRINK_SIZE / 2) * sizeof(*tmp->ior)))) {
                                free(tmp->fds);
                                free(tmp);
                                tmp = NULL;
-                       } else {
-                               memset(tmp->ior, 0, (GROW_SHRINK_SIZE / 2) * sizeof(struct io_rec));
                        }
                }
        }
@@ -126,25 +121,24 @@ static int io_grow(struct io_context *ioc)
        void *tmp;
        DEBUG(ast_log(LOG_DEBUG, "io_grow()\n"));
        ioc->maxfdcnt += GROW_SHRINK_SIZE;
-       tmp = realloc(ioc->ior, (ioc->maxfdcnt + 1) * sizeof(struct io_rec));
-       if (tmp) {
-               ioc->ior = (struct io_rec *)tmp;
-               tmp = realloc(ioc->fds, (ioc->maxfdcnt + 1) * sizeof(struct pollfd));
-               if (tmp) {
+       if ((tmp = ast_realloc(ioc->ior, (ioc->maxfdcnt + 1) * sizeof(*ioc->ior)))) {
+               ioc->ior = tmp;
+               if ((tmp = ast_realloc(ioc->fds, (ioc->maxfdcnt + 1) * sizeof(*ioc->fds)))) {
                        ioc->fds = tmp;
                } else {
                        /*
-                        * Not enough memory for the pollfd.  Not really any need
-                        * to shrink back the iorec's as we'll probably want to
-                        * grow them again soon when more memory is available, and
-                        * then they'll already be the right size
+                        * Failed to allocate enough memory for the pollfd.  Not
+                        * really any need to shrink back the iorec's as we'll
+                        * probably want to grow them again soon when more memory
+                        * is available, and then they'll already be the right size
                         */
                        ioc->maxfdcnt -= GROW_SHRINK_SIZE;
                        return -1;
                }
        } else {
                /*
-                * Out of memory.  We return to the old size, and return a failure
+                * Memory allocation failure.  We return to the old size, and 
+                * return a failure
                 */
                ioc->maxfdcnt -= GROW_SHRINK_SIZE;
                return -1;
@@ -180,10 +174,10 @@ int *ast_io_add(struct io_context *ioc, int fd, ast_io_cb callback, short events
        ioc->fds[ioc->fdcnt].revents = 0;
        ioc->ior[ioc->fdcnt].callback = callback;
        ioc->ior[ioc->fdcnt].data = data;
-       ioc->ior[ioc->fdcnt].id = (int *)malloc(sizeof(int));
-       /* Bonk if we couldn't allocate an int */
-       if (!ioc->ior[ioc->fdcnt].id)
+       if (!(ioc->ior[ioc->fdcnt].id = ast_malloc(sizeof(*ioc->ior[ioc->fdcnt].id)))) {
+               /* Bonk if we couldn't allocate an int */
                return NULL;
+       }
        *(ioc->ior[ioc->fdcnt].id) = ioc->fdcnt;
        ret = ioc->ior[ioc->fdcnt].id;
        ioc->fdcnt++;
index 2fb3497..d6e5f63 100644 (file)
@@ -35,6 +35,7 @@
 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 
 #include "jitterbuf.h"
+#include "asterisk/utils.h"
 
 /*! define these here, just for ancient compiler systems */
 #define JB_LONGMAX 2147483647L
@@ -73,7 +74,7 @@ void jb_reset(jitterbuf *jb)
 {
        /* only save settings */
        jb_conf s = jb->info.conf;
-       memset(jb,0,sizeof(jitterbuf));
+       memset(jb, 0, sizeof(*jb));
        jb->info.conf = s;
 
        /* initialize length */
@@ -85,9 +86,7 @@ jitterbuf * jb_new()
 {
        jitterbuf *jb;
 
-
-       jb = malloc(sizeof(jitterbuf));
-       if (!jb) 
+       if (!(jb = ast_malloc(sizeof(*jb)))) 
                return NULL;
 
        jb_reset(jb);
@@ -236,7 +235,7 @@ static void history_calc_maxbuf(jitterbuf *jb)
                                /* found where it fits */
                                if (toins > jb->hist_maxbuf[j]) {
                                        /* move over */
-                                       memmove(jb->hist_maxbuf+j+1,jb->hist_maxbuf+j, (JB_HISTORY_MAXBUF_SZ-(j+1)) * sizeof(long));
+                                       memmove(jb->hist_maxbuf + j + 1, jb->hist_maxbuf + j, (JB_HISTORY_MAXBUF_SZ - (j + 1)) * sizeof(jb->hist_maxbuf[0]));
                                        /* insert */
                                        jb->hist_maxbuf[j] = toins;
 
@@ -253,7 +252,7 @@ static void history_calc_maxbuf(jitterbuf *jb)
                                /* found where it fits */
                                if (toins < jb->hist_minbuf[j]) {
                                        /* move over */
-                                       memmove(jb->hist_minbuf+j+1,jb->hist_minbuf+j, (JB_HISTORY_MAXBUF_SZ-(j+1)) * sizeof(long));
+                                       memmove(jb->hist_minbuf + j + 1, jb->hist_minbuf + j, (JB_HISTORY_MAXBUF_SZ - (j + 1)) * sizeof(jb->hist_minbuf[0]));
                                        /* insert */
                                        jb->hist_minbuf[j] = toins;
 
@@ -321,21 +320,16 @@ static void history_get(jitterbuf *jb)
 }
 
 /* returns 1 if frame was inserted into head of queue, 0 otherwise */
-static int queue_put(jitterbuf *jb, void *data, int type, long ms, long ts) 
+static int queue_put(jitterbuf *jb, void *data, const enum jb_frame_type type, long ms, long ts) 
 {
        jb_frame *frame;
        jb_frame *p;
        int head = 0;
        long resync_ts = ts - jb->info.resync_offset;
 
-       frame = jb->free;
-       if (frame) {
+       if ((frame = jb->free)) {
                jb->free = frame->next;
-       } else {
-               frame = malloc(sizeof(jb_frame));
-       }
-
-       if (!frame) {
+       } else if (!(frame = ast_malloc(sizeof(*frame)))) {
                jb_err("cannot allocate frame\n");
                return 0;
        }
@@ -514,7 +508,7 @@ static void jb_dbgqueue(jitterbuf *jb)
 }
 #endif
 
-int jb_put(jitterbuf *jb, void *data, int type, long ms, long ts, long now) 
+enum jb_return_code jb_put(jitterbuf *jb, void *data, const enum jb_frame_type type, long ms, long ts, long now) 
 {
        jb_dbg2("jb_put(%x,%x,%ld,%ld,%ld)\n", jb, data, ms, ts, now);
 
@@ -535,7 +529,7 @@ int jb_put(jitterbuf *jb, void *data, int type, long ms, long ts, long now)
 }
 
 
-static int _jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl) 
+static enum jb_return_code _jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl) 
 {
        jb_frame *frame;
        long diff;
@@ -775,9 +769,9 @@ long jb_next(jitterbuf *jb)
        }
 }
 
-int jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl) 
+enum jb_return_code jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl) 
 {
-       int ret = _jb_get(jb,frameout,now,interpl);
+       enum jb_return_code ret = _jb_get(jb, frameout, now, interpl);
 #if 0
        static int lastts=0;
        int thists = ((ret == JB_OK) || (ret == JB_DROP)) ? frameout->ts : 0;
@@ -791,7 +785,7 @@ int jb_get(jitterbuf *jb, jb_frame *frameout, long now, long interpl)
        return ret;
 }
 
-int jb_getall(jitterbuf *jb, jb_frame *frameout) 
+enum jb_return_code jb_getall(jitterbuf *jb, jb_frame *frameout) 
 {
        jb_frame *frame;
        frame = queue_getall(jb);
@@ -805,7 +799,7 @@ int jb_getall(jitterbuf *jb, jb_frame *frameout)
 }
 
 
-int jb_getinfo(jitterbuf *jb, jb_info *stats) 
+enum jb_return_code jb_getinfo(jitterbuf *jb, jb_info *stats) 
 {
 
        history_get(jb);
@@ -815,7 +809,7 @@ int jb_getinfo(jitterbuf *jb, jb_info *stats)
        return JB_OK;
 }
 
-int jb_setconf(jitterbuf *jb, jb_conf *conf) 
+enum jb_return_code jb_setconf(jitterbuf *jb, jb_conf *conf) 
 {
        /* take selected settings from the struct */
 
index cd8be0d..3213534 100644 (file)
@@ -35,21 +35,23 @@ extern "C" {
        /* ms between growing and shrinking; may not be honored if jitterbuffer runs out of space */
 #define JB_ADJUST_DELAY 40
 
-
-/* return codes */
-#define JB_OK          0
-#define JB_EMPTY       1
-#define JB_NOFRAME     2
-#define JB_INTERP      3
-#define JB_DROP                4
-#define JB_SCHED       5
-
-/* frame types */
-#define JB_TYPE_CONTROL        0
-#define JB_TYPE_VOICE  1
-#define JB_TYPE_VIDEO  2  /* reserved */
-#define JB_TYPE_SILENCE        3
-
+enum jb_return_code {
+       /* return codes */
+       JB_OK,            /* 0 */
+       JB_EMPTY,         /* 1 */
+       JB_NOFRAME,       /* 2 */
+       JB_INTERP,        /* 3 */
+       JB_DROP,          /* 4 */
+       JB_SCHED          /* 5 */
+};
+
+enum jb_frame_type {
+       /* frame types */
+       JB_TYPE_CONTROL,  /* 0            */
+       JB_TYPE_VOICE,    /* 1            */
+       JB_TYPE_VIDEO,    /* 2 - reserved */
+       JB_TYPE_SILENCE   /* 3            */
+};
 
 typedef struct jb_conf {
        /* settings */
@@ -85,10 +87,10 @@ typedef struct jb_info {
 } jb_info;
 
 typedef struct jb_frame {
-       void *data;             /* the frame data */
-       long ts;        /* the relative delivery time expected */
-       long ms;        /* the time covered by this frame, in sec/8000 */
-       int  type;      /* the type of frame */
+       void *data;               /* the frame data */
+       long ts;                  /* the relative delivery time expected */
+       long ms;                  /* the time covered by this frame, in sec/8000 */
+       enum jb_frame_type type;  /* the type of frame */
        struct jb_frame *next, *prev;
 } jb_frame;
 
@@ -125,7 +127,7 @@ void                        jb_reset(jitterbuf *jb);
  * JB_DROP: Drop this frame immediately
  * JB_SCHED: Frame added. Call jb_next() to get a new time for the next frame
  */
-int                    jb_put(jitterbuf *jb, void *data, int type, long ms, long ts, long now);
+enum jb_return_code jb_put(jitterbuf *jb, void *data, const enum jb_frame_type type, long ms, long ts, long now);
 
 /* get a frame for time now (receiver's time)  return value is one of
  * JB_OK:  You've got frame!
@@ -134,20 +136,20 @@ int                       jb_put(jitterbuf *jb, void *data, int type, long ms, long ts, long now);
  * JB_INTERP: Please interpolate an interpl-length frame for this time (either we need to grow, or there was a lost frame) 
  * JB_EMPTY: The jb is empty.
  */
-int                    jb_get(jitterbuf *jb, jb_frame *frame, long now, long interpl);
+enum jb_return_code jb_get(jitterbuf *jb, jb_frame *frame, long now, long interpl);
 
 /* unconditionally get frames from jitterbuf until empty */
-int jb_getall(jitterbuf *jb, jb_frame *frameout);
+enum jb_return_code jb_getall(jitterbuf *jb, jb_frame *frameout);
 
 /* when is the next frame due out, in receiver's time (0=EMPTY) 
  * This value may change as frames are added (esp non-audio frames) */
 long                   jb_next(jitterbuf *jb);
 
 /* get jitterbuf info: only "statistics" may be valid */
-int                    jb_getinfo(jitterbuf *jb, jb_info *stats);
+enum jb_return_code jb_getinfo(jitterbuf *jb, jb_info *stats);
 
 /* set jitterbuf conf */
-int                    jb_setconf(jitterbuf *jb, jb_conf *conf);
+enum jb_return_code jb_setconf(jitterbuf *jb, jb_conf *conf);
 
 typedef                void (*jb_output_function_t)(const char *fmt, ...);
 void                   jb_setoutput(jb_output_function_t err, jb_output_function_t warn, jb_output_function_t dbg);
index ae37d75..2639b98 100644 (file)
--- a/loader.c
+++ b/loader.c
@@ -50,6 +50,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include <dlfcn.h>
 #endif
 #include "asterisk/md5.h"
+#include "asterisk/utils.h"
 
 #ifndef RTLD_NOW
 #define RTLD_NOW 0
@@ -290,8 +291,7 @@ static void *find_symbol(struct module *m, const char *name, int verbose)
 
        if (name[0] == '_')
                name++;
-       n1 = alloca(strlen(name)+2); /* room for leading '_' and final '\0' */
-       if (n1 == NULL)
+       if (!(n1 = alloca(strlen(name) + 2))) /* room for leading '_' and final '\0' */
                return NULL;
        n1[0] = '_';
        strcpy(n1+1, name);
@@ -341,9 +341,7 @@ static int __load_resource(const char *resource_name, const struct ast_config *c
                AST_LIST_UNLOCK(&module_list);
                return -1;
        }
-       cur = calloc(1, sizeof(struct module)); 
-       if (!cur) {
-               ast_log(LOG_WARNING, "Out of memory\n");
+       if (!(cur = ast_calloc(1, sizeof(*cur)))) {
                AST_LIST_UNLOCK(&module_list);
                return -1;
        }
@@ -582,8 +580,8 @@ int ast_update_module_list(int (*modentry)(const char *module, const char *descr
 int ast_loader_register(int (*v)(void)) 
 {
        /* XXX Should be more flexible here, taking > 1 verboser XXX */
-       struct loadupdate *tmp = malloc(sizeof (struct loadupdate));
-       if (!tmp)
+       struct loadupdate *tmp; 
+       if (!(tmp = ast_malloc(sizeof(*tmp))))
                return -1;
        tmp->updater = v;
        if (AST_LIST_LOCK(&module_list))