static int aac_afh_open(const void *map, size_t mapsize, void **afh_context)
{
int ret;
- struct aac_afh_context *c = para_malloc(sizeof(*c));
+ struct aac_afh_context *c = alloc(sizeof(*c));
c->map = map;
c->mapsize = mapsize;
metadata.count = rv;
PARA_NOTICE_LOG("%d metadata item(s) found\n", rv);
- metadata.tags = para_malloc((metadata.count + 5) * sizeof(mp4ff_tag_t));
+ metadata.tags = alloc((metadata.count + 5) * sizeof(mp4ff_tag_t));
for (i = 0; i < metadata.count; i++) {
mp4ff_tag_t *tag = metadata.tags + i;
consumed += frame_info.bytesconsumed;
if (!frame_info.samples)
goto success;
- btrbuf = para_malloc(2 * frame_info.samples);
+ btrbuf = alloc(2 * frame_info.samples);
for (i = 0; i < frame_info.samples; i++) {
short sh = ((short *)outbuf)[i];
write_int16_host_endian(btrbuf + loaded, sh);
*/
void acl_add_entry(struct list_head *acl, char *addr, int netmask)
{
- struct access_info *ai = para_malloc(sizeof(struct access_info));
+ struct access_info *ai = alloc(sizeof(struct access_info));
inet_pton(AF_INET, addr, &ai->addr);
ai->netmask = netmask;
pard->map_size, &header, &size);
if (size > 0) {
PARA_INFO_LOG("writing header (%zu bytes)\n", size);
- buf = para_malloc(size);
+ buf = alloc(size);
memcpy(buf, header, size);
btr_add_output(buf, size, btrn);
afh_free_header(header, pard->audio_format_num);
close(fd);
return 0;
}
- client = para_malloc(sizeof(*client));
+ client = alloc(sizeof(*client));
client->fd = fd;
client->connect_time = *now;
para_list_add(&client->node, &afs_client_list);
return;
}
sz = PARA_MIN(((size_t)afhi->chunks_total + 1) * 4, ct->size) + 1;
- afhi->chunk_table = para_malloc(sz);
+ afhi->chunk_table = alloc(sz);
for (i = 0; i <= afhi->chunks_total && i * 4 + 3 < ct->size; i++)
afhi->chunk_table[i] = read_u32(ct->data + 4 * i);
}
if (ret < 0)
return ret;
if (!d->hash)
- d->hash = para_malloc(HASH_SIZE);
+ d->hash = alloc(HASH_SIZE);
memcpy(d->hash, tmp_hash, HASH_SIZE);
free(d->path);
ret = get_audio_file_path_of_row(current_aft_row, &d->path);
int (*compar)(const void *, const void *);
int i;
- options->data_ptr = para_malloc(nmemb * sizeof(*options->data_ptr));
+ options->data_ptr = alloc(nmemb * sizeof(*options->data_ptr));
for (i = 0; i < nmemb; i++)
options->data_ptr[i] = options->data + i;
ret = lls_serialize_parse_result(lpr, cmd, NULL, &query.size);
assert(ret >= 0);
query.size += sizeof(*opts);
- query.data = para_malloc(query.size);
+ query.data = alloc(query.size);
opts = query.data;
memset(opts, 0, sizeof(*opts));
slpr = query.data + sizeof(*opts);
size_t afhi_size = sizeof_afhi_buf(afhi);
size_t size = CAB_PATH_OFFSET + path_len + afhi_size
+ sizeof_chunk_table(afhi) + slpr_size;
- char *buf = para_malloc(size);
+ char *buf = alloc(size);
uint32_t pos;
assert(size <= ~(uint32_t)0);
goto out; /* no attribute modifier given */
goto set_atts;
}
- p = para_malloc(len);
+ p = alloc(len);
memcpy(p, arg, len - 1);
p[len - 1] = '\0';
ret = get_attribute_bitnum_by_name(p, &bitnum);
if (inplace)
out = in;
else
- out = para_malloc(len * 2);
+ out = alloc(len * 2);
for (i = 0; i < len; i++) {
int x = (in[i] * factor) >> 6;
ao_info *info;
const struct lls_opt_result *r;
unsigned n;
- struct private_aow_data *pawd = para_malloc(sizeof(*pawd));
+ struct private_aow_data *pawd = alloc(sizeof(*pawd));
ao_initialize();
aow_show_drivers();
if (!FD_ISSET(at->fd, &s->rfds))
return 0;
bufsize = PARA_MAX(1024U, OPT_UINT32_VAL(BUFSIZE));
- buf = para_malloc(bufsize);
+ buf = alloc(bufsize);
ret = recv_bin_buffer(at->fd, buf, bufsize);
PARA_DEBUG_LOG("recv: %d\n", ret);
if (ret == 0)
if (ret < 0)
goto out;
bufsize = PARA_MAX(1024U, OPT_UINT32_VAL(BUFSIZE));
- buf = para_malloc(bufsize);
+ buf = alloc(bufsize);
do {
size_t n = ret = recv_bin_buffer(fd, buf, bufsize);
if (ret <= 0)
n = OPT_GIVEN(USER_ALLOW);
if (n == 0)
return;
- uid_whitelist = para_malloc(n * sizeof(uid_t));
+ uid_whitelist = alloc(n * sizeof(uid_t));
for (i = 0; i < n; i++) {
const char *arg = lls_string_val(i, OPT_RESULT(USER_ALLOW));
int32_t val;
return -E_MISSING_COLON;
*cmd = p + 1;
len = p - txt;
- re = para_malloc(len + 1);
+ re = alloc(len + 1);
strncpy(re, txt, len);
re[len] = '\0';
ret = get_matching_audio_format_nums(re);
if (a->num_writers > 0)
continue; /* already set up */
a->num_writers = 1;
- a->wids = para_malloc(sizeof(int));
- a->writer_lpr = para_malloc(sizeof(struct lls_parse_result *));
+ a->wids = alloc(sizeof(int));
+ a->writer_lpr = alloc(sizeof(struct lls_parse_result *));
a->wids[0] = check_writer_arg_or_die(NULL, a->writer_lpr);
PARA_INFO_LOG("%s writer: %s (default)\n", audio_formats[i],
writer_name(a->wids[0]));
if (encoded_size == (size_t)-1)
encoded_size = strlen(src);
- target = para_malloc(BASE64_MAX_DECODED_SIZE(encoded_size) + 1);
+ target = alloc(BASE64_MAX_DECODED_SIZE(encoded_size) + 1);
for (
i = 0, j = 0, state = 0;
if (ret < 0)
return ret;
query.size = len + 1 + stdin_obj.size;
- query.data = para_malloc(query.size);
+ query.data = alloc(query.size);
memcpy(query.data, lls_input(0, lpr), len + 1);
if (stdin_obj.size > 0)
memcpy((char *)query.data + len + 1, stdin_obj.data,
struct btr_pool *btrp;
PARA_INFO_LOG("%s, %zu bytes\n", name, area_size);
- btrp = para_malloc(sizeof(*btrp));
- btrp->area_start = para_malloc(area_size);
+ btrp = alloc(sizeof(*btrp));
+ btrp->area_start = alloc(area_size);
btrp->area_end = btrp->area_start + area_size;
btrp->rhead = btrp->area_start;
btrp->whead = btrp->area_start;
*/
struct btr_node *btr_new_node(struct btr_node_description *bnd)
{
- struct btr_node *btrn = para_malloc(sizeof(*btrn));
+ struct btr_node *btrn = alloc(sizeof(*btrn));
btrn->name = para_strdup(bnd->name);
btrn->parent = bnd->parent;
if (!wbr) {
/* Make a new wrap buffer combining buf1 and buf2. */
sz = sz1 + sz2;
- buf = para_malloc(sz);
+ buf = alloc(sz);
PARA_DEBUG_LOG("merging input buffers: (%p:%zu, %p:%zu) -> %p:%zu\n",
buf1, sz1, buf2, sz2, buf, sz);
memcpy(buf, buf1, sz1);
assert(i == 2);
/* make a new btrb that combines the two buffers and a br to it. */
sz = szs[0] + szs[1];
- buf = para_malloc(sz);
+ buf = alloc(sz);
PARA_DEBUG_LOG("%s: memory merging input buffers: (%zu, %zu) -> %zu\n",
btrn->name, szs[0], szs[1], sz);
memcpy(buf, bufs[0], szs[0]);
if (cq->num_pending + num_bytes > cq->max_pending)
return -E_QUEUE;
- qc = para_malloc(sizeof(struct queued_chunk));
+ qc = alloc(sizeof(struct queued_chunk));
cq->num_pending += num_bytes;
qc->buf = buf;
qc->num_bytes = num_bytes;
*/
struct chunk_queue *cq_new(size_t max_pending)
{
- struct chunk_queue *cq = para_malloc(sizeof(*cq));
+ struct chunk_queue *cq = alloc(sizeof(*cq));
init_list_head(&cq->q);
cq->max_pending = max_pending;
cq->num_pending = 0;
goto free_moods;
num_pl = ret;
n = num_moods + num_pl;
- mops = para_malloc((n + 1) * sizeof(char *));
+ mops = alloc((n + 1) * sizeof(char *));
for (i = 0; i < num_moods; i++)
mops[i] = make_message("m/%s", moods[i]);
for (i = 0; i < num_pl; i++)
for (i = 0; i < num_inputs; i++)
len += strlen(lls_input(i, ct->lpr)) + 1;
- p = command = para_malloc(len);
+ p = command = alloc(len);
for (i = 0; i < num_inputs; i++) {
const char *str = lls_input(i, ct->lpr);
strcpy(p, str);
free(sbb.iov.iov_base);
if (ret < 0)
goto out;
- ct->challenge_hash = para_malloc(HASH2_SIZE);
-
+ ct->challenge_hash = alloc(HASH2_SIZE);
if (has_feature("sha256", ct)) {
hash2_function((char *)crypt_buf, APC_CHALLENGE_SIZE, ct->challenge_hash);
hash2_to_asc(ct->challenge_hash, buf);
*/
void add_close_on_fork_list(int fd)
{
- struct close_on_fork *cof = para_malloc(sizeof(struct close_on_fork));
+ struct close_on_fork *cof = alloc(sizeof(struct close_on_fork));
if (!initialized) {
init_list_head(&close_on_fork_list);
*/
static char *vss_get_status_flags(unsigned int flags)
{
- char *msg = para_malloc(5 * sizeof(char));
+ char *msg = alloc(5 * sizeof(char));
msg[0] = (flags & VSS_PLAYING)? 'P' : '_';
msg[1] = (flags & VSS_NOMORE)? 'O' : '_';
for (i = 0; p < end; i++)
p += strlen(p) + 1;
argc = i;
- argv = para_malloc((argc + 1) * sizeof(char *));
+ argv = alloc((argc + 1) * sizeof(char *));
for (i = 0, p = iov->iov_base; p < end; i++) {
argv[i] = para_strdup(p);
p += strlen(p) + 1;
int ret;
unsigned char rand_buf[APC_CHALLENGE_SIZE + 2 * SESSION_KEY_LEN];
unsigned char challenge_hash[HASH2_SIZE];
- char *command = NULL, *buf = para_malloc(HANDSHAKE_BUFSIZE) /* must be on the heap */;
+ char *command = NULL, *buf = alloc(HANDSHAKE_BUFSIZE) /* must be on the heap */;
size_t numbytes;
struct command_context cc_struct = {.u = NULL}, *cc = &cc_struct;
struct iovec iov;
if (inplace)
op = ip;
else
- op = para_malloc(length);
+ op = alloc(length);
for (i = 0; i < length / 2; i++) {
/* be careful in that heat, my dear */
int sample = *ip++;
goto unmap;
key_size = footer - begin;
- key = para_malloc(key_size + 1);
+ key = alloc(key_size + 1);
for (i = 0, j = 0; begin + i < footer; i++) {
if (para_isspace(begin[i]))
continue;
/* Copy CCID preference list (u8 array required) */
given = lls_opt_given(r_c);
if (given) {
- ccids = para_malloc(given);
+ ccids = alloc(given);
fo = flowopt_new();
for (i = 0; i < given; i++)
ccids[i] = lls_int32_val(i, r_c);
int read_pattern(int fd, const char *pattern, size_t bufsize, fd_set *rfds)
{
size_t n, len;
- char *buf = para_malloc(bufsize + 1);
+ char *buf = alloc(bufsize + 1);
int ret = read_nonblock(fd, buf, bufsize, rfds, &n);
buf[n] = '\0';
static unsigned char *alloc_matrix(int rows, int cols)
{
- return para_malloc(rows * cols);
+ return alloc(rows * cols);
}
/*
static int invert_mat(unsigned char *src, int k)
{
int irow, icol, row, col, ix, error;
- int *indxc = para_malloc(k * sizeof(int));
- int *indxr = para_malloc(k * sizeof(int));
- int *ipiv = para_malloc(k * sizeof(int)); /* elements used as pivots */
+ int *indxc = alloc(k * sizeof(int));
+ int *indxr = alloc(k * sizeof(int));
+ int *ipiv = alloc(k * sizeof(int)); /* elements used as pivots */
unsigned char c, *p, *id_row = alloc_matrix(1, k),
*temp_row = alloc_matrix(1, k);
* c holds the coefficient of P(x) = Prod (x - p_i), i=0..k-1
* b holds the coefficient for the matrix inversion
*/
- c = para_malloc(k);
- b = para_malloc(k);
- p = para_malloc(k);
+ c = alloc(k);
+ b = alloc(k);
+ p = alloc(k);
for (j = 1, i = 0; i < k; i++, j += k) {
c[i] = 0;
if (k < 1 || k > GF_SIZE + 1 || n > GF_SIZE + 1 || k > n)
return -E_FEC_PARMS;
- parms = para_malloc(sizeof(struct fec_parms));
+ parms = alloc(sizeof(struct fec_parms));
parms->k = k;
parms->n = n;
parms->enc_matrix = alloc_matrix(n, k);
if (ret < 0)
return ret;
/* do the actual decoding */
- slice = para_malloc(k * sizeof(unsigned char *));
+ slice = alloc(k * sizeof(unsigned char *));
for (row = 0; row < k; row++) {
if (idx[row] >= k) {
slice[row] = para_calloc(sz);
}
if (fg->num_slices == 0) {
fg->num_slices = fg->h.slices_per_group;
- fg->idx = para_malloc(fg->num_slices * sizeof(int));
+ fg->idx = alloc(fg->num_slices * sizeof(int));
fg->data = para_calloc(fg->num_slices * sizeof(unsigned char *));
}
r = fg->num_received_slices;
return 0;
}
fg->idx[r] = slice_num;
- fg->data[r] = para_malloc(fg->h.slice_bytes);
+ fg->data[r] = alloc(fg->h.slice_bytes);
memcpy(fg->data[r], buf, fg->h.slice_bytes);
fg->num_received_slices++;
return 1;
EMBRACE(.name = "stdin"));
stdin_task_register(sit, &s);
- fns = para_malloc(OPT_GIVEN(FILTER) * sizeof(*fns));
+ fns = alloc(OPT_GIVEN(FILTER) * sizeof(*fns));
for (i = 0, parent = sit->btrn; i < OPT_GIVEN(FILTER); i++) {
const char *fa = lls_string_val(i, OPT_RESULT(FILTER));
const char *name;
struct btr_node *btrn = fn->btrn;
size_t k, n = frame->header.blocksize;
unsigned channels = FLAC__stream_decoder_get_channels(decoder);
- char *outbuffer = para_malloc(n * channels * 2);
+ char *outbuffer = alloc(n * channels * 2);
if (channels == 1) {
for (k = 0; k < n; k++) {
ret = -E_SEXP_BUILD;
goto free_params;
}
- key = para_malloc(sizeof(*key));
+ key = alloc(sizeof(*key));
key->sexp = sexp;
*result = key;
ret = bits;
goto release_n;
}
PARA_INFO_LOG("successfully read %u bit ssh public key\n", bits);
- key = para_malloc(sizeof(*key));
+ key = alloc(sizeof(*key));
key->num_bytes = ret;
key->sexp = sexp;
*result = key;
struct stream_cipher *sc_new(const unsigned char *data, int len)
{
gcry_error_t gret;
- struct stream_cipher *sc = para_malloc(sizeof(*sc));
+ struct stream_cipher *sc = alloc(sizeof(*sc));
assert(len >= 2 * AES_CRT128_BLOCK_SIZE);
gret = gcry_cipher_open(&sc->handle, GCRY_CIPHER_AES128,
if (strwidth(msg, &len) < 0)
return;
- new = para_malloc(sizeof(struct rb_entry));
+ new = alloc(sizeof(struct rb_entry));
new->color = color;
new->len = len;
new->msg = msg;
sc = accept_sender_client(hss, rfds);
if (!sc)
return;
- phsd = para_malloc(sizeof(*phsd));
+ phsd = alloc(sizeof(*phsd));
sc->private_data = phsd;
phsd->status = HTTP_CONNECTED;
}
s->nbits = nbits;
n = 1 << nbits;
- s->revtab = para_malloc(n * sizeof(uint16_t));
+ s->revtab = alloc(n * sizeof(uint16_t));
for (j = 4; j <= nbits; j++) {
int k = 1 << j;
double freq = 2 * M_PI / k;
s->nbits = nbits;
s->n = n;
n4 = n >> 2;
- s->tcos = para_malloc(n4 * sizeof(fftsample_t));
- s->tsin = para_malloc(n4 * sizeof(fftsample_t));
+ s->tcos = alloc(n4 * sizeof(fftsample_t));
+ s->tsin = alloc(n4 * sizeof(fftsample_t));
for (i = 0; i < n4; i++) {
alpha = 2 * M_PI * (i + 1.0 / 8.0) / n;
int i9e_extract_completions(const char *word, char **string_list,
char ***result)
{
- char **matches = para_malloc(sizeof(char *));
+ char **matches = alloc(sizeof(char *));
int match_count = 0, matches_len = 1;
char **p;
int len = strlen(word);
if (is_prefix(word, cmd, len))
match_count++;
}
- matches = para_malloc((match_count + 1) * sizeof(*matches));
+ matches = alloc((match_count + 1) * sizeof(*matches));
for (i = 0, match_count = 0; (cmd = completers[i].name); i++)
if (is_prefix(word, cmd, len))
matches[match_count++] = para_strdup(cmd);
if (*p == ' ')
p++;
n = end - p + 1;
- ci.word = para_malloc(n + 1);
+ ci.word = alloc(n + 1);
strncpy(ci.word, p, n);
ci.word[n] = '\0';
create_matches:
assert(len >= 2);
assert(src[0] == quote_chars[0]);
- p = dst = para_malloc(len - 1);
+ p = dst = alloc(len - 1);
backslash = false;
for (n = 1;; n++) {
char c;
if (ret < 0)
goto out;
new_v2size = id3_tag_render(v2_tag, NULL);
- v2_buffer = para_malloc(new_v2size);
+ v2_buffer = alloc(new_v2size);
id3_tag_render(v2_tag, v2_buffer);
PARA_INFO_LOG("writing v2 tag (%lu bytes)\n", new_v2size);
ret = write_all(fd, (char *)v2_buffer, new_v2size);
const char *tag_versions[] = {"no", "id3v1", "id3v2", "id3v1+id3v2"};
afhi->chunks_total = 0;
- afhi->chunk_table = para_malloc(chunk_table_size * sizeof(uint32_t));
+ afhi->chunk_table = alloc(chunk_table_size * sizeof(uint32_t));
while (1) {
int freq, br;
struct timeval tmp, cct; /* current chunk time */
}
fn->min_iqs = 0;
mad_synth_frame(&pmd->synth, &pmd->frame);
- outbuffer = para_malloc(pmd->synth.pcm.length * 2 * pmd->channels);
+ outbuffer = alloc(pmd->synth.pcm.length * 2 * pmd->channels);
loaded = 0;
for (i = 0; i < pmd->synth.pcm.length; i++) {
int sample = MAD_TO_SHORT(pmd->synth.pcm.samples[0][i]);
*/
struct flowopts *flowopt_new(void)
{
- struct flowopts *new = para_malloc(sizeof(*new));
+ struct flowopts *new = alloc(sizeof(*new));
init_list_head(&new->sockopts);
return new;
void flowopt_add(struct flowopts *fo, int lev, int opt,
const char *name, const void *val, int len)
{
- struct pre_conn_opt *new = para_malloc(sizeof(*new));
+ struct pre_conn_opt *new = alloc(sizeof(*new));
new->sock_option = opt;
new->sock_level = lev;
new->opt_val = NULL;
new->opt_len = 0;
} else {
- new->opt_val = para_malloc(len);
+ new->opt_val = alloc(len);
new->opt_len = len;
memcpy(new->opt_val, val, len);
}
PARA_INFO_LOG("%" PRIu32 " seconds, %d frames/chunk\n",
afhi->seconds_total, frames_per_chunk);
ct_size = 250;
- afhi->chunk_table = para_malloc(ct_size * sizeof(uint32_t));
+ afhi->chunk_table = alloc(ct_size * sizeof(uint32_t));
afhi->chunk_table[0] = 0;
afhi->chunk_table[1] = afhi->header_len;
oss.returned = afhi->header_len;
struct btr_node *btrn = fn->btrn;
int ret, oret;
size_t iqs;
- struct OggVorbis_File *vf = para_malloc(sizeof(*vf));
+ struct OggVorbis_File *vf = alloc(sizeof(*vf));
PARA_NOTICE_LOG("iqs: %zu, min_iqs: %zu, opening ov callbacks\n",
btr_get_input_queue_size(btrn), fn->min_iqs);
goto out;
}
have = 0;
- buf = para_malloc(OGGDEC_OUTPUT_CHUNK_SIZE);
+ buf = alloc(OGGDEC_OUTPUT_CHUNK_SIZE);
for (;;) {
ret = ov_read(pod->vf, buf + have, OGGDEC_OUTPUT_CHUNK_SIZE - have,
ENDIAN, 2 /* 16 bit */, 1 /* signed */, NULL);
unsigned char *blob;
size_t decoded_size;
int ret;
- struct asymmetric_key *key = para_malloc(sizeof(*key));
+ struct asymmetric_key *key = alloc(sizeof(*key));
ret = decode_public_key(key_file, &blob, &decoded_size);
if (ret < 0)
return ret;
if (inlen < 0)
return -E_RSA;
- priv = para_malloc(sizeof(*priv));
+ priv = alloc(sizeof(*priv));
ret = get_private_key(key_file, &priv->rsa);
if (ret < 0) {
free(priv);
struct stream_cipher *sc_new(const unsigned char *data, int len)
{
- struct stream_cipher *sc = para_malloc(sizeof(*sc));
+ struct stream_cipher *sc = alloc(sizeof(*sc));
assert(len >= 2 * AES_CRT128_BLOCK_SIZE);
sc->aes = EVP_CIPHER_CTX_new();
*dst = (typeof(*dst)) {
/* Add one for the terminating zero byte. */
- .iov_base = para_malloc(inlen + 1),
+ .iov_base = alloc(inlen + 1),
.iov_len = inlen
};
ret = EVP_EncryptUpdate(ctx, dst->iov_base, &outlen, src->iov_base, inlen);
}
PARA_DEBUG_LOG("meta packet size: %zu bytes\n", sz);
/* terminating zero byte for the last sprintf() */
- buf = p = para_malloc(sz + 1);
+ buf = p = alloc(sz + 1);
memcpy(p, OPUS_COMMENT_HEADER, strlen(OPUS_COMMENT_HEADER));
p += strlen(OPUS_COMMENT_HEADER);
write_u32(p, comment_sz);
if (tmp_skip > 0) {
short *in = pcm + ctx->channels * tmp_skip;
- short *out = para_malloc(bytes);
+ short *out = alloc(bytes);
memcpy(out, in, bytes);
free(pcm);
pcm = out;
/* don't care for anything except opus eos */
if (op->e_o_s && ctx->os.serialno == ctx->opus_serialno)
ctx->eos = true;
- output = para_malloc(sizeof(short) * MAX_FRAME_SIZE * ctx->channels);
+ output = alloc(sizeof(short) * MAX_FRAME_SIZE * ctx->channels);
ret = opus_multistream_decode(ctx->st, (unsigned char *)op->packet,
op->bytes, output, MAX_FRAME_SIZE, 0);
if (ret < 0) {
PARA_ERROR_LOG("could not open %s\n", dev);
return ret;
}
- h = para_malloc(sizeof(*h));
+ h = alloc(sizeof(*h));
h->fd = ret;
*handle = h;
return 1;
static void init_shuffle_map(void)
{
unsigned n, num_inputs = lls_num_inputs(play_lpr);
- shuffle_map = para_malloc(num_inputs * sizeof(unsigned));
+ shuffle_map = alloc(num_inputs * sizeof(unsigned));
for (n = 0; n < num_inputs; n++)
shuffle_map[n] = n;
if (!OPT_GIVEN(RANDOMIZE))
if (!p)
return NULL;
len = p - kma;
- result = para_malloc(len + 1);
+ result = alloc(len + 1);
memcpy(result, kma, len);
result[len] = '\0';
return result;
if (len == 1 && isprint(*seq))
return seq;
- sseq = para_malloc(2 + 2 * len + 1);
+ sseq = alloc(2 + 2 * len + 1);
sseq[0] = '0';
sseq[1] = 'x';
for (n = 0; n < len; n++) {
char **result;
int i;
- result = para_malloc((NUM_MAPPED_KEYS + 1) * sizeof(char *));
+ result = alloc((NUM_MAPPED_KEYS + 1) * sizeof(char *));
FOR_EACH_MAPPED_KEY(i) {
char *seq = get_key_map_seq(i);
result[i] = seq;
*lprp = NULL;
if (!ra || !*ra) {
argc = 1;
- argv = para_malloc(2 * sizeof(char*));
+ argv = alloc(2 * sizeof(char*));
argv[0] = para_strdup("http");
argv[1] = NULL;
} else {
data.output_frames = num_frames * ctx->ratio + 1;
out_samples = data.output_frames * ctx->channels;
- in_float = para_malloc(num_samples * sizeof(float));
+ in_float = alloc(num_samples * sizeof(float));
src_short_to_float_array(in, in_float, num_samples);
data.data_in = in_float;
- data.data_out = para_malloc(out_samples * sizeof(float));
+ data.data_out = alloc(out_samples * sizeof(float));
ret = src_process(ctx->src_state, &data);
free(in_float);
if (ret != 0) {
return -E_LIBSAMPLERATE;
}
out_samples = data.output_frames_gen * ctx->channels;
- out = para_malloc(out_samples * sizeof(short));
+ out = alloc(out_samples * sizeof(short));
src_float_to_short_array(data.data_out, out, out_samples);
free(data.data_out);
*result = out;
*/
struct task *task_register(struct task_info *info, struct sched *s)
{
- struct task *t = para_malloc(sizeof(*t));
+ struct task *t = alloc(sizeof(*t));
assert(info->post_select);
score_objs[SCORECOL_AFT_ROW].size = size;
size = score_table_desc.column_descriptions[SCORECOL_SCORE].data_size;
- score_objs[SCORECOL_SCORE].data = para_malloc(size);
+ score_objs[SCORECOL_SCORE].data = alloc(size);
score_objs[SCORECOL_SCORE].size = size;
*(long *)(score_objs[SCORECOL_SCORE].data) = score;
return ret;
new_score--;
obj.size = sizeof(long);
- obj.data = para_malloc(obj.size);
+ obj.data = alloc(obj.size);
*(long *)obj.data = new_score;
PARA_DEBUG_LOG("new score: %ld, rank %u/%u\n", new_score, new_pos, n);
return osl(osl_update_object(score_table, row, SCORECOL_SCORE, &obj));
if (n == 0) {
ss->num_listen_fds = 1;
- ss->listen_addresses = para_malloc(sizeof(char *));
+ ss->listen_addresses = alloc(sizeof(char *));
ss->listen_addresses[0] = NULL;
- ss->listen_fds = para_malloc(sizeof(int));
+ ss->listen_fds = alloc(sizeof(int));
ss->listen_fds[0] = -1;
} else {
ss->num_listen_fds = n;
- ss->listen_addresses = para_malloc(n * sizeof(char *));
- ss->listen_fds = para_malloc(n * sizeof(int));
+ ss->listen_addresses = alloc(n * sizeof(char *));
+ ss->listen_fds = alloc(n * sizeof(int));
FOR_EACH_LISTEN_FD(i, ss) {
ss->listen_addresses[i] = para_strdup(lls_string_val(i,
listen_address_opt_result));
sct->argv = argv;
if (!OPT_GIVEN(LISTEN_ADDRESS)) {
sct->num_listen_fds = 1;
- sct->listen_fds = para_malloc(sizeof(int));
+ sct->listen_fds = alloc(sizeof(int));
ret = para_listen_simple(IPPROTO_TCP, port);
if (ret < 0)
goto err;
sct->listen_fds[0] = ret;
} else {
sct->num_listen_fds = OPT_GIVEN(LISTEN_ADDRESS);
- sct->listen_fds = para_malloc(sct->num_listen_fds * sizeof(int));
+ sct->listen_fds = alloc(sct->num_listen_fds * sizeof(int));
for (n = 0; n < OPT_GIVEN(LISTEN_ADDRESS); n++) {
const char *arg;
arg = lls_string_val(n, OPT_RESULT(LISTEN_ADDRESS));
*/
if (sbb->iov.iov_len == (size_t)-1)
return -E_SB_PACKET_SIZE;
- sbb->iov.iov_base = para_malloc(sbb->iov.iov_len + 1);
+ sbb->iov.iov_base = alloc(sbb->iov.iov_len + 1);
return 0; /* ready to read body */
success:
*result = c->sbb;
}
PARA_DEBUG_LOG("meta packet size: %zu bytes\n", sz);
/* terminating zero byte for the last sprintf() */
- buf = p = para_malloc(sz + 1);
+ buf = p = alloc(sz + 1);
write_u32(p, comment_sz);
p += 4;
strcpy(p, tags->comment);
if (new_frame_size <= 0)
continue;
samples = new_frame_size * psd->shi.channels;
- btr_output = para_malloc(2 * samples);
+ btr_output = alloc(2 * samples);
for (i = 0; i < samples; i++)
btr_output[i] = read_u16(output + i + skip_idx);
btr_add_output((char *)btr_output, samples * 2, btrn);
*
* \sa malloc(3).
*/
-__must_check __malloc void *para_malloc(size_t size)
+__must_check __malloc void *alloc(size_t size)
{
void *p;
*/
__must_check __malloc void *para_calloc(size_t size)
{
- void *ret = para_malloc(size);
+ void *ret = alloc(size);
memset(ret, 0, size);
return ret;
size_t size = 150;
va_list aq;
- *result = para_malloc(size + 1);
+ *result = alloc(size + 1);
va_copy(aq, ap);
ret = vsnprintf(*result, size, fmt, aq);
va_end(aq);
if (!(flags & FELF_DISCARD_FIRST) || start != buf) {
if (flags & FELF_READ_ONLY) {
size_t s = end - start;
- char *b = para_malloc(s + 1);
+ char *b = alloc(s + 1);
memcpy(b, start, s);
b[s] = '\0';
ret = line_handler(b, private_data);
int ret, sz_off = (b->flags & PBF_SIZE_PREFIX)? 5 : 0;
if (!b->buf) {
- b->buf = para_malloc(128);
+ b->buf = alloc(128);
b->size = 128;
b->offset = 0;
}
char *out;
int ret, state = 0;
- out = para_malloc(strlen(buf) + 1);
+ out = alloc(strlen(buf) + 1);
*out = '\0';
*word = out;
for (in = buf; *in; in++) {
static int create_argv_offset(int offset, const char *buf, const char *delim,
char ***result)
{
- char *word, **argv = para_malloc((offset + 1) * sizeof(char *));
+ char *word, **argv = alloc((offset + 1) * sizeof(char *));
const char *p;
int i, ret;
if (ret == 0)
return 1;
size = regerror(ret, preg, NULL, 0);
- buf = para_malloc(size);
+ buf = alloc(size);
regerror(ret, preg, buf, size);
PARA_ERROR_LOG("%s\n", buf);
free(buf);
char *p;
assert(len < (size_t)-1);
- p = para_malloc(len + 1);
+ p = alloc(len + 1);
if (len > 0)
memcpy(p, src, len);
p[len] = '\0';
return -ERRNO_TO_PARA_ERROR(errno);
if (num_wchars == 0)
return 0;
- dest = para_malloc((num_wchars + 1) * sizeof(*dest));
+ dest = alloc((num_wchars + 1) * sizeof(*dest));
src = s;
memset(&state, 0, sizeof(state));
num_wchars = mbsrtowcs(dest, &src, num_wchars, &state);
num_wchars = mbsrtowcs(NULL, &src, 0, &state);
if (num_wchars == (size_t)-1)
return -ERRNO_TO_PARA_ERROR(errno);
- wcs = para_malloc((num_wchars + 1) * sizeof(*wcs));
+ wcs = alloc((num_wchars + 1) * sizeof(*wcs));
memset(&state, 0, sizeof(state));
num_wchars = mbsrtowcs(wcs, &src, num_wchars + 1, &state);
assert(num_wchars != (size_t)-1);
}
wcs[n] = L'\0';
n = wcstombs(NULL, wcs, 0) + 1;
- *result = para_malloc(n);
+ *result = alloc(n);
num_wchars = wcstombs(*result, wcs, n);
assert(num_wchars != (size_t)-1);
free(wcs);
)
__must_check void *para_realloc(void *p, size_t size);
-__must_check __malloc void *para_malloc(size_t size);
+__must_check __malloc void *alloc(size_t size);
__must_check __malloc void *para_calloc(size_t size);
__must_check __malloc char *para_strdup(const char *s);
close(fd);
goto fail;
}
- buddy = para_malloc(sizeof(*buddy));
+ buddy = alloc(sizeof(*buddy));
buddy->fd = fd;
buddy->sbi = sbi + i;
buddy->ping_received = false;
r_b = FILTER_CMD_OPT_RESULT(SYNC, BUDDY, lpr);
n = lls_opt_given(r_b);
- sbi = para_malloc(n * sizeof(*sbi));
+ sbi = alloc(n * sizeof(*sbi));
PARA_INFO_LOG("initializing buddy info array of length %u\n", n);
for (i = 0; i < n; i++) {
const char *url = lls_string_val(i, r_b);
size_t len = strlen(url);
- char *host = para_malloc(len + 1);
+ char *host = alloc(len + 1);
int port;
struct addrinfo *ai;
apc_free_pubkey(pubkey);
continue;
}
- u = para_malloc(sizeof(*u));
+ u = alloc(sizeof(*u));
u->name = para_strdup(n);
u->pubkey = pubkey;
u->perms = 0;
ret = fec_new(k, n, &fc->parms);
if (ret < 0)
return ret;
- fc->src_data = para_malloc(k * sizeof(char *));
+ fc->src_data = alloc(k * sizeof(char *));
for (i = 0; i < k; i++)
- fc->src_data[i] = para_malloc(fc->mps);
- fc->enc_buf = para_malloc(fc->mps);
+ fc->src_data[i] = alloc(fc->mps);
+ fc->enc_buf = alloc(fc->mps);
fc->state = FEC_STATE_READY_TO_RUN;
fc->next_header_time.tv_sec = 0;
{
int *bof;
- fn->private_data = para_malloc(sizeof(int));
+ fn->private_data = alloc(sizeof(int));
bof = fn->private_data;
*bof = 1;
}
free(buf);
if (ret < 0)
goto err;
- header = para_malloc(WAV_HEADER_LEN);
+ header = alloc(WAV_HEADER_LEN);
make_wav_header(ch, rate, header);
btr_add_output(header, WAV_HEADER_LEN, btrn);
ret = -E_WAV_SUCCESS;
size_t ct_size = 250;
int ret, count = 0, num_frames, num_superframes;
- afhi->chunk_table = para_malloc(ct_size * sizeof(uint32_t));
+ afhi->chunk_table = alloc(ct_size * sizeof(uint32_t));
afhi->chunk_table[0] = 0;
afhi->chunk_table[1] = afhi->header_len;
/* even though src is in UTF-8, strlen() should DTRT */
inbytes = inbytesleft = strlen(src);
outbytes = outbytesleft = 4 * inbytes + 2; /* hope that's enough */
- *dst = outbuf = para_malloc(outbytes);
+ *dst = outbuf = alloc(outbytes);
sz = iconv(cd, ICONV_CAST &inbuf, &inbytesleft, &outbuf, &outbytesleft);
if (sz == (size_t)-1) {
ret = -ERRNO_TO_PARA_ERROR(errno);
result->size = 16 + 8 + 5 * 2 + title_bytes + artist_bytes
+ orig_cr_bytes + comment_bytes + orig_rating_bytes;
PARA_DEBUG_LOG("cdo is %zu bytes\n", (size_t)result->size);
- p = result->ptr = para_malloc(result->size);
+ p = result->ptr = alloc(result->size);
memcpy(p, content_description_header, 16);
p += 16;
write_u64(p, result->size);
result->size += 2 + sizeof(album_tag_header) + 2 + 2 + 2 + album_bytes;
result->size += 2 + sizeof(year_tag_header) + 2 + 2 + 2 + year_bytes;
- p = result->ptr = para_malloc(result->size);
+ p = result->ptr = alloc(result->size);
memcpy(p, extended_content_header, 16);
p += 16;
write_u64(p, result->size);
if (top.reserved2 != 2)
return -E_NO_WMA;
p++; /* objects start at p */
- top.objects = para_malloc(top.num_objects * sizeof(struct asf_object));
+ top.objects = alloc(top.num_objects * sizeof(struct asf_object));
ret = read_asf_objects(p, top.size - (p - map), top.num_objects,
top.objects, &ton);
if (ret < 0)
int i, l, j, k, level, n = src->n;
init_vlc(dst, VLCBITS, n, src->huffbits, src->huffcodes, 4);
- pwd->run_table[didx] = para_malloc(n * sizeof(uint16_t));
- pwd->level_table[didx] = para_malloc(n * sizeof(uint16_t));
+ pwd->run_table[didx] = alloc(n * sizeof(uint16_t));
+ pwd->level_table[didx] = alloc(n * sizeof(uint16_t));
i = 2;
level = 1;
k = 0;
if (fn->min_iqs > len)
goto success;
out_size = WMA_OUTPUT_BUFFER_SIZE;
- out = para_malloc(out_size);
+ out = alloc(out_size);
ret = wma_decode_superframe(pwd, out, &out_size,
(uint8_t *)in + WMA_FRAME_SKIP);
if (ret < 0) {
if (!wa || !*wa) {
writer_num = default_writer_id();
cmd = WRITE_CMD(writer_num);
- argv = para_malloc(2 * sizeof(char *));
+ argv = alloc(2 * sizeof(char *));
argc = 1;
argv[0] = para_strdup(lls_command_name(cmd));
argv[1] = NULL;
static struct mp_ast_node *ast_node_raw(int id)
{
- struct mp_ast_node *node = para_malloc(sizeof(struct mp_ast_node));
+ struct mp_ast_node *node = alloc(sizeof(struct mp_ast_node));
node->id = id;
return node;
}
{
struct mp_ast_node *node = ast_node_raw(id);
node->num_children = 1;
- node->children = para_malloc(sizeof(struct mp_ast_node *));
+ node->children = alloc(sizeof(struct mp_ast_node *));
node->children[0] = child;
return node;
}
{
struct mp_ast_node *node = ast_node_raw(id);
node->num_children = 2;
- node->children = para_malloc(2 * sizeof(struct mp_ast_node *));
+ node->children = alloc(2 * sizeof(struct mp_ast_node *));
node->children[0] = left;
node->children[1] = right;
return node;
projects / paraslash.git / commitdiff