static
sdp_media_t *media_dup(char **pp,
sdp_media_t const *src,
sdp_session_t *sdp)
{
char *p;
sdp_media_t *m;
p = *pp;
STRUCT_DUP(p, m, src);
m->m_next = NULL;
STR_DUP(p, m, src, m_type_name);
STR_DUP(p, m, src, m_proto_name);
LST_DUP(p, m, src, m_format, list_dup);
LST_DUP(p, m, src, m_rtpmaps, rtpmap_dup);
STR_DUP(p, m, src, m_information);
LST_DUP(p, m, src, m_connections, connection_dup);
LST_DUP(p, m, src, m_bandwidths, bandwidth_dup);
PTR_DUP(p, m, src, m_key, key_dup);
LST_DUP(p, m, src, m_attributes, attribute_dup);
/* note! we must not implicitly use 'src->m_session' as it
might point to a temporary session */
m->m_session = sdp;
m->m_rejected = src->m_rejected;
m->m_mode = src->m_mode;
assert((size_t)(p - *pp) == media_xtra(src));
*pp = p;
return m;
}
static
sdp_session_t *session_dup(char **pp, sdp_session_t const *src)
{
char *p;
sdp_session_t *sdp;
p = *pp;
STRUCT_DUP(p, sdp, src);
sdp->sdp_next = NULL;
PTR_DUP(p, sdp, src, sdp_origin, origin_dup);
STR_DUP(p, sdp, src, sdp_subject);
STR_DUP(p, sdp, src, sdp_information);
STR_DUP(p, sdp, src, sdp_uri);
LST_DUP(p, sdp, src, sdp_emails, list_dup);
LST_DUP(p, sdp, src, sdp_phones, list_dup);
LST_DUP(p, sdp, src, sdp_connection, connection_dup);
LST_DUP(p, sdp, src, sdp_bandwidths, bandwidth_dup);
LST_DUP(p, sdp, src, sdp_time, time_dup);
PTR_DUP(p, sdp, src, sdp_key, key_dup);
LST_DUP(p, sdp, src, sdp_attributes, attribute_dup);
STR_DUP(p, sdp, src, sdp_charset);
MED_DUP_ALL(p, sdp, src, sdp_media);
assert((size_t)(p - *pp) == session_xtra(src));
*pp = p;
return sdp;
}
static
sdp_media_t *media_dup_ex(char **pp,
sdp_media_t const *src,
sdp_session_t *sdp,
sdp_connection_t *dst_c,
sdp_connection_t const *src_c)
{
char *p;
sdp_media_t *retval = NULL, *m, **mm = &retval;
int xtra = media_xtra_ex(src, src_c);
p = *pp;
for (; src; src = src->m_next) {
p += STRUCT_ALIGN(p);
STRUCT_DUP(p, m, src);
m->m_next = NULL;
STR_DUP(p, m, src, m_type_name);
STR_DUP(p, m, src, m_proto_name);
LST_DUP(p, m, src, m_format, list_dup);
LST_DUP(p, m, src, m_rtpmaps, rtpmap_dup);
STR_DUP(p, m, src, m_information);
if (src_c != src->m_connections)
LST_DUP(p, m, src, m_connections, connection_dup);
else
m->m_connections = dst_c;
LST_DUP(p, m, src, m_bandwidths, bandwidth_dup);
PTR_DUP(p, m, src, m_key, key_dup);
LST_DUP(p, m, src, m_attributes, attribute_dup);
/* note! we must not implicitly use 'src->m_session' as it
might point to a temporary session */
m->m_session = sdp;
m->m_rejected = src->m_rejected;
m->m_mode = src->m_mode;
assert(m);
*mm = m; mm = &m->m_next;
}
assert(p - *pp == xtra);
*pp = p;
return retval;
}
static
sdp_key_t *key_dup(char **pp, sdp_key_t const *src)
{
char *p;
sdp_key_t *k;
p = *pp;
STRUCT_DUP(p, k, src);
STR_DUP(p, k, src, k_method_name);
STR_DUP(p, k, src, k_material);
assert((size_t)(p - *pp) == key_xtra(src));
*pp = p;
return k;
}
static
sdp_attribute_t *attribute_dup(char **pp, sdp_attribute_t const *src)
{
char *p;
sdp_attribute_t *a;
p = *pp;
STRUCT_DUP(p, a, src);
a->a_next = NULL;
STR_DUP(p, a, src, a_name);
STR_DUP(p, a, src, a_value);
assert((size_t)(p - *pp) == attribute_xtra(src));
*pp = p;
return a;
}
int __tagcat(struct req *req, const char *tagcat, int page, char *tmpl,
bool istag)
{
const unsigned int posts_per_page = req->opts.index_stories;
struct post *posts[posts_per_page];
struct str *tag;
int nposts;
if (!tagcat)
return R404(req, NULL);
tag = STR_DUP(tagcat);
req_head(req, "Content-Type", "text/html");
page = MAX(page, 0);
__store_title(&req->vars, tagcat);
__store_pages(&req->vars, page);
__store_tag(&req->vars, tagcat);
sidebar(req);
vars_scope_push(&req->vars);
nposts = index_get_posts(posts, tag, istag, NULL, NULL,
page * posts_per_page, posts_per_page);
load_posts(req, posts, nposts, nposts == posts_per_page);
str_putref(tag);
req->body = render_page(req, tmpl);
return 0;
}
static
sdp_rtpmap_t *rtpmap_dup(char **pp, sdp_rtpmap_t const *src)
{
char *p;
sdp_rtpmap_t *rm;
p = *pp;
STRUCT_DUP(p, rm, src);
rm->rm_next = NULL;
STR_DUP(p, rm, src, rm_encoding);
STR_DUP(p, rm, src, rm_params);
STR_DUP(p, rm, src, rm_fmtp);
assert((size_t)(p - *pp) == rtpmap_xtra(src));
*pp = p;
return rm;
}
static void config_load_str(struct val *lv, const char *vname,
struct str **ret, const char *def)
{
struct str *s;
s = sexpr_alist_lookup_str(lv, vname);
if (s)
*ret = s;
else if (def)
*ret = STR_DUP(def);
else
*ret = NULL;
}
static
sdp_list_t *list_dup(char **pp, sdp_list_t const *src)
{
char *p;
sdp_list_t *l;
p = *pp;
STRUCT_DUP(p, l, src);
l->l_next = NULL;
STR_DUP(p, l, src, l_text);
assert((size_t)(p - *pp) == list_xtra(src));
*pp = p;
return l;
}
static
sdp_bandwidth_t *bandwidth_dup(char **pp, sdp_bandwidth_t const *src)
{
char *p;
sdp_bandwidth_t *b;
p = *pp;
STRUCT_DUP(p, b, src);
b->b_next = NULL;
STR_DUP(p, b, src, b_modifier_name);
assert((size_t)(p - *pp) == bandwidth_xtra(src));
*pp = p;
return b;
}
static
sdp_connection_t *connection_dup(char **pp, sdp_connection_t const *src)
{
char *p;
sdp_connection_t *c;
p = *pp;
STRUCT_DUP(p, c, src);
c->c_next = NULL;
STR_DUP(p, c, src, c_address);
assert((size_t)(p - *pp) == connection_xtra(src));
*pp = p;
return c;
}
static
sdp_origin_t *origin_dup(char **pp, sdp_origin_t const *src)
{
char *p;
sdp_origin_t *o;
p = *pp;
STRUCT_DUP(p, o, src);
STR_DUP(p, o, src, o_username);
PTR_DUP(p, o, src, o_address, connection_dup);
assert((size_t)(p - *pp) == origin_xtra(src));
*pp = p;
return o;
}
struct str *listing(struct post *post, const char *fname)
{
char path[FILENAME_MAX];
struct str *in;
snprintf(path, FILENAME_MAX, "%s/posts/%d/%s",
str_cstr(config.data_dir), post->id, fname);
in = file_cache_get_cb(path, post->preview ? NULL : revalidate_post,
post);
if (IS_ERR(in))
goto err;
return listing_str(in);
err:
snprintf(path, FILENAME_MAX, "Failed to read in listing '%d/%s': %s",
post->id, fname, xstrerror(PTR_ERR(in)));
return STR_DUP(path);
}
struct str *str_cat(size_t n, ...)
{
size_t totallen;
char *buf, *out;
struct val **vals;
size_t *len;
va_list ap;
size_t i;
if (!n)
return &empty_string;
if (n == 1) {
struct val *val;
struct str *ret;
va_start(ap, n);
val = va_arg(ap, struct val *);
va_end(ap);
if (val->type == VT_STR)
return val_cast_to_str(val);
ret = STR_DUP(val_cstr(val));
val_putref(val);
return ret;
}
totallen = 0;
len = alloca(sizeof(size_t) * n);
vals = alloca(sizeof(struct val *) * n);
va_start(ap, n);
for (i = 0; i < n; i++) {
struct val *val = va_arg(ap, struct val *);
if (!val) {
len[i] = 0;
vals[i] = NULL;
} else {
len[i] = get_len(val);
vals[i] = val;
totallen += len[i];
}
}
va_end(ap);
buf = malloc(totallen + 1);
ASSERT(buf);
buf[0] = '\0';
out = buf;
for (i = 0; i < n; i++) {
struct val *val = vals[i];
if (!val)
continue;
strcpy(out, val_cstr(val));
out += len[i];
val_putref(val);
}
return STR_ALLOC(buf);
}
