for (i = 0; i < 4; i++) {
if ((*handle)->correlates[i] != NULL) {
- free((*handle)->correlates[i]);
+ zap_safe_free((*handle)->correlates[i]);
(*handle)->correlates[i] = NULL;
}
}
if ((*handle)->buffer != NULL) {
- free((*handle)->buffer);
+ zap_safe_free((*handle)->buffer);
(*handle)->buffer = NULL;
}
dsp_uart_destroy(dhandle);
}
- free(*handle);
+ zap_safe_free(*handle);
*handle = NULL;
}
h = (struct hashtable *)zap_malloc(sizeof(struct hashtable));
if (NULL == h) return NULL; /*oom*/
h->table = (struct entry **)zap_malloc(sizeof(struct entry*) * size);
- if (NULL == h->table) { free(h); return NULL; } /*oom*/
+ if (NULL == h->table) { zap_safe_free(h); return NULL; } /*oom*/
memset(h->table, 0, size * sizeof(struct entry *));
h->tablelength = size;
h->primeindex = pindex;
newtable[index] = e;
}
}
- free(h->table);
+ zap_safe_free(h->table);
h->table = newtable;
}
/* Plan B: realloc instead */
if (e->flags & HASHTABLE_FLAG_FREE_KEY) {
freekey(e->k);
}
- free(e);
+ zap_safe_free(e);
return v;
}
pE = &(e->next);
{
e = table[i];
while (NULL != e)
- { f = e; e = e->next; if (f->flags & HASHTABLE_FLAG_FREE_KEY) freekey(f->k); if (f->flags & HASHTABLE_FLAG_FREE_VALUE) free(f->v); free(f); }
+ { f = e; e = e->next; if (f->flags & HASHTABLE_FLAG_FREE_KEY) freekey(f->k); if (f->flags & HASHTABLE_FLAG_FREE_VALUE) zap_safe_free(f->v); zap_safe_free(f); }
}
- free(h->table);
- free(h);
+ zap_safe_free(h->table);
+ zap_safe_free(h);
}
OZ_DECLARE(struct hashtable_iterator *) hashtable_next(struct hashtable_iterator *i)
remember_parent = itr->parent;
ret = hashtable_iterator_advance(itr);
if (itr->parent == remember_e) { itr->parent = remember_parent; }
- free(remember_e);
+ zap_safe_free(remember_e);
return ret;
}
/*! destroy the queue */
OZ_DECLARE(zap_status_t) zap_queue_destroy(zap_queue_t **queue);
+/* Duplicate string */
+OZ_DECLARE(char *) zap_strdup(const char *str);
+
OZ_DECLARE(zap_size_t) zap_fsk_modulator_generate_bit(zap_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, zap_size_t buflen);
OZ_DECLARE(int32_t) zap_fsk_modulator_generate_carrier_bits(zap_fsk_modulator_t *fsk_trans, uint32_t bits);
OZ_DECLARE(void) zap_fsk_modulator_generate_chan_sieze(zap_fsk_modulator_t *fsk_trans);
TELETONE_API(int) teletone_destroy_session(teletone_generation_session_t *ts)
{
if (ts->buffer) {
- free(ts->buffer);
+ zap_safe_free(ts->buffer);
ts->buffer = NULL;
ts->samples = 0;
}
return ts->samples;
}
-/* don't ask */
-static char *my_strdup (const char *s)
-{
- size_t len = strlen (s) + 1;
- void *new = zap_malloc(len);
-
- if (new == NULL) {
- return NULL;
- }
-
- return (char *) memcpy (new, s, len);
-}
-
TELETONE_API(int) teletone_run(teletone_generation_session_t *ts, const char *cmd)
{
char *data = NULL, *cur = NULL, *end = NULL;
}
do {
- if (!(data = my_strdup(cmd))) {
+ if (!(data = zap_strdup(cmd))) {
return -1;
}
}
}
bottom:
- free(data);
+ zap_safe_free(data);
data = NULL;
if (ts->LOOPS > 0) {
ts->LOOPS--;
int argc = 0;
if (data) {
- mycmd = strdup(data);
+ mycmd = zap_strdup(data);
argc = zap_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
}
if (status != PK_SUCCESS) {
zap_log(ZAP_LOG_ERROR, "Error: PKH_QUEUE_Create failed(%s)!\n",
PKH_ERROR_GetText(status, error_text, sizeof(error_text)));
- free(span_data);
+ zap_safe_free(span_data);
return 0;
}
assert(str != NULL);
- mydata = strdup(str);
+ mydata = zap_strdup(str);
assert(mydata != NULL);
if ((profile_name = strchr(mydata, '@'))) {
}
- free(mydata);
+ zap_safe_free(mydata);
return configured;
}
if (span_data) {
PKH_QUEUE_Destroy(span_data->event_queue);
- free(span_data);
+ zap_safe_free(span_data);
}
return ZAP_SUCCESS;
r2conf.loglevel |= tmplevel;
zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with loglevel %s\n", span->span_id, clevel);
}
- free(logval);
+ zap_safe_free(logval);
} else if (!strcasecmp(var, "advanced_protocol_file")) {
if (!(val = va_arg(ap, char *))) {
break;
int argc = 0;
if (data) {
- mycmd = strdup(data);
+ mycmd = zap_strdup(data);
argc = zap_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
}
assert(str != NULL);
- mydata = strdup(str);
+ mydata = zap_strdup(str);
assert(mydata != NULL);
}
- free(mydata);
+ zap_safe_free(mydata);
return configured;
}
assert(str != NULL);
- mydata = strdup(str);
+ mydata = zap_strdup(str);
assert(mydata != NULL);
}
- free(mydata);
+ zap_safe_free(mydata);
return configured;
void dsp_uart_destroy(dsp_uart_handle_t **handle)
{
if (*handle) {
- free(*handle);
+ zap_safe_free(*handle);
*handle = NULL;
}
}
if (start_len) {
new_buffer->data = zap_malloc(start_len);
if (!new_buffer->data) {
- free(new_buffer);
+ zap_safe_free(new_buffer);
return ZAP_MEMERR;
}
memset(new_buffer->data, 0, start_len);
OZ_DECLARE(void) zap_buffer_destroy(zap_buffer_t **buffer)
{
if (*buffer) {
- free((*buffer)->data);
- free(*buffer);
+ zap_safe_free((*buffer)->data);
+ zap_safe_free(*buffer);
}
*buffer = NULL;
*
*/
+#include "openzap.h"
#include "zap_dso.h"
#include <stdlib.h>
#include <string.h>
DWORD error = GetLastError();
char tmp[80];
sprintf(tmp, "dll open error [%ul]\n", error);
- *err = _strdup(tmp);
+ *err = zap_strdup(tmp);
}
return lib;
DWORD error = GetLastError();
char tmp[80];
sprintf(tmp, "dll sym error [%ul]\n", error);
- *err = _strdup(tmp);
+ *err = zap_strdup(tmp);
}
return (void *)(intptr_t)func; // this should really be addr - zap_dso_func_data
}
zap_dso_lib_t zap_dso_open(const char *path, char **err) {
void *lib = dlopen(path, RTLD_NOW | RTLD_LOCAL);
if (lib == NULL) {
- *err = strdup(dlerror());
+ *err = zap_strdup(dlerror());
}
return lib;
}
void *zap_dso_func_sym(zap_dso_lib_t lib, const char *sym, char **err) {
void *func = dlsym(lib, sym);
if (!func) {
- *err = strdup(dlerror());
+ *err = zap_strdup(dlerror());
}
return func;
}
snprintf(buf, sizeof(buf), "span%d", new_span->span_id);
name = buf;
}
- new_span->name = strdup(name);
+ new_span->name = zap_strdup(name);
zap_span_add(new_span);
*span = new_span;
status = ZAP_SUCCESS;
return ZAP_FAIL;
}
- t_name = strdup(var_name);
- t_val = strdup(value);
+ t_name = zap_strdup(var_name);
+ t_val = zap_strdup(value);
if(hashtable_insert(zchan->variable_hash, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE)) {
return ZAP_SUCCESS;
char *rval = NULL;
if (type && !cmd) {
- dup = strdup(type);
+ dup = zap_strdup(type);
if ((p = strchr(dup, ' '))) {
*p++ = '\0';
cmd = p;
}
if (zap_span_create(zio, &span, name) == ZAP_SUCCESS) {
- span->type = strdup(type);
+ span->type = zap_strdup(type);
d = 0;
zap_log(ZAP_LOG_DEBUG, "created span %d (%s) of type %s\n", span->span_id, span->name, type);
} else if (!strcasecmp(var, "cas-channel")) {
configured += zio->configure_span(span, val, ZAP_CHAN_TYPE_CAS, name, number);
} else if (!strcasecmp(var, "dtmf_hangup")) {
- span->dtmf_hangup = strdup(val);
+ span->dtmf_hangup = zap_strdup(val);
span->dtmf_hangup_len = strlen(val);
} else {
zap_log(ZAP_LOG_ERROR, "unknown span variable '%s'\n", var);
if (zap_test_flag(cur_chan, ZAP_CHANNEL_CONFIGURED)) {
zap_channel_destroy(cur_chan);
}
- free(cur_chan);
+ zap_safe_free(cur_chan);
cur_chan = NULL;
}
}
hashtable_remove(globals.span_hash, (void *)cur_span->name);
zap_safe_free(cur_span->type);
zap_safe_free(cur_span->name);
- free(cur_span);
+ zap_safe_free(cur_span);
cur_span = NULL;
}
}
end = handle->end;
} else {
zap_log(ZAP_LOG_CRIT, "Memory Error!\n");
- free(data);
+ zap_safe_free(data);
return ZAP_FAIL;
}
}
handle->data_len = strlen(buf);
handle->end = (uint8_t *) (handle->data) + handle->data_len;
}
- free(data);
+ zap_safe_free(data);
}
return ret ? ZAP_FAIL : ZAP_SUCCESS;
}
+OZ_DECLARE(char *) zap_strdup(const char *str)
+{
+ zap_size_t len = strlen(str) + 1;
+ void *new = zap_malloc(len);
+
+ if (!new) {
+ return NULL;
+ }
+
+ return (char *)memcpy(new, str, len);
+}
/* For Emacs:
m3ua_span_data_t *span_data = (m3ua_span_data_t *) span->mod_data;
if (span_data) {
- free(span_data);
+ zap_safe_free(span_data);
}
return ZAP_SUCCESS;
zap_safe_free(chan_data);
if (span_data) {
- free(span_data);
+ zap_safe_free(span_data);
}
#ifndef WIN32
pthread_attr_destroy(&thread->attribute);
#endif
- free(thread);
+ zap_safe_free(thread);
return exit_val;
}
fail:
if (thread) {
- free(thread);
+ zap_safe_free(thread);
}
done:
return status;
if (pthread_mutex_destroy(&mp->mutex))
return ZAP_FAIL;
#endif
- free(mp);
+ zap_safe_free(mp);
return ZAP_SUCCESS;
}
projects / thirdparty / freeswitch.git / commitdiff
