static bool test_talloc_ptrtype(const struct torture_context *ctx)
{
void *top = talloc_new(ctx);
struct struct1 {
int foo;
int bar;
} *s1, *s2, **s3, ***s4;
const char *location1;
const char *location2;
const char *location3;
const char *location4;
bool ret = false;
if (!top)
goto out;
s1 = talloc_ptrtype(top, s1);location1 = __location__;
if (!s1)
goto out;
ok1(talloc_get_size(s1) == sizeof(struct struct1));
ok1(strcmp(location1, talloc_get_name(s1)) == 0);
s2 = talloc_array_ptrtype(top, s2, 10);location2 = __location__;
if (!s2)
goto out;
ok1(talloc_get_size(s2) == (sizeof(struct struct1) * 10));
ok1(strcmp(location2, talloc_get_name(s2)) == 0);
s3 = talloc_array_ptrtype(top, s3, 10);location3 = __location__;
if (!s3)
goto out;
ok1(talloc_get_size(s3) == (sizeof(struct struct1 *) * 10));
torture_assert_str_equal("ptrtype", location3, talloc_get_name(s3),
"talloc_array_ptrtype() sets the wrong name");
s4 = talloc_array_ptrtype(top, s4, 10);location4 = __location__;
if (!s4)
goto out;
ok1(talloc_get_size(s4) == (sizeof(struct struct1 **) * 10));
torture_assert_str_equal("ptrtype", location4, talloc_get_name(s4),
"talloc_array_ptrtype() sets the wrong name");
ret = true;
out:
talloc_free(top);
return ret;
}
/** Steal one VP
*
* @param[in] ctx to move VALUE_PAIR into
* @param[in] vp VALUE_PAIR to move into the new context.
*/
void pairsteal(TALLOC_CTX *ctx, VALUE_PAIR *vp)
{
(void) talloc_steal(ctx, vp);
/*
* The DA may be unknown. If we're stealing the VPs to a
* different context, copy the unknown DA. We use the VP
* as a context here instead of "ctx", so that when the
* VP is freed, so is the DA.
*
* Since we have no introspection into OTHER VPs using
* the same DA, we can't have multiple VPs use the same
* DA. So we might as well tie it to this VP.
*/
if (vp->da->flags.is_unknown) {
DICT_ATTR *da;
char *p;
size_t size;
size = talloc_get_size(vp->da);
p = talloc_zero_array(vp, char, size);
da = (DICT_ATTR *) p;
talloc_set_type(p, DICT_ATTR);
memcpy(da, vp->da, size);
vp->da = da;
}
static void do_test1(void)
{
struct hash_count_context *hc = NULL;
TALLOC_CTX *mem_ctx = talloc_new(NULL);
struct timeval interval = {1, 0};
TDB_DATA key;
int count = 0;
int ret, i;
key.dptr = (uint8_t *)discard_const(KEY);
key.dsize = strlen(KEY);
ret = hash_count_increment(hc, key);
assert(ret == EINVAL);
ret = hash_count_init(mem_ctx, interval, NULL, NULL, &hc);
assert(ret == EINVAL);
ret = hash_count_init(mem_ctx, interval, test1_handler, &count, &hc);
assert(ret == 0);
assert(hc != NULL);
for (i=0; i<10; i++) {
ret = hash_count_increment(hc, key);
assert(ret == 0);
assert(count == i+1);
}
talloc_free(hc);
ret = talloc_get_size(mem_ctx);
assert(ret == 0);
talloc_free(mem_ctx);
}
static SMB_INO_T stream_inode(const SMB_STRUCT_STAT *sbuf, const char *sname)
{
MD5_CTX ctx;
unsigned char hash[16];
SMB_INO_T result;
char *upper_sname;
DEBUG(10, ("stream_inode called for %lu/%lu [%s]\n",
(unsigned long)sbuf->st_ex_dev,
(unsigned long)sbuf->st_ex_ino, sname));
upper_sname = talloc_strdup_upper(talloc_tos(), sname);
SMB_ASSERT(upper_sname != NULL);
MD5Init(&ctx);
MD5Update(&ctx, (const unsigned char *)&(sbuf->st_ex_dev),
sizeof(sbuf->st_ex_dev));
MD5Update(&ctx, (const unsigned char *)&(sbuf->st_ex_ino),
sizeof(sbuf->st_ex_ino));
MD5Update(&ctx, (unsigned char *)upper_sname,
talloc_get_size(upper_sname)-1);
MD5Final(hash, &ctx);
TALLOC_FREE(upper_sname);
/* Hopefully all the variation is in the lower 4 (or 8) bytes! */
memcpy(&result, hash, sizeof(result));
DEBUG(10, ("stream_inode returns %lu\n", (unsigned long)result));
return result;
}
/**
\details Expand the available space in the buffer to size
\param push Pointer to the mapirops_push structure
\param extra_size The extra size to add to current buffer
\return MAPIROPS_ERR_SUCCESS on success, MAPIROPS_ERR_BUFSIZE if an
overflow is detected, or MAPIROPS_ERR_ALLOC if realloc failed.
*/
enum mapirops_err_code mapirops_push_expand(struct mapirops_push *push,
uint32_t extra_size)
{
uint32_t size = extra_size + push->offset;
if (size < push->offset) {
return mapirops_error(MAPIROPS_ERR_BUFSIZE, LOG_ERR,
"Overflow in push_expand to %u", size);
}
if (talloc_get_size(push->data.data) >= size) {
return MAPIROPS_ERR_SUCCESS;
}
push->data.length += MAPIROPS_CHUNK_SIZE;
if ((size + 1) > push->data.length) {
push->data.length = size + 1;
}
push->data.data = talloc_realloc(push, push->data.data, uint8_t,
push->data.length);
if (push->data.data == NULL) {
return mapirops_error(MAPIROPS_ERR_ALLOC, LOG_ERR,
"Failed to push_expand to %u", push->data.length);
}
return MAPIROPS_ERR_SUCCESS;
}
static char *example_obj_list(struct manifest *m, struct ccan_file *f)
{
struct manifest **deps = talloc_array(f, struct manifest *, 0);
char **lines, *list;
unsigned int i;
/* This one for a start. */
add_dep(&deps, m->basename);
/* Other modules implied by includes. */
for (lines = get_ccan_file_lines(f); *lines; lines++) {
unsigned preflen = strspn(*lines, " \t");
if (strstarts(*lines + preflen, "#include <ccan/")) {
char *modname;
modname = talloc_strdup(f, *lines + preflen
+ strlen("#include <ccan/"));
modname[strcspn(modname, "/")] = '\0';
if (!have_mod(deps, modname))
add_dep(&deps, modname);
}
}
list = talloc_strdup(f, "");
for (i = 0; i < talloc_get_size(deps) / sizeof(*deps); i++) {
if (deps[i]->compiled[COMPILE_NORMAL])
list = talloc_asprintf_append(list, " %s",
deps[i]->compiled
[COMPILE_NORMAL]);
}
return list;
}
static bstr read_file(struct mp_log *log, const char *filename)
{
FILE *f = fopen(filename, "rb");
if (!f) {
mp_verbose(log, "Can't open config file: %s\n", mp_strerror(errno));
return (bstr){0};
}
char *data = talloc_array(NULL, char, 0);
size_t size = 0;
while (1) {
size_t left = talloc_get_size(data) - size;
if (!left) {
MP_TARRAY_GROW(NULL, data, size + 1);
continue;
}
size_t s = fread(data + size, 1, left, f);
if (!s) {
if (ferror(f))
mp_err(log, "Error reading config file.\n");
fclose(f);
MP_TARRAY_APPEND(NULL, data, size, 0);
return (bstr){data, size - 1};
}
size += s;
}
assert(0);
}
int daemon_check_srvids(struct ctdb_context *ctdb, TDB_DATA indata,
TDB_DATA *outdata)
{
uint64_t *ids;
int i, num_ids;
uint8_t *results;
if ((indata.dsize % sizeof(uint64_t)) != 0) {
DEBUG(DEBUG_ERR, ("Bad indata in daemon_check_srvids, "
"size=%d\n", (int)indata.dsize));
return -1;
}
ids = (uint64_t *)indata.dptr;
num_ids = indata.dsize / 8;
results = talloc_zero_array(outdata, uint8_t, (num_ids+7)/8);
if (results == NULL) {
DEBUG(DEBUG_ERR, ("talloc failed in daemon_check_srvids\n"));
return -1;
}
for (i=0; i<num_ids; i++) {
if (srvid_exists(ctdb->srv, ids[i]) == 0) {
results[i/8] |= (1 << (i%8));
}
}
outdata->dptr = (uint8_t *)results;
outdata->dsize = talloc_get_size(results);
return 0;
}
static struct mp_audio *play(struct af_instance *af, struct mp_audio *data)
{
struct af_resample *s = af->priv;
struct mp_audio *in = data;
struct mp_audio *out = af->data;
int in_size = data->len;
int in_samples = in_size / (data->bps * data->nch);
int out_samples = avresample_available(s->avrctx) +
av_rescale_rnd(get_delay(s) + in_samples,
s->ctx.out_rate, s->ctx.in_rate, AV_ROUND_UP);
int out_size = out->bps * out_samples * out->nch;
if (talloc_get_size(out->audio) < out_size)
out->audio = talloc_realloc_size(out, out->audio, out_size);
af->delay = out->bps * av_rescale_rnd(get_delay(s),
s->ctx.out_rate, s->ctx.in_rate,
AV_ROUND_UP);
#if !USE_SET_CHANNEL_MAPPING
reorder_channels(data->audio, s->reorder_in, data->bps, data->nch, in_samples);
#endif
out_samples = avresample_convert(s->avrctx,
(uint8_t **) &out->audio, out_size, out_samples,
(uint8_t **) &in->audio, in_size, in_samples);
*data = *out;
#if USE_SET_CHANNEL_MAPPING
if (needs_reorder(s->reorder_out, out->nch)) {
if (talloc_get_size(s->reorder_buffer) < out_size)
s->reorder_buffer = talloc_realloc_size(s, s->reorder_buffer, out_size);
data->audio = s->reorder_buffer;
out_samples = avresample_convert(s->avrctx_out,
(uint8_t **) &data->audio, out_size, out_samples,
(uint8_t **) &out->audio, out_size, out_samples);
}
#else
reorder_channels(data->audio, s->reorder_out, out->bps, out->nch, out_samples);
#endif
data->len = out->bps * out_samples * out->nch;
return data;
}
static bool have_mod(struct manifest *deps[], const char *basename)
{
unsigned int i;
for (i = 0; i < talloc_get_size(deps) / sizeof(*deps); i++)
if (strcmp(deps[i]->basename, basename) == 0)
return true;
return false;
}
static void set_min_out_buffer_size(struct bstr *outbuf, int len)
{
size_t oldlen = talloc_get_size(outbuf->start);
if (oldlen < len) {
assert(outbuf->start); // talloc context should be already set
mp_msg(MSGT_DECAUDIO, MSGL_V, "Increasing filtered audio buffer size "
"from %zd to %d\n", oldlen, len);
outbuf->start = talloc_realloc_size(NULL, outbuf->start, len);
}
}
static bool test_free_children(void)
{
void *root;
const char *p1, *p2, *name, *name2;
talloc_enable_null_tracking();
root = talloc_new(NULL);
p1 = talloc_strdup(root, "foo1");
p2 = talloc_strdup(p1, "foo2");
talloc_set_name(p1, "%s", "testname");
talloc_free_children(p1);
/* check its still a valid talloc ptr */
talloc_get_size(talloc_get_name(p1));
if (strcmp(talloc_get_name(p1), "testname") != 0) {
return false;
}
talloc_set_name(p1, "%s", "testname");
name = talloc_get_name(p1);
talloc_free_children(p1);
/* check its still a valid talloc ptr */
talloc_get_size(talloc_get_name(p1));
torture_assert("name", name == talloc_get_name(p1), "name ptr changed");
torture_assert("namecheck", strcmp(talloc_get_name(p1), "testname") == 0,
"wrong name");
CHECK_BLOCKS("name1", p1, 2);
/* note that this does not free the old child name */
talloc_set_name_const(p1, "testname2");
name2 = talloc_get_name(p1);
/* but this does */
talloc_free_children(p1);
torture_assert("namecheck", strcmp(talloc_get_name(p1), "testname2") == 0,
"wrong name");
CHECK_BLOCKS("name1", p1, 1);
talloc_report_full(root, stdout);
talloc_free(root);
return true;
}
cbuf* cbuf_swapptr(cbuf* b, char** ptr, size_t len)
{
void* p = talloc_parent(*ptr);
SWAP(b->buf, *ptr, char*);
talloc_steal(b, b->buf);
talloc_steal(p, *ptr);
b->size = talloc_get_size(b->buf);
b->pos = (len == -1) ? strlen(b->buf) : len;
assert(b->pos <= b->size);
return b;
}
// Render "fake" highlights, because using actual dvd sub highlight elements
// is too hard, and would require changes to libavcodec's dvdsub decoder.
// Note: a proper solution would introduce something like
// SD_CTRL_APPLY_DVDNAV, which would crop the vobsub frame,
// and apply the current CLUT.
void mp_nav_get_highlight(void *priv, struct mp_osd_res res,
struct sub_bitmaps *out_imgs)
{
struct MPContext *mpctx = priv;
struct mp_nav_state *nav = mpctx->nav_state;
pthread_mutex_lock(&nav->osd_lock);
struct sub_bitmap *sub = nav->hi_elem;
if (!sub)
sub = talloc_zero(nav, struct sub_bitmap);
nav->hi_elem = sub;
if (!is_valid_size(nav->vidsize)) {
pthread_mutex_unlock(&nav->osd_lock);
return;
}
int sizes[2] = {nav->vidsize[0], nav->vidsize[1]};
if (sizes[0] != nav->subsize[0] || sizes[1] != nav->subsize[1]) {
talloc_free(sub->bitmap);
sub->bitmap = talloc_array(sub, uint32_t, sizes[0] * sizes[1]);
memset(sub->bitmap, 0x80, talloc_get_size(sub->bitmap));
nav->subsize[0] = sizes[0];
nav->subsize[1] = sizes[1];
}
out_imgs->num_parts = 0;
if (nav->hi_visible) {
sub->x = nav->highlight[0];
sub->y = nav->highlight[1];
sub->w = MPCLAMP(nav->highlight[2] - sub->x, 0, sizes[0]);
sub->h = MPCLAMP(nav->highlight[3] - sub->y, 0, sizes[1]);
sub->stride = sub->w * 4;
if (sub->w > 0 && sub->h > 0)
nav->outputs[out_imgs->num_parts++] = *sub;
}
if (nav->overlays[0])
nav->outputs[out_imgs->num_parts++] = *nav->overlays[0];
if (nav->overlays[1])
nav->outputs[out_imgs->num_parts++] = *nav->overlays[1];
if (out_imgs->num_parts) {
out_imgs->parts = nav->outputs;
out_imgs->format = SUBBITMAP_RGBA;
osd_rescale_bitmaps(out_imgs, sizes[0], sizes[1], res, 0);
}
pthread_mutex_unlock(&nav->osd_lock);
}
/*
test lzxpress
*/
static bool test_lzxpress(struct torture_context *test)
{
TALLOC_CTX *tmp_ctx = talloc_new(test);
uint8_t *data;
const char *fixed_data = "this is a test. and this is a test too";
const uint8_t fixed_out[] = { 0x00, 0x20, 0x00, 0x04, 0x74, 0x68, 0x69, 0x73,
0x20, 0x10, 0x00, 0x61, 0x20, 0x74, 0x65, 0x73,
0x74, 0x2E, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x9F,
0x00, 0x04, 0x20, 0x74, 0x6F, 0x6F, 0x00, 0x00,
0x00, 0x00 };
ssize_t c_size;
uint8_t *out, *out2;
data = talloc_size(tmp_ctx, 1023);
out = talloc_size(tmp_ctx, 2048);
memset(out, 0x42, talloc_get_size(out));
torture_comment(test, "lzxpress fixed compression\n");
c_size = lzxpress_compress((const uint8_t *)fixed_data,
strlen(fixed_data),
out,
talloc_get_size(out));
torture_assert_int_equal(test, c_size, sizeof(fixed_out), "fixed lzxpress_compress size");
torture_assert_mem_equal(test, out, fixed_out, c_size, "fixed lzxpress_compress data");
torture_comment(test, "lzxpress fixed decompression\n");
out2 = talloc_size(tmp_ctx, strlen(fixed_data));
c_size = lzxpress_decompress(out,
sizeof(fixed_out),
out2,
talloc_get_size(out2));
torture_assert_int_equal(test, c_size, strlen(fixed_data), "fixed lzxpress_decompress size");
torture_assert_mem_equal(test, out2, fixed_data, c_size, "fixed lzxpress_decompress data");
return true;
}
void stat_cache_delete(const char *name)
{
char *lname = talloc_strdup_upper(talloc_tos(), name);
if (!lname) {
return;
}
DEBUG(10,("stat_cache_delete: deleting name [%s] -> %s\n",
lname, name ));
memcache_delete(smbd_memcache(), STAT_CACHE,
data_blob_const(lname, talloc_get_size(lname)-1));
TALLOC_FREE(lname);
}
static struct mp_audio *play(struct af_instance *af, struct mp_audio *data)
{
struct af_resample *s = af->priv;
struct mp_audio *in = data;
struct mp_audio *out = af->data;
out->samples = avresample_available(s->avrctx) +
av_rescale_rnd(get_delay(s) + in->samples,
s->ctx.out_rate, s->ctx.in_rate, AV_ROUND_UP);
mp_audio_realloc_min(out, out->samples);
af->delay = get_delay(s) / (double)s->ctx.in_rate;
#if !USE_SET_CHANNEL_MAPPING
do_reorder(in, s->reorder_in);
#endif
if (out->samples) {
out->samples = avresample_convert(s->avrctx,
(uint8_t **) out->planes, out->samples * out->sstride, out->samples,
(uint8_t **) in->planes, in->samples * in->sstride, in->samples);
if (out->samples < 0)
return NULL; // error
}
*data = *out;
#if USE_SET_CHANNEL_MAPPING
if (needs_reorder(s->reorder_out, out->nch)) {
if (af_fmt_is_planar(out->format)) {
reorder_planes(data, s->reorder_out);
} else {
int out_size = out->samples * out->sstride;
if (talloc_get_size(s->reorder_buffer) < out_size)
s->reorder_buffer = talloc_realloc_size(s, s->reorder_buffer, out_size);
data->planes[0] = s->reorder_buffer;
int out_samples = avresample_convert(s->avrctx_out,
(uint8_t **) data->planes, out_size, out->samples,
(uint8_t **) out->planes, out_size, out->samples);
assert(out_samples == data->samples);
}
}
#else
do_reorder(data, s->reorder_out);
#endif
return data;
}
static void msg_pool_usage_helper(const void *ptr, int depth, int max_depth, int is_ref, void *_s)
{
const char *name = talloc_get_name(ptr);
struct msg_pool_usage_state *state = (struct msg_pool_usage_state *)_s;
if (is_ref) {
sprintf_append(state->mem_ctx, &state->s, &state->len, &state->buflen,
"%*sreference to: %s\n", depth*4, "", name);
return;
}
if (depth == 0) {
sprintf_append(state->mem_ctx, &state->s, &state->len, &state->buflen,
"%stalloc report on '%s' (total %6lu bytes in %3lu blocks)\n",
(max_depth < 0 ? "full " :""), name,
(unsigned long)talloc_total_size(ptr),
(unsigned long)talloc_total_blocks(ptr));
return;
}
if (strcmp(name, "char") == 0) {
/*
* Print out the first 50 bytes of the string
*/
sprintf_append(state->mem_ctx, &state->s, &state->len,
&state->buflen,
"%*s%-30s contains %6lu bytes in %3lu blocks "
"(ref %d): %*s\n", depth*4, "",
name,
(unsigned long)talloc_total_size(ptr),
(unsigned long)talloc_total_blocks(ptr),
talloc_reference_count(ptr),
MIN(50, talloc_get_size(ptr)),
(char *)ptr);
return;
}
sprintf_append(state->mem_ctx, &state->s, &state->len, &state->buflen,
"%*s%-30s contains %6lu bytes in %3lu blocks (ref %d)\n",
depth*4, "",
name,
(unsigned long)talloc_total_size(ptr),
(unsigned long)talloc_total_blocks(ptr),
talloc_reference_count(ptr));
}
int main(void)
{
struct srvid_context *srv;
TALLOC_CTX *mem_ctx = talloc_new(NULL);
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
int ret;
int count = 0;
ret = srvid_init(mem_ctx, &srv);
assert(ret == 0);
ret = srvid_register(srv, tmp_ctx, TEST_SRVID, test_handler, &count);
assert(ret == 0);
ret = srvid_exists(srv, TEST_SRVID);
assert(ret == 0);
ret = srvid_dispatch(srv, TEST_SRVID, 0, tdb_null);
assert(ret == 0);
assert(count == 1);
ret = srvid_deregister(srv, TEST_SRVID, NULL);
assert(ret == ENOENT);
ret = srvid_deregister(srv, TEST_SRVID, &count);
assert(ret == 0);
ret = srvid_register(srv, tmp_ctx, TEST_SRVID, test_handler, &count);
assert(ret == 0);
talloc_free(tmp_ctx);
ret = srvid_exists(srv, TEST_SRVID);
assert(ret == ENOENT);
ret = srvid_dispatch(srv, TEST_SRVID, 0, tdb_null);
assert(ret == ENOENT);
talloc_free(srv);
assert(talloc_get_size(mem_ctx) == 0);
talloc_free(mem_ctx);
return 0;
}
static void do_test2(void)
{
struct hash_count_context *hc;
TALLOC_CTX *mem_ctx = talloc_new(NULL);
struct timeval interval = {1, 0};
TDB_DATA key;
uint64_t count = 0;
int ret;
key.dptr = (uint8_t *)discard_const(KEY);
key.dsize = strlen(KEY);
ret = hash_count_init(mem_ctx, interval, test2_handler, &count, &hc);
assert(ret == 0);
ret = hash_count_increment(hc, key);
assert(ret == 0);
assert(count == 1);
hash_count_expire(hc, &ret);
assert(ret == 0);
ret = hash_count_increment(hc, key);
assert(ret == 0);
assert(count == 2);
sleep(2);
ret = hash_count_increment(hc, key);
assert(ret == 0);
assert(count == 1);
sleep(2);
hash_count_expire(hc, &ret);
assert(ret == 1);
talloc_free(hc);
ret = talloc_get_size(mem_ctx);
assert(ret == 0);
talloc_free(mem_ctx);
}
static void get_bitmaps(struct sh_sub *sh, struct osd_state *osd,
struct sub_bitmaps *res)
{
struct sd_lavc_priv *priv = sh->context;
if (priv->endpts != MP_NOPTS_VALUE && (osd->sub_pts >= priv->endpts ||
osd->sub_pts < priv->endpts - 300))
clear(priv);
if (!osd->support_rgba)
return;
if (priv->bitmaps_changed && priv->count > 0)
priv->outbitmaps = talloc_memdup(priv, priv->inbitmaps,
talloc_get_size(priv->inbitmaps));
bool pos_changed = false;
// Hope that PGS subs set these and 720/576 works for dvb subs
int inw = priv->avctx->width;
if (!inw)
inw = 720;
int inh = priv->avctx->height;
if (!inh)
inh = 576;
struct mp_eosd_res *d = &osd->dim;
double xscale = (double) (d->w - d->ml - d->mr) / inw;
double yscale = (double) (d->h - d->mt - d->mb) / inh;
for (int i = 0; i < priv->count; i++) {
struct sub_bitmap *bi = &priv->inbitmaps[i];
struct sub_bitmap *bo = &priv->outbitmaps[i];
#define SET(var, val) pos_changed |= var != (int)(val); var = (val)
SET(bo->x, bi->x * xscale + d->ml);
SET(bo->y, bi->y * yscale + d->mt);
SET(bo->dw, bi->w * xscale);
SET(bo->dh, bi->h * yscale);
}
res->parts = priv->outbitmaps;
res->part_count = priv->count;
if (priv->bitmaps_changed)
res->bitmap_id = ++res->bitmap_pos_id;
else if (pos_changed)
res->bitmap_pos_id++;
priv->bitmaps_changed = false;
res->type = SUBBITMAP_RGBA;
res->scaled = xscale != 1 || yscale != 1;
}
/*
dump talloc memory hierarchy, returning it as a blob to the client
*/
int32_t ctdb_dump_memory(struct ctdb_context *ctdb, TDB_DATA *outdata)
{
char *report;
size_t reportlen;
report = talloc_report_str(outdata, NULL);
if (report == NULL) {
DEBUG(DEBUG_ERR,
(__location__ " talloc_report_str failed\n"));
return -1;
}
reportlen = talloc_get_size(report);
if (reportlen > 0) {
reportlen -= 1; /* strip trailing zero */
}
outdata->dptr = (uint8_t *)report;
outdata->dsize = reportlen;
return 0;
}
NTSTATUS file_name_hash(connection_struct *conn,
const char *name, uint32_t *p_name_hash)
{
char *fullpath = NULL;
/* Set the hash of the full pathname. */
fullpath = talloc_asprintf(talloc_tos(),
"%s/%s",
conn->connectpath,
name);
if (!fullpath) {
return NT_STATUS_NO_MEMORY;
}
*p_name_hash = hash(fullpath, talloc_get_size(fullpath), 0);
DEBUG(10,("file_name_hash: %s hash 0x%x\n",
fullpath,
(unsigned int)*p_name_hash ));
TALLOC_FREE(fullpath);
return NT_STATUS_OK;
}
r = db_ctdb_marshall_record(talloc_tos(), reqid, key, header, data);
if (r == NULL) {
talloc_free(m);
return NULL;
}
if (m == NULL) {
m = (struct ctdb_marshall_buffer *)talloc_zero_size(
mem_ctx, offsetof(struct ctdb_marshall_buffer, data));
if (m == NULL) {
goto done;
}
m->db_id = db_id;
}
m_size = talloc_get_size(m);
r_size = talloc_get_size(r);
m2 = (struct ctdb_marshall_buffer *)talloc_realloc_size(
mem_ctx, m, m_size + r_size);
if (m2 == NULL) {
talloc_free(m);
goto done;
}
memcpy(m_size + (uint8_t *)m2, r, r_size);
m2->count++;
done:
talloc_free(r);
static bool test_pool_steal(void)
{
void *root;
void *pool;
void *p1, *p2;
void *p1_2, *p2_2;
size_t hdr;
size_t ofs1, ofs2;
root = talloc_new(NULL);
pool = talloc_pool(root, 1024);
p1 = talloc_size(pool, 4 * 16);
torture_assert("pool allocate 4 * 16", p1 != NULL, "failed ");
memset(p1, 0x11, talloc_get_size(p1));
p2 = talloc_size(pool, 4 * 16);
torture_assert("pool allocate 4 * 16", p2 > p1, "failed: !(p2 > p1) ");
memset(p2, 0x11, talloc_get_size(p2));
ofs1 = PTR_DIFF(p2, p1);
hdr = ofs1 - talloc_get_size(p1);
talloc_steal(root, p1);
talloc_steal(root, p2);
talloc_free(pool);
p1_2 = p1;
#if 1 /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
p1_2 = talloc_realloc_size(root, p1, 5 * 16);
torture_assert("pool realloc 5 * 16", p1_2 > p2, "failed: pointer not changed");
memset(p1_2, 0x11, talloc_get_size(p1_2));
ofs1 = PTR_DIFF(p1_2, p2);
ofs2 = talloc_get_size(p2) + hdr;
torture_assert("pool realloc ", ofs1 == ofs2, "failed: pointer offset unexpected");
p2_2 = talloc_realloc_size(root, p2, 3 * 16);
torture_assert("pool realloc 5 * 16", p2_2 == p2, "failed: pointer changed");
memset(p2_2, 0x11, talloc_get_size(p2_2));
#endif /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
talloc_free(p1_2);
p2_2 = p2;
#if 1 /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
/* now we should reclaim the full pool */
p2_2 = talloc_realloc_size(root, p2, 8 * 16);
torture_assert("pool realloc 8 * 16", p2_2 == p1, "failed: pointer not expected");
p2 = p2_2;
memset(p2_2, 0x11, talloc_get_size(p2_2));
/* now we malloc and free the full pool space */
p2_2 = talloc_realloc_size(root, p2, 2 * 1024);
torture_assert("pool realloc 2 * 1024", p2_2 != p1, "failed: pointer not expected");
memset(p2_2, 0x11, talloc_get_size(p2_2));
#endif /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
talloc_free(p2_2);
talloc_free(root);
return true;
}
static bool test_pool(void)
{
void *pool;
void *p1, *p2, *p3, *p4;
void *p2_2;
pool = talloc_pool(NULL, 1024);
p1 = talloc_size(pool, 80);
memset(p1, 0x11, talloc_get_size(p1));
p2 = talloc_size(pool, 20);
memset(p2, 0x11, talloc_get_size(p2));
p3 = talloc_size(p1, 50);
memset(p3, 0x11, talloc_get_size(p3));
p4 = talloc_size(p3, 1000);
memset(p4, 0x11, talloc_get_size(p4));
#if 1 /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
p2_2 = talloc_realloc_size(pool, p2, 20+1);
torture_assert("pool realloc 20+1", p2_2 == p2, "failed: pointer changed");
memset(p2, 0x11, talloc_get_size(p2));
p2_2 = talloc_realloc_size(pool, p2, 20-1);
torture_assert("pool realloc 20-1", p2_2 == p2, "failed: pointer changed");
memset(p2, 0x11, talloc_get_size(p2));
p2_2 = talloc_realloc_size(pool, p2, 20-1);
torture_assert("pool realloc 20-1", p2_2 == p2, "failed: pointer changed");
memset(p2, 0x11, talloc_get_size(p2));
talloc_free(p3);
/* this should reclaim the memory of p4 and p3 */
p2_2 = talloc_realloc_size(pool, p2, 400);
torture_assert("pool realloc 400", p2_2 == p2, "failed: pointer changed");
memset(p2, 0x11, talloc_get_size(p2));
talloc_free(p1);
/* this should reclaim the memory of p1 */
p2_2 = talloc_realloc_size(pool, p2, 800);
torture_assert("pool realloc 800", p2_2 == p1, "failed: pointer not changed");
p2 = p2_2;
memset(p2, 0x11, talloc_get_size(p2));
/* this should do a malloc */
p2_2 = talloc_realloc_size(pool, p2, 1800);
torture_assert("pool realloc 1800", p2_2 != p2, "failed: pointer not changed");
p2 = p2_2;
memset(p2, 0x11, talloc_get_size(p2));
/* this should reclaim the memory from the pool */
p3 = talloc_size(pool, 80);
torture_assert("pool alloc 80", p3 == p1, "failed: pointer changed");
memset(p3, 0x11, talloc_get_size(p3));
talloc_free(p2);
talloc_free(p3);
p1 = talloc_size(pool, 80);
memset(p1, 0x11, talloc_get_size(p1));
p2 = talloc_size(pool, 20);
memset(p2, 0x11, talloc_get_size(p2));
talloc_free(p1);
p2_2 = talloc_realloc_size(pool, p2, 20-1);
torture_assert("pool realloc 20-1", p2_2 == p2, "failed: pointer changed");
memset(p2, 0x11, talloc_get_size(p2));
p2_2 = talloc_realloc_size(pool, p2, 20-1);
torture_assert("pool realloc 20-1", p2_2 == p2, "failed: pointer changed");
memset(p2, 0x11, talloc_get_size(p2));
/* this should do a malloc */
p2_2 = talloc_realloc_size(pool, p2, 1800);
torture_assert("pool realloc 1800", p2_2 != p2, "failed: pointer not changed");
p2 = p2_2;
memset(p2, 0x11, talloc_get_size(p2));
/* this should reclaim the memory from the pool */
p3 = talloc_size(pool, 800);
torture_assert("pool alloc 800", p3 == p1, "failed: pointer changed");
memset(p3, 0x11, talloc_get_size(p3));
#endif /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
talloc_free(pool);
return true;
}
static bool test_talloc_ptrtype(void)
{
void *top = talloc_new(NULL);
struct struct1 {
int foo;
int bar;
} *s1, *s2, **s3, ***s4;
const char *location1;
const char *location2;
const char *location3;
const char *location4;
printf("test: ptrtype\n# TALLOC PTRTYPE\n");
s1 = talloc_ptrtype(top, s1);location1 = __location__;
if (talloc_get_size(s1) != sizeof(struct struct1)) {
printf("failure: ptrtype [\n"
"talloc_ptrtype() allocated the wrong size %lu (should be %lu)\n"
"]\n", (unsigned long)talloc_get_size(s1),
(unsigned long)sizeof(struct struct1));
return false;
}
if (strcmp(location1, talloc_get_name(s1)) != 0) {
printf("failure: ptrtype [\n"
"talloc_ptrtype() sets the wrong name '%s' (should be '%s')\n]\n",
talloc_get_name(s1), location1);
return false;
}
s2 = talloc_array_ptrtype(top, s2, 10);location2 = __location__;
if (talloc_get_size(s2) != (sizeof(struct struct1) * 10)) {
printf("failure: ptrtype [\n"
"talloc_array_ptrtype() allocated the wrong size "
"%lu (should be %lu)\n]\n",
(unsigned long)talloc_get_size(s2),
(unsigned long)(sizeof(struct struct1)*10));
return false;
}
if (strcmp(location2, talloc_get_name(s2)) != 0) {
printf("failure: ptrtype [\n"
"talloc_array_ptrtype() sets the wrong name '%s' (should be '%s')\n]\n",
talloc_get_name(s2), location2);
return false;
}
s3 = talloc_array_ptrtype(top, s3, 10);location3 = __location__;
if (talloc_get_size(s3) != (sizeof(struct struct1 *) * 10)) {
printf("failure: ptrtype [\n"
"talloc_array_ptrtype() allocated the wrong size "
"%lu (should be %lu)\n]\n",
(unsigned long)talloc_get_size(s3),
(unsigned long)(sizeof(struct struct1 *)*10));
return false;
}
torture_assert_str_equal("ptrtype", location3, talloc_get_name(s3),
"talloc_array_ptrtype() sets the wrong name");
s4 = talloc_array_ptrtype(top, s4, 10);location4 = __location__;
if (talloc_get_size(s4) != (sizeof(struct struct1 **) * 10)) {
printf("failure: ptrtype [\n"
"talloc_array_ptrtype() allocated the wrong size "
"%lu (should be %lu)\n]\n",
(unsigned long)talloc_get_size(s4),
(unsigned long)(sizeof(struct struct1 **)*10));
return false;
}
torture_assert_str_equal("ptrtype", location4, talloc_get_name(s4),
"talloc_array_ptrtype() sets the wrong name");
talloc_free(top);
printf("success: ptrtype\n");
return true;
}
/**
* Add @child to @node's children list, and set @child's parent to
* @node.
*/
static void add_child(Node *node, Node *child)
{
HASH_ADD_KEYPTR(hh, node->children, child->name, talloc_get_size(child->name) - 1, child);
child->parent = node;
}
static void filter_request(char *buf, size_t buf_len)
{
int msg_type = CVAL(buf,0);
int type = CVAL(buf,smb_com);
unsigned x;
fstring name1,name2;
int name_len1, name_len2;
int name_type1, name_type2;
if (msg_type) {
/* it's a netbios special */
switch (msg_type)
case 0x81:
/* session request */
/* inbuf_size is guaranteed to be at least 4. */
name_len1 = name_len((unsigned char *)(buf+4),
buf_len - 4);
if (name_len1 <= 0 || name_len1 > buf_len - 4) {
DEBUG(0,("Invalid name length in session request\n"));
return;
}
name_len2 = name_len((unsigned char *)(buf+4+name_len1),
buf_len - 4 - name_len1);
if (name_len2 <= 0 || name_len2 > buf_len - 4 - name_len1) {
DEBUG(0,("Invalid name length in session request\n"));
return;
}
name_type1 = name_extract((unsigned char *)buf,
buf_len,(unsigned int)4,name1);
name_type2 = name_extract((unsigned char *)buf,
buf_len,(unsigned int)(4 + name_len1),name2);
if (name_type1 == -1 || name_type2 == -1) {
DEBUG(0,("Invalid name type in session request\n"));
return;
}
d_printf("sesion_request: %s -> %s\n",
name1, name2);
if (netbiosname) {
char *mangled = name_mangle(
talloc_tos(), netbiosname, 0x20);
if (mangled != NULL) {
/* replace the destination netbios
* name */
memcpy(buf+4, mangled,
name_len((unsigned char *)mangled,
talloc_get_size(mangled)));
TALLOC_FREE(mangled);
}
}
return;
}
/* it's an ordinary SMB request */
switch (type) {
case SMBsesssetupX:
/* force the client capabilities */
x = IVAL(buf,smb_vwv11);
d_printf("SMBsesssetupX cap=0x%08x\n", x);
d_printf("pwlen=%d/%d\n", SVAL(buf, smb_vwv7), SVAL(buf, smb_vwv8));
system("mv sessionsetup.dat sessionsetup1.dat");
save_file("sessionsetup.dat", smb_buf(buf), SVAL(buf, smb_vwv7));
x = (x | CLI_CAPABILITY_SET) & ~CLI_CAPABILITY_MASK;
SIVAL(buf, smb_vwv11, x);
break;
}
}
NTSTATUS cli_dfs_get_referral(TALLOC_CTX *ctx,
struct cli_state *cli,
const char *path,
struct client_dfs_referral **refs,
size_t *num_refs,
size_t *consumed)
{
unsigned int data_len = 0;
unsigned int param_len = 0;
uint16_t setup[1];
uint16_t recv_flags2;
uint8_t *param = NULL;
uint8_t *rdata = NULL;
char *p;
char *endp;
smb_ucs2_t *path_ucs;
char *consumed_path = NULL;
uint16_t consumed_ucs;
uint16 num_referrals;
struct client_dfs_referral *referrals = NULL;
NTSTATUS status;
TALLOC_CTX *frame = talloc_stackframe();
*num_refs = 0;
*refs = NULL;
SSVAL(setup, 0, TRANSACT2_GET_DFS_REFERRAL);
param = talloc_array(talloc_tos(), uint8_t, 2);
if (!param) {
status = NT_STATUS_NO_MEMORY;
goto out;
}
SSVAL(param, 0, 0x03); /* max referral level */
param = trans2_bytes_push_str(param, cli_ucs2(cli),
path, strlen(path)+1,
NULL);
if (!param) {
status = NT_STATUS_NO_MEMORY;
goto out;
}
param_len = talloc_get_size(param);
path_ucs = (smb_ucs2_t *)¶m[2];
status = cli_trans(talloc_tos(), cli, SMBtrans2,
NULL, 0xffff, 0, 0,
setup, 1, 0,
param, param_len, 2,
NULL, 0, CLI_BUFFER_SIZE,
&recv_flags2,
NULL, 0, NULL, /* rsetup */
NULL, 0, NULL,
&rdata, 4, &data_len);
if (!NT_STATUS_IS_OK(status)) {
goto out;
}
endp = (char *)rdata + data_len;
consumed_ucs = SVAL(rdata, 0);
num_referrals = SVAL(rdata, 2);
/* consumed_ucs is the number of bytes
* of the UCS2 path consumed not counting any
* terminating null. We need to convert
* back to unix charset and count again
* to get the number of bytes consumed from
* the incoming path. */
errno = 0;
if (pull_string_talloc(talloc_tos(),
NULL,
0,
&consumed_path,
path_ucs,
consumed_ucs,
STR_UNICODE) == 0) {
if (errno != 0) {
status = map_nt_error_from_unix(errno);
} else {
status = NT_STATUS_INVALID_NETWORK_RESPONSE;
}
goto out;
}
if (consumed_path == NULL) {
status = map_nt_error_from_unix(errno);
goto out;
}
*consumed = strlen(consumed_path);
if (num_referrals != 0) {
uint16 ref_version;
uint16 ref_size;
int i;
uint16 node_offset;
referrals = talloc_array(ctx, struct client_dfs_referral,
num_referrals);
if (!referrals) {
status = NT_STATUS_NO_MEMORY;
goto out;
}
/* start at the referrals array */
p = (char *)rdata+8;
for (i=0; i<num_referrals && p < endp; i++) {
if (p + 18 > endp) {
goto out;
}
ref_version = SVAL(p, 0);
ref_size = SVAL(p, 2);
node_offset = SVAL(p, 16);
if (ref_version != 3) {
p += ref_size;
continue;
}
referrals[i].proximity = SVAL(p, 8);
referrals[i].ttl = SVAL(p, 10);
if (p + node_offset > endp) {
status = NT_STATUS_INVALID_NETWORK_RESPONSE;
goto out;
}
clistr_pull_talloc(referrals,
(const char *)rdata,
recv_flags2,
&referrals[i].dfspath,
p+node_offset,
PTR_DIFF(endp, p+node_offset),
STR_TERMINATE|STR_UNICODE);
if (!referrals[i].dfspath) {
status = map_nt_error_from_unix(errno);
goto out;
}
p += ref_size;
}
if (i < num_referrals) {
status = NT_STATUS_INVALID_NETWORK_RESPONSE;
goto out;
}
}
