size_t tcp_dump(const parse_frame *f, int opt, FILE *out)
{
const tcp *t = (tcp *)f->off;
int bytes = fprintf(out,
"%s "
"srcport=%hu dstport=%hu seqno=%lu ackno=%lu "
"fin=%u syn=%u rst=%u psh=%u ack=%u urg=%u ecn=%u cwr=%u "
"res=0x%hx off=%u win=%hu chksum=0x%04hx urgptr=%hu\n",
Iface_TCP.shortname,
t->srcport, t->dstport, (unsigned long)t->seqno, (unsigned long)t->ackno,
t->fin, t->syn, t->rst, t->psh, t->ack, t->urg, t->ecn, t->cwr,
t->reserved, t->off, t->window, t->chksum, t->urgptr);
bytes += dump_opts(t, f, opt, out);
return (size_t)bytes;
}
/* called without aufs lock */
int au_opts_parse(struct super_block *sb, char *str, struct au_opts *opts)
{
int err, n, token;
aufs_bindex_t bindex;
unsigned char skipped;
struct dentry *root;
struct au_opt *opt, *opt_tail;
char *opt_str;
/* reduce the stack space */
union {
struct au_opt_xino_itrunc *xino_itrunc;
struct au_opt_wbr_create *create;
} u;
struct {
substring_t args[MAX_OPT_ARGS];
} *a;
err = -ENOMEM;
a = kmalloc(sizeof(*a), GFP_NOFS);
if (unlikely(!a))
goto out;
root = sb->s_root;
err = 0;
bindex = 0;
opt = opts->opt;
opt_tail = opt + opts->max_opt - 1;
opt->type = Opt_tail;
while (!err && (opt_str = strsep(&str, ",")) && *opt_str) {
err = -EINVAL;
skipped = 0;
token = match_token(opt_str, options, a->args);
switch (token) {
case Opt_br:
err = 0;
while (!err && (opt_str = strsep(&a->args[0].from, ":"))
&& *opt_str) {
err = opt_add(opt, opt_str, opts->sb_flags,
bindex++);
if (unlikely(!err && ++opt > opt_tail)) {
err = -E2BIG;
break;
}
opt->type = Opt_tail;
skipped = 1;
}
break;
case Opt_add:
if (unlikely(match_int(&a->args[0], &n))) {
pr_err("bad integer in %s\n", opt_str);
break;
}
bindex = n;
err = opt_add(opt, a->args[1].from, opts->sb_flags,
bindex);
if (!err)
opt->type = token;
break;
case Opt_append:
err = opt_add(opt, a->args[0].from, opts->sb_flags,
/*dummy bindex*/1);
if (!err)
opt->type = token;
break;
case Opt_prepend:
err = opt_add(opt, a->args[0].from, opts->sb_flags,
/*bindex*/0);
if (!err)
opt->type = token;
break;
case Opt_del:
err = au_opts_parse_del(&opt->del, a->args);
if (!err)
opt->type = token;
break;
#if 0 /* reserved for future use */
case Opt_idel:
del->pathname = "(indexed)";
if (unlikely(match_int(&args[0], &n))) {
pr_err("bad integer in %s\n", opt_str);
break;
}
err = au_opts_parse_idel(sb, n, &opt->del, a->args);
if (!err)
opt->type = token;
break;
#endif
case Opt_mod:
err = au_opts_parse_mod(&opt->mod, a->args);
if (!err)
opt->type = token;
break;
#ifdef IMOD /* reserved for future use */
case Opt_imod:
u.mod->path = "(indexed)";
if (unlikely(match_int(&a->args[0], &n))) {
pr_err("bad integer in %s\n", opt_str);
break;
}
err = au_opts_parse_imod(sb, n, &opt->mod, a->args);
if (!err)
opt->type = token;
break;
#endif
case Opt_xino:
err = au_opts_parse_xino(sb, &opt->xino, a->args);
if (!err)
opt->type = token;
break;
case Opt_trunc_xino_path:
err = au_opts_parse_xino_itrunc_path
(sb, &opt->xino_itrunc, a->args);
if (!err)
opt->type = token;
break;
case Opt_itrunc_xino:
u.xino_itrunc = &opt->xino_itrunc;
if (unlikely(match_int(&a->args[0], &n))) {
pr_err("bad integer in %s\n", opt_str);
break;
}
u.xino_itrunc->bindex = n;
aufs_read_lock(root, AuLock_FLUSH);
if (n < 0 || au_sbend(sb) < n) {
pr_err("out of bounds, %d\n", n);
aufs_read_unlock(root, !AuLock_IR);
break;
}
aufs_read_unlock(root, !AuLock_IR);
err = 0;
opt->type = token;
break;
case Opt_dirwh:
if (unlikely(match_int(&a->args[0], &opt->dirwh)))
break;
err = 0;
opt->type = token;
break;
case Opt_rdcache:
if (unlikely(match_int(&a->args[0], &n))) {
pr_err("bad integer in %s\n", opt_str);
break;
}
if (unlikely(n > AUFS_RDCACHE_MAX)) {
pr_err("rdcache must be smaller than %d\n",
AUFS_RDCACHE_MAX);
break;
}
opt->rdcache = n;
err = 0;
opt->type = token;
break;
case Opt_rdblk:
if (unlikely(match_int(&a->args[0], &n)
|| n < 0
|| n > KMALLOC_MAX_SIZE)) {
pr_err("bad integer in %s\n", opt_str);
break;
}
if (unlikely(n && n < NAME_MAX)) {
pr_err("rdblk must be larger than %d\n",
NAME_MAX);
break;
}
opt->rdblk = n;
err = 0;
opt->type = token;
break;
case Opt_rdhash:
if (unlikely(match_int(&a->args[0], &n)
|| n < 0
|| n * sizeof(struct hlist_head)
> KMALLOC_MAX_SIZE)) {
pr_err("bad integer in %s\n", opt_str);
break;
}
opt->rdhash = n;
err = 0;
opt->type = token;
break;
case Opt_trunc_xino:
case Opt_notrunc_xino:
case Opt_noxino:
case Opt_trunc_xib:
case Opt_notrunc_xib:
case Opt_shwh:
case Opt_noshwh:
case Opt_plink:
case Opt_noplink:
case Opt_list_plink:
case Opt_dio:
case Opt_nodio:
case Opt_diropq_a:
case Opt_diropq_w:
case Opt_warn_perm:
case Opt_nowarn_perm:
case Opt_refrof:
case Opt_norefrof:
case Opt_verbose:
case Opt_noverbose:
case Opt_sum:
case Opt_nosum:
case Opt_wsum:
case Opt_rdblk_def:
case Opt_rdhash_def:
err = 0;
opt->type = token;
break;
case Opt_udba:
opt->udba = udba_val(a->args[0].from);
if (opt->udba >= 0) {
err = 0;
opt->type = token;
} else
pr_err("wrong value, %s\n", opt_str);
break;
case Opt_wbr_create:
u.create = &opt->wbr_create;
u.create->wbr_create
= au_wbr_create_val(a->args[0].from, u.create);
if (u.create->wbr_create >= 0) {
err = 0;
opt->type = token;
} else
pr_err("wrong value, %s\n", opt_str);
break;
case Opt_wbr_copyup:
opt->wbr_copyup = au_wbr_copyup_val(a->args[0].from);
if (opt->wbr_copyup >= 0) {
err = 0;
opt->type = token;
} else
pr_err("wrong value, %s\n", opt_str);
break;
case Opt_ignore:
pr_warn("ignored %s\n", opt_str);
/*FALLTHROUGH*/
case Opt_ignore_silent:
skipped = 1;
err = 0;
break;
case Opt_err:
pr_err("unknown option %s\n", opt_str);
break;
}
if (!err && !skipped) {
if (unlikely(++opt > opt_tail)) {
err = -E2BIG;
opt--;
opt->type = Opt_tail;
break;
}
opt->type = Opt_tail;
}
}
kfree(a);
dump_opts(opts);
if (unlikely(err))
au_opts_free(opts);
out:
return err;
}
