int snd_send_fd(int sock, void *data, size_t len, int fd);
int snd_receive_fd(int sock, void *data, size_t len, int *fd);
+size_t snd_strlcpy(char *dst, const char *src, size_t size);
/*
* error messages
void snd_ctl_elem_id_set_name(snd_ctl_elem_id_t *obj, const char *val)
{
assert(obj);
- strncpy((char *)obj->name, val, sizeof(obj->name));
+ snd_strlcpy((char *)obj->name, val, sizeof(obj->name));
}
/**
void snd_ctl_elem_info_set_name(snd_ctl_elem_info_t *obj, const char *val)
{
assert(obj);
- strncpy((char *)obj->id.name, val, sizeof(obj->id.name));
+ snd_strlcpy((char *)obj->id.name, val, sizeof(obj->id.name));
}
/**
void snd_ctl_elem_value_set_name(snd_ctl_elem_value_t *obj, const char *val)
{
assert(obj);
- strncpy((char *)obj->id.name, val, sizeof(obj->id.name));
+ snd_strlcpy((char *)obj->id.name, val, sizeof(obj->id.name));
}
/**
snd_lib_error_handler_t snd_err_msg = snd_err_msg_default;
#endif
+
+/**
+ * \brief Copy a C-string into a sized buffer
+ * \param dst Where to copy the string to
+ * \param src Where to copy the string from
+ * \param size Size of destination buffer
+ * \retval The source string length
+ *
+ * The result is always a valid NUL-terminated string that fits
+ * in the buffer (unless, of course, the buffer size is zero).
+ * It does not pad out the result like strncpy() does.
+ */
+size_t snd_strlcpy(char *dst, const char *src, size_t size)
+{
+ size_t ret = strlen(src);
+ if (size) {
+ size_t len = ret >= size ? size - 1 : ret;
+ memcpy(dst, src, len);
+ dst[len] = '\0';
+ }
+ return ret;
+}
info->card = -1;
/* FIXME: fill this with something more useful: we know the hardware name */
if (pcm->name) {
- strncpy((char *)info->id, pcm->name, sizeof(info->id));
- strncpy((char *)info->name, pcm->name, sizeof(info->name));
- strncpy((char *)info->subname, pcm->name, sizeof(info->subname));
+ snd_strlcpy((char *)info->id, pcm->name, sizeof(info->id));
+ snd_strlcpy((char *)info->name, pcm->name, sizeof(info->name));
+ snd_strlcpy((char *)info->subname, pcm->name, sizeof(info->subname));
}
info->subdevices_count = 1;
return 0;
info->stream = pcm->stream;
info->card = -1;
if (pcm->name) {
- strncpy((char *)info->id, pcm->name, sizeof(info->id));
- strncpy((char *)info->name, pcm->name, sizeof(info->name));
- strncpy((char *)info->subname, pcm->name, sizeof(info->subname));
+ snd_strlcpy((char *)info->id, pcm->name, sizeof(info->id));
+ snd_strlcpy((char *)info->name, pcm->name, sizeof(info->name));
+ snd_strlcpy((char *)info->subname, pcm->name, sizeof(info->subname));
}
info->subdevices_count = 1;
return 0;
info->stream = pcm->stream;
info->card = -1;
if (pcm->name) {
- strncpy((char *)info->id, pcm->name, sizeof(info->id));
- strncpy((char *)info->name, pcm->name, sizeof(info->name));
- strncpy((char *)info->subname, pcm->name, sizeof(info->subname));
+ snd_strlcpy((char *)info->id, pcm->name, sizeof(info->id));
+ snd_strlcpy((char *)info->name, pcm->name, sizeof(info->name));
+ snd_strlcpy((char *)info->subname, pcm->name, sizeof(info->subname));
}
info->subdevices_count = 1;
return 0;
void snd_seq_client_info_set_name(snd_seq_client_info_t *info, const char *name)
{
assert(info && name);
- strncpy(info->name, name, sizeof(info->name));
+ snd_strlcpy(info->name, name, sizeof(info->name));
}
/**
void snd_seq_port_info_set_name(snd_seq_port_info_t *info, const char *name)
{
assert(info && name);
- strncpy(info->name, name, sizeof(info->name));
+ snd_strlcpy(info->name, name, sizeof(info->name));
}
/**
void snd_seq_queue_info_set_name(snd_seq_queue_info_t *info, const char *name)
{
assert(info && name);
- strncpy(info->name, name, sizeof(info->name));
+ snd_strlcpy(info->name, name, sizeof(info->name));
}
/**
memset(&info, 0, sizeof(info));
info.locked = 1;
if (name)
- strncpy(info.name, name, sizeof(info.name) - 1);
+ snd_strlcpy(info.name, name, sizeof(info.name));
return snd_seq_create_queue(seq, &info);
}
int err;
snd_seq_queue_info_t info;
assert(seq && name);
- strncpy(info.name, name, sizeof(info.name));
+ snd_strlcpy(info.name, name, sizeof(info.name));
err = seq->ops->get_named_queue(seq, &info);
if (err < 0)
return err;
be = elem->bytes_ext;
be->size = elem->size;
- elem_copy_text(be->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(be->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
be->hdr.type = SND_SOC_TPLG_TYPE_BYTES;
tplg_dbg(" Control Bytes: %s\n", elem->id);
return -ENOMEM;
ec = elem->enum_ctrl;
- elem_copy_text(ec->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(ec->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
ec->hdr.type = SND_SOC_TPLG_TYPE_ENUM;
ec->size = elem->size;
tplg->channel_idx = 0;
/* init new mixer */
mc = elem->mixer_ctrl;
- elem_copy_text(mc->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(mc->hdr.name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
mc->hdr.type = SND_SOC_TPLG_TYPE_MIXER;
mc->size = elem->size;
tplg->channel_idx = 0;
hdr->size = sizeof(struct snd_soc_tplg_ctl_hdr);
hdr->type = t->type;
- elem_copy_text(hdr->name, t->name,
- SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(hdr->name, t->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
/* clean up access flag */
if (t->access == 0)
unsigned int len, i;
const char *source = NULL, *sink = NULL, *control = NULL;
- elem_copy_text(buf, text, LINE_SIZE);
+ snd_strlcpy(buf, text, LINE_SIZE);
len = strlen(buf);
if (len <= 2) {
tplg_dbg(" Widget: %s\n", elem->id);
widget = elem->widget;
- elem_copy_text(widget->name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(widget->name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
widget->size = elem->size;
snd_config_for_each(i, next, cfg) {
if (snd_config_get_string(n, &val) < 0)
return -EINVAL;
- elem_copy_text(widget->sname, val,
+ snd_strlcpy(widget->sname, val,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg("\t%s: %s\n", id, val);
continue;
return -ENOMEM;
line = elem->route;
- elem_copy_text(line->source, t->src, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(line->source, t->src, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
if (t->ctl)
- elem_copy_text(line->control, t->ctl,
+ snd_strlcpy(line->control, t->ctl,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
- elem_copy_text(line->sink, t->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(line->sink, t->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
return 0;
}
w->size = elem->size;
w->id = wt->id;
- elem_copy_text(w->name, wt->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(w->name, wt->name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
if (wt->sname)
- elem_copy_text(w->sname, wt->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(w->sname, wt->sname, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
w->reg = wt->reg;
w->shift = wt->shift;
w->mask = wt->mask;
case SND_SOC_TPLG_TUPLE_TYPE_STRING:
string = &array->string[j];
string->token = token_val;
- elem_copy_text(string->string, tuple->string,
+ snd_strlcpy(string->string, tuple->string,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
break;
continue;
tuple = &set->tuple[set->num_tuples];
- elem_copy_text(tuple->token, id,
+ snd_strlcpy(tuple->token, id,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
switch (type) {
break;
case SND_SOC_TPLG_TUPLE_TYPE_STRING:
- elem_copy_text(tuple->string, value,
+ snd_strlcpy(tuple->string, value,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg("\t\t%s = %s\n", tuple->token, tuple->string);
break;
if (snd_config_get_string(n, &value) < 0)
continue;
- elem_copy_text(tokens->token[tokens->num_tokens].id, id,
+ snd_strlcpy(tokens->token[tokens->num_tokens].id, id,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tokens->token[tokens->num_tokens].value = atoi(value);
tplg_dbg("\t\t %s : %d\n", tokens->token[tokens->num_tokens].id,
ref->type = elem_ref->type;
ref->elem = elem_ref;
- elem_copy_text(ref->id, elem_ref->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(ref->id, elem_ref->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
list_add_tail(&ref->list, &elem->ref_list);
return 0;
/* do we get name from cfg */
if (cfg) {
snd_config_get_id(cfg, &id);
- elem_copy_text(elem->id, id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(elem->id, id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
elem->id[SNDRV_CTL_ELEM_ID_NAME_MAXLEN - 1] = 0;
/* as we insert new elem based on the index value, move index
parsing here */
}
}
} else if (name != NULL)
- elem_copy_text(elem->id, name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(elem->id, name, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
switch (type) {
case SND_TPLG_TYPE_DATA:
sc = elem->stream_caps;
sc->size = elem->size;
- elem_copy_text(sc->name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(sc->name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg(" PCM Capabilities: %s\n", elem->id);
/* store stream caps name, to find and merge
* the caps in building phase.
*/
- elem_copy_text(caps[stream].name, value,
+ snd_strlcpy(caps[stream].name, value,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg("\t\t%s\n\t\t\t%s\n", id, value);
snd_config_get_id(cfg, &id);
tplg_dbg("\t\tFE DAI %s:\n", id);
- elem_copy_text(pcm->dai_name, id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(pcm->dai_name, id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
snd_config_for_each(i, next, cfg) {
pcm = elem->pcm;
pcm->size = elem->size;
- elem_copy_text(pcm->pcm_name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(pcm->pcm_name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg(" PCM: %s\n", elem->id);
dai = elem->dai;
dai->size = elem->size;
- elem_copy_text(dai->dai_name, elem->id,
+ snd_strlcpy(dai->dai_name, elem->id,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg(" DAI: %s\n", elem->id);
link = elem->link;
link->size = elem->size;
- elem_copy_text(link->name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
+ snd_strlcpy(link->name, elem->id, SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg(" Link: %s\n", elem->id);
if (snd_config_get_string(n, &val) < 0)
return -EINVAL;
- elem_copy_text(link->stream_name, val,
+ snd_strlcpy(link->stream_name, val,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg("\t%s: %s\n", id, val);
continue;
static void tplg_add_stream_object(struct snd_soc_tplg_stream *strm,
struct snd_tplg_stream_template *strm_tpl)
{
- elem_copy_text(strm->name, strm_tpl->name,
+ snd_strlcpy(strm->name, strm_tpl->name,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
strm->format = strm_tpl->format;
strm->rate = strm_tpl->rate;
static void tplg_add_stream_caps(struct snd_soc_tplg_stream_caps *caps,
struct snd_tplg_stream_caps_template *caps_tpl)
{
- elem_copy_text(caps->name, caps_tpl->name,
+ snd_strlcpy(caps->name, caps_tpl->name,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
caps->formats = caps_tpl->formats;
pcm = elem->pcm;
pcm->size = elem->size;
- elem_copy_text(pcm->pcm_name, pcm_tpl->pcm_name,
+ snd_strlcpy(pcm->pcm_name, pcm_tpl->pcm_name,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
- elem_copy_text(pcm->dai_name, pcm_tpl->dai_name,
+ snd_strlcpy(pcm->dai_name, pcm_tpl->dai_name,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
pcm->pcm_id = pcm_tpl->pcm_id;
pcm->dai_id = pcm_tpl->dai_id;
/* ID and names */
link->id = link_tpl->id;
- elem_copy_text(link->name, link_tpl->name,
+ snd_strlcpy(link->name, link_tpl->name,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
- elem_copy_text(link->stream_name, link_tpl->stream_name,
+ snd_strlcpy(link->stream_name, link_tpl->stream_name,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
/* stream configs */
dai = elem->dai;
dai->size = elem->size;
- elem_copy_text(dai->dai_name, dai_tpl->dai_name,
+ snd_strlcpy(dai->dai_name, dai_tpl->dai_name,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
dai->dai_id = dai_tpl->dai_id;
if (snd_config_get_string(n, &value) < 0)
continue;
- elem_copy_text(&texts->items[j][0], value,
+ snd_strlcpy(&texts->items[j][0], value,
SNDRV_CTL_ELEM_ID_NAME_MAXLEN);
tplg_dbg("\t%s\n", &texts->items[j][0]);
struct tplg_elem* tplg_elem_new_common(snd_tplg_t *tplg,
snd_config_t *cfg, const char *name, enum snd_tplg_type type);
-static inline void elem_copy_text(char *dest, const char *src, int len)
-{
- if (!dest || !src || !len)
- return;
-
- strncpy(dest, src, len);
- dest[len - 1] = 0;
-}
-
int tplg_parse_channel(snd_tplg_t *tplg ATTRIBUTE_UNUSED,
snd_config_t *cfg, void *private);