struct lavc_conv *lavc_conv_create(struct mp_log *log, const char *codec_name,
char *extradata, int extradata_len)
{
struct lavc_conv *priv = talloc_zero(NULL, struct lavc_conv);
priv->log = log;
priv->cur_list = talloc_array(priv, char*, 0);
priv->codec = talloc_strdup(priv, codec_name);
AVCodecContext *avctx = NULL;
const char *fmt = get_lavc_format(priv->codec);
AVCodec *codec = avcodec_find_decoder(mp_codec_to_av_codec_id(fmt));
if (!codec)
goto error;
avctx = avcodec_alloc_context3(codec);
if (!avctx)
goto error;
avctx->extradata_size = extradata_len;
avctx->extradata = talloc_memdup(priv, extradata, extradata_len);
if (avcodec_open2(avctx, codec, NULL) < 0)
goto error;
// Documented as "set by libavcodec", but there is no other way
avctx->time_base = (AVRational) {1, 1000};
priv->avctx = avctx;
priv->extradata = talloc_strndup(priv, avctx->subtitle_header,
avctx->subtitle_header_size);
disable_styles(bstr0(priv->extradata));
return priv;
error:
MP_FATAL(priv, "Could not open libavcodec subtitle converter\n");
av_free(avctx);
talloc_free(priv);
return NULL;
}
/** Open a key by name (including the predefined key name!) */
WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
const char *name, struct registry_key **result)
{
struct registry_key *predef;
WERROR error;
int predeflength;
char *predefname;
if (strchr(name, '\\') != NULL)
predeflength = strchr(name, '\\')-name;
else
predeflength = strlen(name);
predefname = talloc_strndup(mem_ctx, name, predeflength);
error = reg_get_predefined_key_by_name(handle, predefname, &predef);
talloc_free(predefname);
if (!W_ERROR_IS_OK(error)) {
return error;
}
if (strchr(name, '\\')) {
return reg_open_key(mem_ctx, predef, strchr(name, '\\')+1,
result);
} else {
*result = predef;
return WERR_OK;
}
}
/**
* XXX: This is temporary and there should be no callers of this once
* smb_filename is plumbed through all path based operations.
*/
struct smb_filename *synthetic_smb_fname_split(TALLOC_CTX *ctx,
const char *fname,
const SMB_STRUCT_STAT *psbuf)
{
const char *stream_name = NULL;
char *base_name = NULL;
struct smb_filename *ret;
if (!lp_posix_pathnames()) {
stream_name = strchr_m(fname, ':');
}
/* Setup the base_name/stream_name. */
if (stream_name) {
base_name = talloc_strndup(ctx, fname,
PTR_DIFF(stream_name, fname));
} else {
base_name = talloc_strdup(ctx, fname);
}
if (!base_name) {
return NULL;
}
ret = synthetic_smb_fname(ctx, base_name, stream_name, psbuf);
TALLOC_FREE(base_name);
return ret;
}
double ldb_msg_find_attr_as_double(const struct ldb_message *msg,
const char *attr_name,
double default_value)
{
const struct ldb_val *v = ldb_msg_find_ldb_val(msg, attr_name);
char *buf;
char *end = NULL;
double ret;
if (!v || !v->data) {
return default_value;
}
buf = talloc_strndup(msg, (const char *)v->data, v->length);
if (buf == NULL) {
return default_value;
}
errno = 0;
ret = strtod(buf, &end);
talloc_free(buf);
if (errno != 0) {
return default_value;
}
if (end && end[0] != '\0') {
return default_value;
}
return ret;
}
static char *get_netbios_name(TALLOC_CTX *mem_ctx, HostAddresses *addrs)
{
char *nb_name = NULL;
size_t len;
unsigned int i;
for (i = 0; addrs && i < addrs->len; i++) {
if (addrs->val[i].addr_type != KRB5_ADDRESS_NETBIOS) {
continue;
}
len = MIN(addrs->val[i].address.length, 15);
nb_name = talloc_strndup(mem_ctx,
addrs->val[i].address.data, len);
if (nb_name) {
break;
}
}
if ((nb_name == NULL) || (nb_name[0] == '\0')) {
return NULL;
}
/* Strip space padding */
for (len = strlen(nb_name) - 1;
(len > 0) && (nb_name[len] == ' ');
--len) {
nb_name[len] = '\0';
}
return nb_name;
}
static char *get_netbios_name(TALLOC_CTX *mem_ctx, HostAddresses *addrs)
{
char *nb_name = NULL;
int len, i;
for (i = 0; addrs && i < addrs->len; i++) {
if (addrs->val[i].addr_type != KRB5_ADDRESS_NETBIOS) {
continue;
}
len = MIN(addrs->val[i].address.length, 15);
nb_name = talloc_strndup(mem_ctx,
addrs->val[i].address.data, len);
if (nb_name) {
break;
}
}
if (nb_name == NULL) {
return NULL;
}
/* Strip space padding */
i = strlen(nb_name) - 1;
while (i > 0 && nb_name[i] == ' ') {
nb_name[i] = '\0';
}
return nb_name;
}
void mp_tags_set_bstr(struct mp_tags *tags, bstr key, bstr value)
{
for (int n = 0; n < tags->num_keys; n++) {
if (bstrcasecmp0(key, tags->keys[n]) == 0) {
talloc_free(tags->values[n]);
tags->values[n] = talloc_strndup(tags, value.start, value.len);
return;
}
}
MP_RESIZE_ARRAY(tags, tags->keys, tags->num_keys + 1);
MP_RESIZE_ARRAY(tags, tags->values, tags->num_keys + 1);
tags->keys[tags->num_keys] = talloc_strndup(tags, key.start, key.len);
tags->values[tags->num_keys] = talloc_strndup(tags, value.start, value.len);
tags->num_keys++;
}
static char *
get_name_from_passwd_file (void *ctx)
{
long pw_buf_size;
char *pw_buf;
struct passwd passwd, *ignored;
char *name;
int e;
pw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
if (pw_buf_size == -1) pw_buf_size = 64;
pw_buf = talloc_size (ctx, pw_buf_size);
while ((e = getpwuid_r (getuid (), &passwd, pw_buf,
pw_buf_size, &ignored)) == ERANGE) {
pw_buf_size = pw_buf_size * 2;
pw_buf = talloc_zero_size(ctx, pw_buf_size);
}
if (e == 0) {
char *comma = strchr (passwd.pw_gecos, ',');
if (comma)
name = talloc_strndup (ctx, passwd.pw_gecos,
comma - passwd.pw_gecos);
else
name = talloc_strdup (ctx, passwd.pw_gecos);
} else {
name = talloc_strdup (ctx, "");
}
talloc_free (pw_buf);
return name;
}
/*
called when a CTDB_REPLY_CONTROL packet comes in
*/
void ctdb_reply_control(struct ctdb_context *ctdb, struct ctdb_req_header *hdr)
{
struct ctdb_reply_control_old *c = (struct ctdb_reply_control_old *)hdr;
TDB_DATA data;
struct ctdb_control_state *state;
const char *errormsg = NULL;
state = reqid_find(ctdb->idr, hdr->reqid, struct ctdb_control_state);
if (state == NULL) {
DEBUG(DEBUG_ERR,("pnn %u Invalid reqid %u in ctdb_reply_control\n",
ctdb->pnn, hdr->reqid));
return;
}
if (hdr->reqid != state->reqid) {
/* we found a record but it was the wrong one */
DEBUG(DEBUG_ERR, ("Dropped orphaned control reply with reqid:%u\n", hdr->reqid));
return;
}
data.dptr = &c->data[0];
data.dsize = c->datalen;
if (c->errorlen) {
errormsg = talloc_strndup(state,
(char *)&c->data[c->datalen], c->errorlen);
}
/* make state a child of the packet, so it goes away when the packet
is freed. */
talloc_steal(hdr, state);
state->callback(ctdb, c->status, data, errormsg, state->private_data);
}
/*
given a filename, find the parent directory
*/
static char *parent_dir(TALLOC_CTX *mem_ctx, const char *name)
{
const char *p = strrchr(name, '/');
if (p == NULL) {
return talloc_strdup(mem_ctx, ".");
}
return talloc_strndup(mem_ctx, name, (p+1) - name);
}
char *talloc_dirname(const void *ctx, const char *dir)
{
char *p = strrchr(dir, '/');
if (!p)
return talloc_strdup(ctx, ".");
return talloc_strndup(ctx, dir, p - dir);
}
static bool test_rpc_netservergetinfo(struct torture_context *tctx,
struct smbcli_state *cli)
{
struct rap_WserverGetInfo r;
struct dcerpc_pipe *p;
struct dcerpc_binding_handle *b;
struct srvsvc_NetSrvGetInfo s;
union srvsvc_NetSrvInfo info;
const char *server_name;
torture_assert_ntstatus_ok(tctx,
torture_rpc_connection(tctx, &p, &ndr_table_srvsvc),
"failed to open srvsvc");
b = p->binding_handle;
s.in.server_unc = NULL;
s.in.level = 101;
s.out.info = &info;
torture_assert_ntstatus_ok(tctx,
dcerpc_srvsvc_NetSrvGetInfo_r(b, tctx, &s),
"srvsvc_NetSrvGetInfo level 101 failed");
torture_assert_werr_ok(tctx, s.out.result,
"srvsvc_NetSrvGetInfo level 101 failed");
r.in.bufsize = 0xffff;
r.in.level = 0;
torture_assert_ntstatus_ok(tctx,
smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
"rap_netservergetinfo level 0 failed");
torture_assert_int_equal(tctx, r.out.status, 0,
"rap_netservergetinfo level 0 failed");
server_name = talloc_strndup(tctx, info.info101->server_name, 16);
torture_assert_str_equal(tctx, (const char *)r.out.info.info0.name, server_name, "server name");
r.in.level = 1;
torture_assert_ntstatus_ok(tctx,
smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
"rap_netservergetinfo level 1 failed");
torture_assert_int_equal(tctx, r.out.status, 0,
"rap_netservergetinfo level 1 failed");
torture_assert_str_equal(tctx, (const char *)r.out.info.info1.name, server_name, "server name");
torture_assert_int_equal(tctx, r.out.info.info1.version_major, info.info101->version_major, "version major");
torture_assert_int_equal(tctx, r.out.info.info1.version_minor, info.info101->version_minor, "version minor");
torture_assert_int_equal(tctx, r.out.info.info1.servertype, info.info101->server_type, "server_type");
torture_assert_str_equal(tctx, r.out.info.info1.comment, info.info101->comment, "comment");
talloc_free(p);
return true;
}
char *
_notmuch_message_id_parse (void *ctx, const char *message_id, const char **next)
{
const char *s, *end;
char *result;
if (message_id == NULL || *message_id == '\0')
return NULL;
s = message_id;
skip_space_and_comments (&s);
/* Skip any unstructured text as well. */
while (*s && *s != '<')
s++;
if (*s == '<') {
s++;
} else {
if (next)
*next = s;
return NULL;
}
skip_space_and_comments (&s);
end = s;
while (*end && *end != '>')
end++;
if (next) {
if (*end)
*next = end + 1;
else
*next = end;
}
if (end > s && *end == '>')
end--;
if (end <= s)
return NULL;
result = talloc_strndup (ctx, s, end - s + 1);
/* Finally, collapse any whitespace that is within the message-id
* itself. */
{
char *r;
int len;
for (r = result, len = strlen (r); *r; r++, len--)
if (*r == ' ' || *r == '\t')
memmove (r, r+1, len);
}
return result;
}
errno_t sysdb_get_rdn(struct sysdb_ctx *sysdb, TALLOC_CTX *mem_ctx,
const char *dn, char **_name, char **_val)
{
errno_t ret;
struct ldb_dn *ldb_dn;
const char *attr_name = NULL;
const struct ldb_val *val;
TALLOC_CTX *tmp_ctx;
/* We have to create a tmp_ctx here because
* ldb_dn_new_fmt() fails if mem_ctx is NULL
*/
tmp_ctx = talloc_new(NULL);
if (!tmp_ctx) {
return ENOMEM;
}
ldb_dn = ldb_dn_new_fmt(tmp_ctx, sysdb->ldb, "%s", dn);
if (ldb_dn == NULL) {
ret = ENOMEM;
goto done;
}
if (_name) {
attr_name = ldb_dn_get_rdn_name(ldb_dn);
if (attr_name == NULL) {
ret = EINVAL;
goto done;
}
*_name = talloc_strdup(mem_ctx, attr_name);
if (!*_name) {
ret = ENOMEM;
goto done;
}
}
val = ldb_dn_get_rdn_val(ldb_dn);
if (val == NULL) {
ret = EINVAL;
if (_name) talloc_free(*_name);
goto done;
}
*_val = talloc_strndup(mem_ctx, (char *) val->data, val->length);
if (!*_val) {
ret = ENOMEM;
if (_name) talloc_free(*_name);
goto done;
}
ret = EOK;
done:
talloc_zfree(tmp_ctx);
return ret;
}
int demuxer_add_attachment(demuxer_t *demuxer, struct bstr name,
struct bstr type, struct bstr data)
{
if (!(demuxer->num_attachments % 32))
demuxer->attachments = talloc_realloc(demuxer, demuxer->attachments,
struct demux_attachment,
demuxer->num_attachments + 32);
struct demux_attachment *att =
demuxer->attachments + demuxer->num_attachments;
att->name = talloc_strndup(demuxer->attachments, name.start, name.len);
att->type = talloc_strndup(demuxer->attachments, type.start, type.len);
att->data = talloc_size(demuxer->attachments, data.len);
memcpy(att->data, data.start, data.len);
att->data_size = data.len;
return demuxer->num_attachments++;
}
static int ldif_canonicalise_objectCategory(struct ldb_context *ldb, void *mem_ctx,
const struct ldb_val *in, struct ldb_val *out)
{
struct ldb_dn *dn1 = NULL;
const struct dsdb_schema *schema = dsdb_get_schema(ldb, NULL);
const struct dsdb_class *sclass;
TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
if (!tmp_ctx) {
return LDB_ERR_OPERATIONS_ERROR;
}
if (!schema) {
talloc_free(tmp_ctx);
*out = data_blob_talloc(mem_ctx, in->data, in->length);
if (in->data && !out->data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_SUCCESS;
}
dn1 = ldb_dn_from_ldb_val(tmp_ctx, ldb, in);
if ( ! ldb_dn_validate(dn1)) {
const char *lDAPDisplayName = talloc_strndup(tmp_ctx, (char *)in->data, in->length);
sclass = dsdb_class_by_lDAPDisplayName(schema, lDAPDisplayName);
if (sclass) {
struct ldb_dn *dn = ldb_dn_new(tmp_ctx, ldb,
sclass->defaultObjectCategory);
if (dn == NULL) {
talloc_free(tmp_ctx);
return LDB_ERR_OPERATIONS_ERROR;
}
*out = data_blob_string_const(ldb_dn_alloc_casefold(mem_ctx, dn));
talloc_free(tmp_ctx);
if (!out->data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_SUCCESS;
} else {
*out = data_blob_talloc(mem_ctx, in->data, in->length);
talloc_free(tmp_ctx);
if (in->data && !out->data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_SUCCESS;
}
}
*out = data_blob_string_const(ldb_dn_alloc_casefold(mem_ctx, dn1));
talloc_free(tmp_ctx);
if (!out->data) {
return LDB_ERR_OPERATIONS_ERROR;
}
return LDB_SUCCESS;
}
void tid_srvr_get_address(const TID_SRVR_BLK *blk,
const struct sockaddr **out_addr,
size_t *out_len)
{
char *colon = NULL;
assert(blk);
char *hostname = NULL, *port = NULL;
int s, len;
struct addrinfo *result;
// make sure we don't return garbage
*out_len = 0;
*out_addr = NULL;
/* get a copy of the address */
hostname = talloc_strdup(blk, blk->aaa_server_addr);
/* address might contain AAA port number. If so, process it */
colon = strrchr(hostname, ':');
/* If there are more than one colon, and the last one is not preceeded by ],
this is not a port separator, but an IPv6 address (likely) */
if (strchr(hostname, ':') != colon && *(colon - 1) != ']')
colon = NULL;
/* we get two strings, the hostname without the colon, and the port number */
if (colon != NULL) {
*colon = '\0';
port = talloc_strdup(blk, colon + 1);
}
/* IPv6 addresses might be surrounded by square brackets */
len = strlen(hostname);
if (hostname[0] == '[' && hostname[len - 1] == ']') {
char *copy = talloc_strndup(NULL, hostname + 1, len - 2);
talloc_free(hostname);
hostname = copy;
}
s = getaddrinfo(hostname, // address
port ? port : "2083", // port as a string
NULL, // hints
&result);
if (s != 0 || result == NULL) {
tr_crit("tid_srvr_get_address: Could not resolve an address from %s", hostname);
return;
}
*out_addr = result->ai_addr;
*out_len = result->ai_addrlen;
result->ai_addr = NULL; // to avoid deleting it
freeaddrinfo(result);
talloc_free(hostname);
talloc_free(port);
}
static void do_pam_chauthtok(struct LOCAL_request *lreq)
{
int ret;
char *newauthtok;
char *salt;
char *new_hash;
struct pam_data *pd;
pd = lreq->preq->pd;
newauthtok = talloc_strndup(lreq, (char *) pd->newauthtok,
pd->newauthtok_size);
NULL_CHECK_OR_JUMP(newauthtok, ("talloc_strndup failed.\n"), lreq->error,
ENOMEM, done);
memset(pd->newauthtok, 0, pd->newauthtok_size);
if (strlen(newauthtok) == 0) {
/* TODO: should we allow null passwords via a config option ? */
DEBUG(1, ("Empty passwords are not allowed!\n"));
lreq->error = EINVAL;
goto done;
}
ret = s3crypt_gen_salt(lreq, &salt);
NEQ_CHECK_OR_JUMP(ret, EOK, ("Salt generation failed.\n"),
lreq->error, ret, done);
DEBUG(4, ("Using salt [%s]\n", salt));
ret = s3crypt_sha512(lreq, newauthtok, salt, &new_hash);
NEQ_CHECK_OR_JUMP(ret, EOK, ("Hash generation failed.\n"),
lreq->error, ret, done);
DEBUG(4, ("New hash [%s]\n", new_hash));
memset(newauthtok, 0, pd->newauthtok_size);
lreq->mod_attrs = sysdb_new_attrs(lreq);
NULL_CHECK_OR_JUMP(lreq->mod_attrs, ("sysdb_new_attrs failed.\n"),
lreq->error, ENOMEM, done);
ret = sysdb_attrs_add_string(lreq->mod_attrs, SYSDB_PWD, new_hash);
NEQ_CHECK_OR_JUMP(ret, EOK, ("sysdb_attrs_add_string failed.\n"),
lreq->error, ret, done);
ret = sysdb_attrs_add_long(lreq->mod_attrs,
"lastPasswordChange", (long)time(NULL));
NEQ_CHECK_OR_JUMP(ret, EOK, ("sysdb_attrs_add_long failed.\n"),
lreq->error, ret, done);
ret = sysdb_set_user_attr(lreq->dbctx, lreq->preq->pd->user,
lreq->mod_attrs, SYSDB_MOD_REP);
NEQ_CHECK_OR_JUMP(ret, EOK, ("sysdb_set_user_attr failed.\n"),
lreq->error, ret, done);
done:
return;
}
/* Accepts fqname in the format shortname@domname only. */
errno_t sss_parse_internal_fqname(TALLOC_CTX *mem_ctx,
const char *fqname,
char **_shortname,
char **_dom_name)
{
errno_t ret;
char *separator;
char *shortname = NULL;
char *dom_name = NULL;
size_t shortname_len;
TALLOC_CTX *tmp_ctx;
if (fqname == NULL) {
return EINVAL;
}
tmp_ctx = talloc_new(NULL);
if (tmp_ctx == NULL) {
return ENOMEM;
}
separator = strrchr(fqname, '@');
if (separator == NULL || *(separator + 1) == '\0' || separator == fqname) {
/*The name does not contain name or domain component. */
ret = ERR_WRONG_NAME_FORMAT;
goto done;
}
if (_dom_name != NULL) {
dom_name = talloc_strdup(tmp_ctx, separator + 1);
if (dom_name == NULL) {
ret = ENOMEM;
goto done;
}
*_dom_name = talloc_steal(mem_ctx, dom_name);
}
if (_shortname != NULL) {
shortname_len = strlen(fqname) - strlen(separator);
shortname = talloc_strndup(tmp_ctx, fqname, shortname_len);
if (shortname == NULL) {
ret = ENOMEM;
goto done;
}
*_shortname = talloc_steal(mem_ctx, shortname);
}
ret = EOK;
done:
talloc_free(tmp_ctx);
return ret;
}
/*
construct a string MprVar from a lump of data
*/
struct MprVar mprData(const uint8_t *p, size_t length)
{
struct MprVar var;
char *s = talloc_strndup(mprMemCtx(), (const char *)p, length);
if (s == NULL) {
return mprCreateUndefinedVar();
}
var = mprString(s);
talloc_free(s);
return var;
}
/*
convert a string to a dom_sid, returning a talloc'd dom_sid
*/
struct dom_sid *dom_sid_parse_length(TALLOC_CTX *mem_ctx, const DATA_BLOB *sid)
{
struct dom_sid *ret;
char *p = talloc_strndup(mem_ctx, (char *)sid->data, sid->length);
if (!p) {
return NULL;
}
ret = dom_sid_parse_talloc(mem_ctx, p);
talloc_free(p);
return ret;
}
/**
\details Pull an ASCII string
\param pull Pointer to the mapirops_pull structure
\param mem_ctx Pointer to the memory context to use for string
memory allocation
\param flags Flags controlling how the string should be pulled
\param str Pointer on pointer to the UTF-8 string to return
\param slen Size of the UTF-8 string to pull
\note Calling function is responsible for freeing the str allocated
string returned
\return MAPIROPS_ERR_SUCCESS on success, otherwise MAPIROPS error
*/
enum mapirops_err_code mapirops_pull_ascii_string(struct mapirops_pull *pull, TALLOC_CTX *mem_ctx,
int flags, char **str, size_t slen)
{
size_t src_len = slen;
/* If no prefixing size is available, calculate the size */
if (flags & MAPIROPS_STR_NOSIZE) {
/* We can't have STR_SIZE and STR_NOTERM flags set at the same time */
if (flags & MAPIROPS_STR_NOTERM) {
return MAPIROPS_ERR_INVALID_FLAGS;
}
/* TODO: Implement parsing routine looking for \0 */
flags &= ~MAPIROPS_STR_NOSIZE;
src_len = slen;
}
if (flags & MAPIROPS_STR_NOTERM) {
flags &= ~MAPIROPS_STR_NOTERM;
} else {
/* Add termination character */
src_len += 1;
}
if (flags) {
return MAPIROPS_ERR_INVALID_FLAGS;
}
/* Empty string, nothing to pull */
if (src_len == 0) {
*str = NULL;
return MAPIROPS_ERR_SUCCESS;
}
/* Ensure src_len is <= remaining buffer size */
if (src_len >= (pull->data.length - pull->offset)) {
return mapirops_error(MAPIROPS_ERR_BUFSIZE, LOG_ERR,
"Overflow in pull_ascii to %u", src_len);
}
/* No iconv conversion required here: ASCII is a subset of UTF-8 */
if (src_len > 0) {
*str = talloc_strndup(mem_ctx, (const char *)pull->data.data + pull->offset, src_len);
if (*str == NULL) {
return mapirops_error(MAPIROPS_ERR_ALLOC, LOG_ERR,
"Failed to pull_ascii to %u", src_len);
}
pull->offset += src_len;
} else {
*str = NULL;
}
return MAPIROPS_ERR_SUCCESS;
}
/*
insert an entry into the prefix cache. The string might not be null
terminated */
static void cache_insert(struct pvfs_mangle_context *ctx,
const char *prefix, int length, uint32_t hash)
{
int i = hash % ctx->cache_size;
if (ctx->prefix_cache[i]) {
talloc_free(ctx->prefix_cache[i]);
}
ctx->prefix_cache[i] = talloc_strndup(ctx->prefix_cache, prefix, length);
ctx->prefix_cache_hashes[i] = hash;
}
/*
* Read a key with uint64 value
*/
static int partition_metadata_get_uint64(struct ldb_module *module,
const char *key, uint64_t *value,
uint64_t default_value)
{
struct partition_private_data *data;
struct tdb_context *tdb;
TDB_DATA tdb_key, tdb_data;
char *value_str;
TALLOC_CTX *tmp_ctx;
data = talloc_get_type_abort(ldb_module_get_private(module),
struct partition_private_data);
if (!data || !data->metadata || !data->metadata->db) {
return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
"partition_metadata: metadata tdb not initialized");
}
tmp_ctx = talloc_new(NULL);
if (tmp_ctx == NULL) {
return ldb_module_oom(module);
}
tdb = data->metadata->db->tdb;
tdb_key.dptr = (uint8_t *)discard_const_p(char, key);
tdb_key.dsize = strlen(key);
tdb_data = tdb_fetch(tdb, tdb_key);
if (!tdb_data.dptr) {
if (tdb_error(tdb) == TDB_ERR_NOEXIST) {
*value = default_value;
return LDB_SUCCESS;
} else {
return ldb_module_error(module, LDB_ERR_OPERATIONS_ERROR,
tdb_errorstr(tdb));
}
}
value_str = talloc_strndup(tmp_ctx, (char *)tdb_data.dptr, tdb_data.dsize);
if (value_str == NULL) {
SAFE_FREE(tdb_data.dptr);
talloc_free(tmp_ctx);
return ldb_module_oom(module);
}
*value = strtoull(value_str, NULL, 10);
SAFE_FREE(tdb_data.dptr);
talloc_free(tmp_ctx);
return LDB_SUCCESS;
}
void process(struct processor *p_uncast, const char *filename,
struct stack *s, struct makefile *m)
{
struct processor_pdfcrop *p;
void *c;
int cachedir_index;
char *cachedir;
char *infile;
/* We need access to the real structure, get it safely */
p = talloc_get_type(p_uncast, struct processor_pdfcrop);
/* Makes a new context */
c = talloc_new(p);
/* Finds the original filename */
cachedir_index = string_index(filename, ".tek_cache/");
if (cachedir_index == -1) {
fprintf(stderr, "Bad cachedir for image\n");
return;
}
cachedir = talloc_strdup(c, filename);
cachedir[cachedir_index + strlen(".tex_cache/")] = '\0';
infile = talloc_strdup(c, filename);
infile[cachedir_index] = '\0';
strcat(infile, filename + strlen(cachedir));
infile[strlen(infile) - 4] = '\0';
TALLOC_FREE(cachedir);
cachedir = talloc_strndup(c, filename, basename_len(filename));
/* Creates the target to build the image */
makefile_create_target(m, filename);
makefile_start_deps(m);
makefile_add_dep(m, infile);
makefile_end_deps(m);
makefile_start_cmds(m);
makefile_nam_cmd(m, "echo -e \"PDFCROP\\t%s\"", infile);
makefile_add_cmd(m, "mkdir -p \"%s\" >& /dev/null || true", cachedir);
makefile_add_cmd(m, "pdfcrop \"%s\" \"%s\" >& /dev/null",
infile, filename);
makefile_end_cmds(m);
/* Cleans up all the memory allocated by this code. */
TALLOC_FREE(c);
}
static int elp_decode(struct osim_decoded_data *dd,
const struct osim_file_desc *desc,
int len, uint8_t *data)
{
int i, num_lp = len / 2;
for (i = 0; i < num_lp; i++) {
uint8_t *cur = data + i*2;
struct osim_decoded_element *elem;
elem = element_alloc(dd, "Language Code", ELEM_T_STRING, ELEM_REPR_NONE);
elem->u.buf = (uint8_t *) talloc_strndup(elem, (const char *) cur, 2);
}
return 0;
}
static enum mapistore_error tdb_record_get_uri(struct indexing_context *ictx,
const char *username,
TALLOC_CTX *mem_ctx,
uint64_t fmid,
char **urip,
bool *soft_deletedp)
{
TDB_DATA key, dbuf;
int ret;
/* Sanity checks */
MAPISTORE_RETVAL_IF(!ictx, MAPISTORE_ERR_NOT_INITIALIZED, NULL);
MAPISTORE_RETVAL_IF(!username, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
MAPISTORE_RETVAL_IF(!fmid, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
MAPISTORE_RETVAL_IF(!urip, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
MAPISTORE_RETVAL_IF(!soft_deletedp, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
/* Check if the fmid exists within the database */
key.dptr = (unsigned char *) talloc_asprintf(ictx, "0x%.16"PRIx64, fmid);
key.dsize = strlen((const char *) key.dptr);
ret = tdb_exists(TDB_WRAP(ictx)->tdb, key);
if (ret) {
*soft_deletedp = false;
}
else {
talloc_free(key.dptr);
key.dptr = (unsigned char *) talloc_asprintf(ictx, "%s0x%.16"PRIx64,
MAPISTORE_SOFT_DELETED_TAG,
fmid);
key.dsize = strlen((const char *)key.dptr);
ret = tdb_exists(TDB_WRAP(ictx)->tdb, key);
if (ret) {
*soft_deletedp = true;
}
else {
talloc_free(key.dptr);
*urip = NULL;
return MAPISTORE_ERR_NOT_FOUND;
}
}
dbuf = tdb_fetch(TDB_WRAP(ictx)->tdb, key);
*urip = talloc_strndup(mem_ctx, (const char *) dbuf.dptr, dbuf.dsize);
free(dbuf.dptr);
talloc_free(key.dptr);
return MAPISTORE_SUCCESS;
}
int demuxer_add_chapter(demuxer_t *demuxer, struct bstr name,
uint64_t start, uint64_t end)
{
if (!(demuxer->num_chapters % 32))
demuxer->chapters = talloc_realloc(demuxer, demuxer->chapters,
struct demux_chapter,
demuxer->num_chapters + 32);
demuxer->chapters[demuxer->num_chapters].start = start;
demuxer->chapters[demuxer->num_chapters].end = end;
demuxer->chapters[demuxer->num_chapters].name = name.len ?
talloc_strndup(demuxer->chapters, name.start, name.len) :
talloc_strdup(demuxer->chapters, mp_gtext("unknown"));
return demuxer->num_chapters++;
}
static int read_id(void *ta_parent, struct mpv_node *dst, char **src)
{
char *start = *src;
if (!mp_isalpha(**src) && **src != '_')
return -1;
while (mp_isalnum(**src) || **src == '_')
*src += 1;
if (**src == ' ') {
**src = '\0'; // we're allowed to mutate it => can avoid the strndup
*src += 1;
} else {
start = talloc_strndup(ta_parent, start, *src - start);
}
dst->format = MPV_FORMAT_STRING;
dst->u.string = start;
return 0;
}
bool wb_samba3_split_username(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx,
const char *domuser,
char **domain, char **user)
{
char *p = strchr(domuser, *lpcfg_winbind_separator(lp_ctx));
if (p == NULL) {
*domain = talloc_strdup(mem_ctx, lpcfg_workgroup(lp_ctx));
} else {
*domain = talloc_strndup(mem_ctx, domuser,
PTR_DIFF(p, domuser));
domuser = p+1;
}
*user = talloc_strdup(mem_ctx, domuser);
return ((*domain != NULL) && (*user != NULL));
}
