static int process_session_attributes(struct sdp_chopper *chop, struct sdp_attributes *attrs,
struct sdp_ng_flags *flags)
{
GList *l;
struct sdp_attribute *attr;
for (l = attrs->list.head; l; l = l->next) {
attr = l->data;
switch (attr->attr) {
case ATTR_ICE:
case ATTR_ICE_UFRAG:
case ATTR_ICE_PWD:
case ATTR_ICE_OPTIONS:
case ATTR_ICE_LITE:
if (!flags->ice_remove && !flags->ice_force)
break;
goto strip;
case ATTR_CANDIDATE:
if (flags->ice_force_relay) {
if ((attr->u.candidate.type_str.len == 5) &&
(strncasecmp(attr->u.candidate.type_str.s, "relay", 5) == 0))
goto strip;
else
break;
}
if (!flags->ice_remove && !flags->ice_force)
break;
goto strip;
case ATTR_EXTMAP:
case ATTR_INACTIVE:
case ATTR_SENDONLY:
case ATTR_RECVONLY:
case ATTR_SENDRECV:
case ATTR_FINGERPRINT:
case ATTR_SETUP:
goto strip;
case ATTR_GROUP:
if (attr->u.group.semantics == GROUP_BUNDLE)
goto strip;
break;
default:
break;
}
continue;
strip:
if (copy_up_to(chop, &attr->full_line))
return -1;
if (skip_over(chop, &attr->full_line))
return -1;
}
return 0;
}
static int replace_network_address(struct sdp_chopper *chop, struct network_address *address,
struct packet_stream *ps, struct sdp_ng_flags *flags)
{
char buf[64];
int len;
struct packet_stream *sink = packet_stream_sink(ps);
if (is_addr_unspecified(&address->parsed)
&& !(sink && is_trickle_ice_address(&sink->advertised_endpoint)))
return 0;
if (copy_up_to(chop, &address->address_type))
return -1;
if (flags->media_address.s && is_addr_unspecified(&flags->parsed_media_address))
__parse_address(&flags->parsed_media_address, NULL, NULL, &flags->media_address);
if (!is_addr_unspecified(&flags->parsed_media_address))
len = sprintf(buf, "%s %s",
flags->parsed_media_address.family->rfc_name,
sockaddr_print_buf(&flags->parsed_media_address));
else
call_stream_address46(buf, ps, SAF_NG, &len, NULL);
chopper_append_dup(chop, buf, len);
if (skip_over(chop, &address->address))
return -1;
return 0;
}
static int replace_network_address(struct sdp_chopper *chop, struct network_address *address,
struct packet_stream *ps, struct sdp_ng_flags *flags)
{
char buf[64];
int len;
struct packet_stream *sink = packet_stream_sink(ps);
if (is_addr_unspecified(&address->parsed)
&& !(sink && is_trickle_ice_address(&sink->advertised_endpoint)))
return 0;
if (copy_up_to(chop, &address->address_type))
return -1;
if (flags->media_address.s && is_addr_unspecified(&flags->parsed_media_address))
__parse_address(&flags->parsed_media_address, NULL, NULL, &flags->media_address);
if (!is_addr_unspecified(&flags->parsed_media_address)) {
if (IN6_IS_ADDR_V4MAPPED(&flags->parsed_media_address))
len = sprintf(buf, "IP4 " IPF, IPP(flags->parsed_media_address.s6_addr32[3]));
else {
memcpy(buf, "IP6 ", 4);
inet_ntop(AF_INET6, &flags->parsed_media_address, buf + 4, sizeof(buf)-4);
len = strlen(buf);
}
}
else
call_stream_address(buf, ps, SAF_NG, &len);
chopper_append_dup(chop, buf, len);
if (skip_over(chop, &address->address))
return -1;
return 0;
}
static int
load_vmis(const char *file)
{ FILE *fd = fopen(file, "r");
if ( fd )
{ char buf[1024];
int line = 0;
while(fgets(buf, sizeof(buf), fd))
{ line++;
if ( strncmp(buf, "VMI(", 4) == 0 )
{ const char *s1 = skip_ws(buf+4);
const char *e1 = skip_id(s1);
const char *s2 = skip_ws(skip_over(e1, ','));
const char *e2 = skip_flags(s2);
const char *s3 = skip_ws(skip_over(e2, ','));
const char *e3 = skip_flags(s3);
const char *s4 = skip_over(skip_ws(skip_over(e3, ',')), '(');
const char *e4 = skip_over(s4, ')');
if ( !e4 )
{ fprintf(stderr, "Syntax error at %s:%d\n", file, line);
exit(1);
} else
e4--; /* backspace over ) */
vmi_list[vmi_count].name = my_strndup(s1, e1-s1);
vmi_list[vmi_count].flags = my_strndup(s2, e2-s2);
vmi_list[vmi_count].argc = my_strndup(s3, e3-s3);
vmi_list[vmi_count].args = my_strndup(s4, e4-s4);
add_synopsis(s1, e1-s1); /* flags (s2) isn't needed for VM signature */
add_synopsis(s3, e3-s3);
add_synopsis(s4, e4-s4);
vmi_count++;
}
}
fclose(fd);
return 0;
}
return -1;
}
bool operator()(
Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper) const
{
typedef qi::detail::reset_on_exit<Iterator
, traits::is_multi_pass<Iterator>::value &&
(action == retry || action == fail)> on_exit_type;
on_exit_type on_exit(first);
for(;;)
{
try
{
return subject(first, last, context, skipper);
}
catch (expectation_failure2<ID, Iterator> const& x)
{
typedef
fusion::vector<
Iterator&
, Iterator const&
, Iterator const&
, ID>
params;
error_handler_result r = action;
skip_over(first, last, skipper);
params args(first, last, x.first, x.id);
f(args, context, r);
// The assertions below will fire if you are using a
// multi_pass as the underlying iterator, one of your error
// handlers forced its guarded rule to 'fail' or 'retry',
// and the error handler has not been instantiated using
// either 'fail' or 'retry' in the first place. Please see
// the multi_pass docs for more information.
switch (r)
{
case fail:
BOOST_ASSERT(
!traits::is_multi_pass<Iterator>::value ||
action == retry || action == fail);
return false;
case retry:
BOOST_ASSERT(
!traits::is_multi_pass<Iterator>::value ||
action == retry || action == fail);
continue;
case accept: return true;
case rethrow: boost::throw_exception(x);
}
}
}
return false;
}
static int replace_transport_protocol(struct sdp_chopper *chop,
struct sdp_media *media, struct call_media *cm)
{
str *tp = &media->transport;
if (!cm->protocol)
return 0;
if (copy_up_to(chop, tp))
return -1;
chopper_append_c(chop, cm->protocol->name);
if (skip_over(chop, tp))
return -1;
return 0;
}
static int replace_media_port(struct sdp_chopper *chop, struct sdp_media *media, struct packet_stream *ps) {
str *port = &media->port;
unsigned int p;
if (!media->port_num)
return 0;
if (copy_up_to(chop, port))
return -1;
p = ps->sfd ? ps->sfd->fd.localport : 0;
chopper_append_printf(chop, "%u", p);
if (skip_over(chop, port))
return -1;
return 0;
}
bool operator()(
Iterator& first, Iterator const& last
, Context& context, Skipper const& skipper) const
{
Iterator i = first;
bool r = subject(i, last, context, skipper);
if (r)
{
typedef
fusion::vector<
Iterator&
, Iterator const&
, Iterator const&>
params;
skip_over(first, last, skipper);
params args(first, last, i);
f(args, context);
first = i;
}
return r;
}
static int
read_mtree_keywords(FILE *fp, fsnode *node)
{
char keyword[PATH_MAX];
char *name, *p, *value;
gid_t gid;
uid_t uid;
struct stat *st, sb;
intmax_t num;
u_long flset, flclr;
int error, istemp, type;
st = &node->inode->st;
do {
error = skip_over(fp, " \t");
if (error)
break;
error = read_word(fp, keyword, sizeof(keyword));
if (error)
break;
if (keyword[0] == '\0')
break;
value = strchr(keyword, '=');
if (value != NULL)
*value++ = '\0';
/*
* We use EINVAL, ENOATTR, ENOSYS and ENXIO to signal
* certain conditions:
* EINVAL - Value provided for a keyword that does
* not take a value. The value is ignored.
* ENOATTR - Value missing for a keyword that needs
* a value. The keyword is ignored.
* ENOSYS - Unsupported keyword encountered. The
* keyword is ignored.
* ENXIO - Value provided for a keyword that does
* not take a value. The value is ignored.
*/
switch (keyword[0]) {
case 'c':
if (strcmp(keyword, "contents") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
node->contents = strdup(value);
} else
error = ENOSYS;
break;
case 'f':
if (strcmp(keyword, "flags") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
flset = flclr = 0;
if (!strtofflags(&value, &flset, &flclr)) {
st->st_flags &= ~flclr;
st->st_flags |= flset;
} else
error = errno;
} else
error = ENOSYS;
break;
case 'g':
if (strcmp(keyword, "gid") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
error = read_number(value, 10, &num,
0, UINT_MAX);
if (!error)
st->st_gid = num;
} else if (strcmp(keyword, "gname") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
if (gid_from_group(value, &gid) == 0)
st->st_gid = gid;
else
error = EINVAL;
} else
error = ENOSYS;
break;
case 'l':
if (strcmp(keyword, "link") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
node->symlink = strdup(value);
} else
error = ENOSYS;
break;
case 'm':
if (strcmp(keyword, "mode") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
if (value[0] >= '0' && value[0] <= '9') {
error = read_number(value, 8, &num,
0, 07777);
if (!error) {
st->st_mode &= S_IFMT;
st->st_mode |= num;
}
} else {
/* Symbolic mode not supported. */
error = EINVAL;
break;
}
} else
error = ENOSYS;
break;
case 'o':
if (strcmp(keyword, "optional") == 0) {
if (value != NULL)
error = ENXIO;
node->flags |= FSNODE_F_OPTIONAL;
} else
error = ENOSYS;
break;
case 's':
if (strcmp(keyword, "size") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
error = read_number(value, 10, &num,
0, INTMAX_MAX);
if (!error)
st->st_size = num;
} else
error = ENOSYS;
break;
case 't':
if (strcmp(keyword, "time") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
p = strchr(value, '.');
if (p != NULL)
*p++ = '\0';
error = read_number(value, 10, &num, 0,
INTMAX_MAX);
if (error)
break;
st->st_atime = num;
st->st_ctime = num;
st->st_mtime = num;
if (p == NULL)
break;
error = read_number(p, 10, &num, 0,
INTMAX_MAX);
if (error)
break;
if (num != 0)
error = EINVAL;
} else if (strcmp(keyword, "type") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
if (strcmp(value, "dir") == 0)
node->type = S_IFDIR;
else if (strcmp(value, "file") == 0)
node->type = S_IFREG;
else if (strcmp(value, "link") == 0)
node->type = S_IFLNK;
else
error = EINVAL;
} else
error = ENOSYS;
break;
case 'u':
if (strcmp(keyword, "uid") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
error = read_number(value, 10, &num,
0, UINT_MAX);
if (!error)
st->st_uid = num;
} else if (strcmp(keyword, "uname") == 0) {
if (value == NULL) {
error = ENOATTR;
break;
}
if (uid_from_user(value, &uid) == 0)
st->st_uid = uid;
else
error = EINVAL;
} else
error = ENOSYS;
break;
default:
error = ENOSYS;
break;
}
switch (error) {
case EINVAL:
mtree_error("%s: invalid value '%s'", keyword, value);
break;
case ENOATTR:
mtree_error("%s: keyword needs a value", keyword);
break;
case ENOSYS:
mtree_warning("%s: unsupported keyword", keyword);
break;
case ENXIO:
mtree_error("%s: keyword does not take a value",
keyword);
break;
}
} while (1);
if (error)
return (error);
st->st_mode = (st->st_mode & ~S_IFMT) | node->type;
/* Nothing more to do for the global defaults. */
if (node->name == NULL)
return (0);
/*
* Be intelligent about the file type.
*/
if (node->contents != NULL) {
if (node->symlink != NULL) {
mtree_error("%s: both link and contents keywords "
"defined", node->name);
return (0);
}
type = S_IFREG;
} else if (node->type != 0) {
type = node->type;
if (type == S_IFREG) {
/* the named path is the default contents */
node->contents = mtree_file_path(node);
}
} else
type = (node->symlink != NULL) ? S_IFLNK : S_IFDIR;
if (node->type == 0)
node->type = type;
if (node->type != type) {
mtree_error("%s: file type and defined keywords to not match",
node->name);
return (0);
}
st->st_mode = (st->st_mode & ~S_IFMT) | node->type;
if (node->contents == NULL)
return (0);
name = mtree_resolve(node->contents, &istemp);
if (name == NULL)
return (errno);
if (stat(name, &sb) != 0) {
mtree_error("%s: contents file '%s' not found", node->name,
name);
free(name);
return (0);
}
/*
* Check for hardlinks. If the contents key is used, then the check
* will only trigger if the contents file is a link even if it is used
* by more than one file
*/
if (sb.st_nlink > 1) {
fsinode *curino;
st->st_ino = sb.st_ino;
st->st_dev = sb.st_dev;
curino = link_check(node->inode);
if (curino != NULL) {
free(node->inode);
node->inode = curino;
node->inode->nlink++;
}
}
free(node->contents);
node->contents = name;
st->st_size = sb.st_size;
return (0);
}
fsnode *
read_mtree(const char *fname, fsnode *node)
{
struct mtree_fileinfo *fi;
FILE *fp;
int c, error;
/* We do not yet support nesting... */
assert(node == NULL);
if (strcmp(fname, "-") == 0)
fp = stdin;
else {
fp = fopen(fname, "r");
if (fp == NULL)
err(1, "Can't open `%s'", fname);
}
error = mtree_file_push(fname, fp);
if (error)
goto out;
bzero(&mtree_global, sizeof(mtree_global));
bzero(&mtree_global_inode, sizeof(mtree_global_inode));
mtree_global.inode = &mtree_global_inode;
mtree_global_inode.nlink = 1;
mtree_global_inode.st.st_nlink = 1;
mtree_global_inode.st.st_atime = mtree_global_inode.st.st_ctime =
mtree_global_inode.st.st_mtime = time(NULL);
errors = warnings = 0;
setgroupent(1);
setpassent(1);
mtree_root = node;
mtree_current = node;
do {
/* Start of a new line... */
fi = SLIST_FIRST(&mtree_fileinfo);
fi->line++;
error = skip_over(fp, " \t");
if (error)
break;
c = getc(fp);
if (c == EOF) {
error = ferror(fp) ? errno : -1;
break;
}
switch (c) {
case '\n': /* empty line */
error = 0;
break;
case '#': /* comment -- skip to end of line. */
error = skip_to(fp, "\n");
if (!error)
(void)getc(fp);
break;
case '/': /* special commands */
error = read_mtree_command(fp);
break;
default: /* specification */
ungetc(c, fp);
error = read_mtree_spec(fp);
break;
}
} while (!error);
endpwent();
endgrent();
if (error <= 0 && (errors || warnings)) {
warnx("%u error(s) and %u warning(s) in mtree manifest",
errors, warnings);
if (errors)
exit(1);
}
out:
if (error > 0)
errc(1, error, "Error reading mtree file");
if (fp != stdin)
fclose(fp);
if (mtree_root != NULL)
return (mtree_root);
/* Handle empty specifications. */
node = create_node(".", S_IFDIR, NULL, &mtree_global);
node->first = node;
return (node);
}
skip_inside_pad_outcome (Policy const & policy,
SubParser const & sub_parser, Input const & input)
: policy (policy), outcome (
parse (policy, sub_parser, skip_over (policy.skip_parser(), input))) {}
static int process_media_attributes(struct sdp_chopper *chop, struct sdp_media *sdp,
struct sdp_ng_flags *flags, struct call_media *media)
{
GList *l;
struct sdp_attributes *attrs = &sdp->attributes;
struct sdp_attribute *attr, *a;
for (l = attrs->list.head; l; l = l->next) {
attr = l->data;
switch (attr->attr) {
case ATTR_ICE:
case ATTR_ICE_UFRAG:
case ATTR_ICE_PWD:
case ATTR_ICE_OPTIONS:
case ATTR_ICE_LITE:
if (MEDIA_ISSET(media, PASSTHRU))
break;
if (!flags->ice_remove && !flags->ice_force)
break;
goto strip;
case ATTR_CANDIDATE:
if (MEDIA_ISSET(media, PASSTHRU))
break;
if (flags->ice_force_relay) {
if ((attr->u.candidate.type_str.len == 5) &&
(strncasecmp(attr->u.candidate.type_str.s, "relay", 5) == 0))
goto strip;
else
break;
}
if (!flags->ice_remove && !flags->ice_force)
break;
goto strip;
case ATTR_RTCP:
case ATTR_RTCP_MUX:
if (flags->ice_force_relay)
break;
case ATTR_INACTIVE:
case ATTR_SENDONLY:
case ATTR_RECVONLY:
case ATTR_SENDRECV:
goto strip;
case ATTR_EXTMAP:
case ATTR_CRYPTO:
case ATTR_FINGERPRINT:
case ATTR_SETUP:
if (MEDIA_ISSET(media, PASSTHRU))
break;
goto strip;
case ATTR_MID:
if (MEDIA_ISSET(media, PASSTHRU))
break;
a = attr_get_by_id(&sdp->session->attributes, ATTR_GROUP);
if (a && a->u.group.semantics == GROUP_BUNDLE)
goto strip;
break;
default:
break;
}
continue;
strip:
if (copy_up_to(chop, &attr->full_line))
return -1;
if (skip_over(chop, &attr->full_line))
return -1;
}
return 0;
}
