xt: Rewrite unsupported compat expression dumping
Phil Sutter
reviewercover xt: Rewrite unsupported compat expression dumping
Alternative approach to my previous dump and restore support of xt compat expressions:
If translation is not available or not successful, fall back to a format which allows to be parsed easily.
When parsing, reject these expressions explicitly with a meaningful error message.
Phil Sutter (4):
xt: Delay libxtables access until translation
xt: Purify enum nft_xt_type
xt: Rewrite unsupported compat expression dumping
xt: Fall back to generic printing from translation
doc/libnftables-json.adoc | 18 +++- doc/statements.txt | 17 ++++ include/json.h | 2 + include/parser.h | 1 + include/statement.h | 11 +- src/json.c | 19 ++-- src/parser_bison.y | 18 ++++ src/parser_json.c | 5 + src/scanner.l | 3 + src/statement.c | 1 + src/xt.c | 207 +++++++++++++++----------------------- 11 files changed, 163 insertions(+), 139 deletions(-)
Signature · 1 line
2.38.0
Phil Sutter
reviewerPATCH 1/4 xt: Delay libxtables access until translation
There is no point in spending efforts setting up the xt match/target when it is not printed afterwards. So just store the statement data from libnftnl in struct xt_stmt and perform the extension lookup from xt_stmt_xlate() instead.
This means some data structures are only temporarily allocated for the sake of passing to libxtables callbacks, no need to drag them around. Also no need to clone the looked up extension, it is needed only to call the functions it provides.
While being at it, select numeric output in xt_xlate_*_params - otherwise there will be reverse DNS lookups which should not happen by default.
--- include/statement.h | 9 +-- src/xt.c | 192 ++++++++++++++++++-------------------------- 2 files changed, 80 insertions(+), 121 deletions(-)
include/statement.h +4 -5
@@ -264,12 +264,11 @@ struct xtables_target;struct xt_stmt {const char *name;enum nft_xt_type type; +uint32_t rev; +uint32_t family; +size_t infolen; +void *info;uint32_t proto; -union { -struct xtables_match *match; -struct xtables_target *target; - }; -void *entry; };extern struct stmt *xt_stmt_alloc (const struct location *loc);
src/xt.c +76 -116
278 lines not on this page · raw message
Signature · 1 line
2.38.0
Pablo Neira Ayuso
maintainerRe: [nft PATCH 1/4] xt: Delay libxtables access until translation
Hi Phil,
Quoted 4 lines · Phil Sutter
There is no point in spending efforts setting up the xt match/target when it is not printed afterwards. So just store the statement data from libnftnl in struct
xt_stmtand perform the extension lookup fromxt_stmt_xlate()instead.
There is nft -i and nft monitor which keep a ruleset cache. Both are sort of incomplete: nft -i resorts to cleaning up the cache based on the generation number and nft monitor still needs to be updated to keep track of incremental ruleset updates via netlink events. Sooner or later these two will get better support for incremental ruleset updates.
I mean, in those two cases, every call to print the translation will trigger the allocation of the xt structures, fill them and then call .xlate. I agree it is a bit more work, I guess this won't case any noticeable penalty, but it might be work that needs to be done over and over again when ruleset uses xt match / target.
Phil Sutter
reviewerRe: [nft PATCH 1/4] xt: Delay libxtables access until translation
Hi Pablo,
Quoted 13 lines · Pablo Neira Ayuso
Quoted 4 lines · Phil Sutter
There is no point in spending efforts setting up the xt match/target when it is not printed afterwards. So just store the statement data from libnftnl in struct
xt_stmtand perform the extension lookup fromxt_stmt_xlate()instead.There is nft -i and nft monitor which keep a ruleset cache. Both are sort of incomplete: nft -i resorts to cleaning up the cache based on the generation number and nft monitor still needs to be updated to keep track of incremental ruleset updates via netlink events. Sooner or later these two will get better support for incremental ruleset updates.
Quoted 5 lines
I mean, in those two cases, every call to print the translation will trigger the allocation of the xt structures, fill them and then call .xlate. I agree it is a bit more work, I guess this won't case any noticeable penalty, but it might be work that needs to be done over and over again when ruleset uses xt match / target.
So you're saying the overhead when printing a rule might be more significant than when fetching it. I doubt this simply because the same rule is usually printed at most once and there are multiple other commands requiring a rule cache.
IMO we may also just leave the code as-is and wait for someone to complain about bad performance with rulesets containing many compat expressions. Depending on the actual report, we may also follow a hybrid approach and do the match/target lookup only when needed and cache it for later use.
My patch made most sense with an nft in mind which does not need xtables support for saving/restoring compat expressions. Users depending on this for whatever reason will execute the xlate code path in any case now.
Cheers, Phil
Pablo Neira Ayuso
maintainerRe: [nft PATCH 1/4] xt: Delay libxtables access until translation
Quoted 17 lines · Phil Sutter
Hi Pablo,
Quoted 13 lines · Pablo Neira Ayuso
Quoted 4 lines · Phil Sutter
There is no point in spending efforts setting up the xt match/target when it is not printed afterwards. So just store the statement data from libnftnl in struct
xt_stmtand perform the extension lookup fromxt_stmt_xlate()instead.There is nft -i and nft monitor which keep a ruleset cache. Both are sort of incomplete: nft -i resorts to cleaning up the cache based on the generation number and nft monitor still needs to be updated to keep track of incremental ruleset updates via netlink events. Sooner or later these two will get better support for incremental ruleset updates.
Quoted 8 lines
Quoted 5 lines
I mean, in those two cases, every call to print the translation will trigger the allocation of the xt structures, fill them and then call .xlate. I agree it is a bit more work, I guess this won't case any noticeable penalty, but it might be work that needs to be done over and over again when ruleset uses xt match / target.
So you're saying the overhead when printing a rule might be more significant than when fetching it.
I'm saying that there might be scenarios where, once the xt match/target is set up, we might call .xlate to print it not just once (considering nft -i use case), but see below.
Quoted 7 lines
I doubt this simply because the same rule is usually printed at most once and there are multiple other commands requiring a rule cache.
IMO we may also just leave the code as-is and wait for someone to complain about bad performance with rulesets containing many compat expressions.
Quoted 7 lines
Depending on the actual report, we may also follow a hybrid approach and do the match/target lookup only when needed and cache it for later use.
My patch made most sense with an nft in mind which does not need xtables support for saving/restoring compat expressions. Users depending on this for whatever reason will execute the xlate code path in any case now.
OK, you are refering to commands that do not need ruleset listing, in that case setting up the xt match/target structure makes no sense.
Your original patch description says:
Quoted 2 lines
Also no need to clone the looked up extension, it is needed only to call the functions it provides.
I agree, removing this extra clone is good.
I think this patch is fine, the caching of the xt match/target setup should be easy to do, struct stmt is const on that path, but it could be overrided in this case.
Phil Sutter
reviewerPATCH 2/4 xt: Purify enum nft_xt_type
In reply to Phil SutterRemove NFT_XT_MAX from the enum, it is not a valid xt type.
--- include/statement.h | 2 +- src/xt.c | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-)
include/statement.h +1 -1
@@ -255,8 +255,8 @@ enum nft_xt_type {NFT_XT_MATCH =0 ,NFT_XT_TARGET , NFT_XT_WATCHER, - NFT_XT_MAX }; +#define NFT_XT_MAX (NFT_XT_WATCHER + 1)struct xtables_match ;struct xtables_target ;
src/xt.c +0 -2
@@ -110,8 +110,6 @@ void xt_stmt_xlate(const struct stmt *stmt, struct output_ctx *octx) }xfree (t);break ; -default : -break ; }xt_xlate_free (xl);
Signature · 1 line
2.38.0
Phil Sutter
reviewerPATCH 3/4 xt: Rewrite unsupported compat expression dumping
In reply to Phil SutterChoose a format which provides more information and is easily parseable. Then teach parsers about it and make it explicitly reject the ruleset giving a meaningful explanation. Also update the man pages with some more details.
--- doc/libnftables-json.adoc | 18 +++++++++++++++--- doc/statements.txt | 17 +++++++++++++++++ include/json.h | 2 ++ include/parser.h | 1 + src/json.c | 19 +++++++++++++------ src/parser_bison.y | 18 ++++++++++++++++++ src/parser_json.c | 5 +++++ src/scanner.l | 3 +++ src/statement.c | 1 + src/xt.c | 8 +++++++- 10 files changed, 82 insertions(+), 10 deletions(-)
doc/libnftables-json.adoc +15 -3
@@ -1059,10 +1059,22 @@ Assign connection tracking expectation. === XT [verse] -*{ "xt": null }* +____ +*{ "xt": { + "type":* 'TYPENAME'*, + "name":* 'STRING' +*}}* + +'TYPENAME' := *match* | *target* | *watcher* +____ + +This represents an xt statement from xtables compat interface. It is a +fallback if translation is not available or not complete. + +Seeing this means the ruleset (or parts of it) were created by *iptables-nft* +and one should use that to manage it. -This represents an xt statement from xtables compat interface. Sadly, at this -point, it is not possible to provide any further information about its content. +*BEWARE:* nftables won't restore these statements. == EXPRESSIONS Expressions are the building blocks of (most) statements. In their most basic
doc/statements.txt +17 -0
@@ -783,3 +783,20 @@ ____ # jump to different chains depending on layer 4 protocol type: nft add rule ip filter input ip protocol vmap { tcp : jump tcp-chain, udp : jump udp-chain , icmp : jump icmp-chain } ------------------------ + +XT STATEMENT +~~~~~~~~~~~~ +This represents an xt statement from xtables compat interface. It is a +fallback if translation is not available or not complete. + +[verse] +____ +*xt* 'TYPE' 'NAME' + +'TYPE' := *match* | *target* | *watcher* +____ + +Seeing this means the ruleset (or parts of it) were created by *iptables-nft* +and one should use that to manage it. + +*BEWARE:* nftables won't restore these statements.
include/json.h +2 -0
@@ -92,6 +92,7 @@ json_t *connlimit_stmt_json(const struct stmt *stmt, struct output_ctx *octx);json_t *tproxy_stmt_json (const struct stmt *stmt,struct output_ctx *octx);json_t *synproxy_stmt_json (const struct stmt *stmt,struct output_ctx *octx);json_t *optstrip_stmt_json (const struct stmt *stmt,struct output_ctx *octx); +json_t *xt_stmt_json (const struct stmt *stmt,struct output_ctx *octx);int do_command_list_json (struct netlink_ctx *ctx,struct cmd *cmd);
@@ -194,6 +195,7 @@ STMT_PRINT_STUB(connlimit) STMT_PRINT_STUB(tproxy) STMT_PRINT_STUB(synproxy) STMT_PRINT_STUB(optstrip) +STMT_PRINT_STUB(xt)#undef STMT_PRINT_STUB#undef EXPR_PRINT_STUB
include/parser.h +1 -0
@@ -50,6 +50,7 @@ enum startcond_type {PARSER_SC_TCP ,PARSER_SC_TYPE ,PARSER_SC_VLAN , +PARSER_SC_XT ,PARSER_SC_CMD_EXPORT ,PARSER_SC_CMD_IMPORT , PARSER_SC_CMD_LIST,
src/json.c +13 -6
@@ -82,12 +82,6 @@ static json_t *stmt_print_json(const struct stmt *stmt, struct output_ctx *octx)char buf[1024 ];FILE *fp; -/* XXX: Can't be supported at this point: -* xt_stmt_xlate() ignores output_fp. -*/ -if (stmt->ops->type ==STMT_XT ) -return json_pack ("{s:n}" ,"xt" ); -if (stmt->ops->json)return stmt->ops->json (stmt, octx);
@@ -1624,6 +1618,19 @@ json_t *optstrip_stmt_json(const struct stmt *stmt, struct output_ctx *octx) expr_print_json(stmt->optstrip.expr, octx)); } +json_t *xt_stmt_json (const struct stmt *stmt,struct output_ctx *octx) +{ +static const char *xt_typename[NFT_XT_MAX ] = { + [NFT_XT_MATCH ] ="match" , + [NFT_XT_TARGET ] ="target" , + [NFT_XT_WATCHER ] ="watcher" , + }; + +return json_pack ("{s:{s:s, s:s}}" ,"xt" , +"type" , xt_typename[stmt->xt.type], +"name" , stmt->xt.name); +} +static json_t *table_print_json_full (struct netlink_ctx *ctx,struct table *table) {
src/parser_bison.y +18 -0
@@ -626,6 +626,8 @@ int nft_lex(void *, void *, void *); %token IN "in" %token OUT "out" +%token XT "xt" + %type <limit_rate> limit_rate_pkts %type <limit_rate> limit_rate_bytes
@@ -900,6 +902,9 @@ int nft_lex(void *, void *, void *); %type <stmt> optstrip_stmt %destructor { stmt_free($$); } optstrip_stmt +%type <stmt> xt_stmt +%destructor { stmt_free($$); } xt_stmt + %type <expr> boolean_expr %destructor { expr_free($$); } boolean_expr %type <val8> boolean_keys
@@ -991,6 +996,7 @@ close_scope_udplite : { scanner_pop_start_cond(nft->scanner, PARSER_SC_EXPR_UDPL close_scope_log : { scanner_pop_start_cond(nft->scanner, PARSER_SC_STMT_LOG); } close_scope_synproxy : { scanner_pop_start_cond(nft->scanner, PARSER_SC_STMT_SYNPROXY); } +close_scope_xt : { scanner_pop_start_cond(nft->scanner, PARSER_SC_XT); } common_block : INCLUDE QUOTED_STRING stmt_separator {
@@ -2879,6 +2885,18 @@ stmt : verdict_stmt | synproxy_stmt close_scope_synproxy | chain_stmt | optstrip_stmt + | xt_stmt close_scope_xt + ; + +xt_stmt : XT STRING STRING + { + $$ = NULL; + xfree($2); + xfree($3); + erec_queue(error(&@$, "unsupported xtables compat expression, use iptables-nft with this ruleset"), + state->msgs); + YYERROR; + } ; chain_stmt_type : JUMP { $$ = NFT_JUMP; }
src/parser_json.c +5 -0
@@ -2764,6 +2764,11 @@ static struct stmt *json_parse_stmt(struct json_ctx *ctx, json_t *root)return verdict_stmt_alloc (int_loc, expr); } +if (!strcmp (type,"xt" )) { +json_error (ctx,"unsupported xtables compat expression, use iptables-nft with this ruleset" ); +return NULL ; + } +for (i =0 ; i <array_size (stmt_parser_tbl); i++) {if (!strcmp (type, stmt_parser_tbl[i].key))return stmt_parser_tbl[i].cb (ctx, stmt_parser_tbl[i].key, tmp);
src/scanner.l +3 -0
@@ -214,6 +214,7 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) %s SCANSTATE_TCP %s SCANSTATE_TYPE %s SCANSTATE_VLAN +%s SCANSTATE_XT %s SCANSTATE_CMD_EXPORT %s SCANSTATE_CMD_IMPORT %s SCANSTATE_CMD_LIST
@@ -799,6 +800,8 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) "secmark" { scanner_push_start_cond(yyscanner, SCANSTATE_SECMARK); return SECMARK; } +"xt" { scanner_push_start_cond(yyscanner, SCANSTATE_XT); return XT; } + {addrstring} { yylval->string = xstrdup(yytext); return STRING;
src/statement.c +1 -0
@@ -997,6 +997,7 @@ static const struct stmt_ops xt_stmt_ops = { .name = "xt", .print = xt_stmt_print, .destroy = xt_stmt_destroy, + .json = xt_stmt_json, };struct stmt *xt_stmt_alloc (const struct location *loc)
src/xt.c +7 -1
@@ -115,7 +115,13 @@ void xt_stmt_xlate(const struct stmt *stmt, struct output_ctx *octx)xt_xlate_free (xl);xfree (entry);#else -nft_print (octx,"# xt_%s" , stmt->xt.name); +static const char *typename[NFT_XT_MAX ] = { + [NFT_XT_MATCH ] ="match" , + [NFT_XT_TARGET ] ="target" , + [NFT_XT_WATCHER ] ="watcher" , + }; + +nft_print (octx,"xt %s %s" , typename[stmt->xt.type], stmt->xt.name);#endif }
Signature · 1 line
2.38.0
Florian Westphal
maintainerQuoted 13 lines · Phil Sutter
src/scanner.l +1
-0@@ -214,6 +214,7 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) %s SCANSTATE_TCP %s SCANSTATE_TYPE %s SCANSTATE_VLAN +%s SCANSTATE_XT %s SCANSTATE_CMD_EXPORT %s SCANSTATE_CMD_IMPORT %s SCANSTATE_CMD_LIST
src/scanner.l addrstring ({macaddr}|{ip4addr}|{ip6addr}) · line 803
Quoted 4 lines
src/scanner.l +1
-0@@ -799,6 +800,8 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) "secmark" { scanner_push_start_cond(yyscanner, SCANSTATE_SECMARK); return SECMARK; } +"xt" { scanner_push_start_cond(yyscanner, SCANSTATE_XT); return XT; }
Why is there a new scanner state? It has no tokens, so it doesn't do anything.
Perhaps a leftover? Or did you plan to make match/target/watcher scoped tokens?
Phil Sutter
reviewerQuoted 17 lines · Florian Westphal
Quoted 16 lines · Phil Sutter
src/scanner.l +1
-0@@ -214,6 +214,7 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) %s SCANSTATE_TCP %s SCANSTATE_TYPE %s SCANSTATE_VLAN +%s SCANSTATE_XT %s SCANSTATE_CMD_EXPORT %s SCANSTATE_CMD_IMPORT %s SCANSTATE_CMD_LIST@@ -799,6 +800,8 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) "secmark" { scanner_push_start_cond(yyscanner, SCANSTATE_SECMARK); return SECMARK; }
Quoted 7 lines
src/scanner.l addrstring ({macaddr}|{ip4addr}|{ip6addr}) · line 803
Quoted 1 line
src/scanner.l +1
-0+"xt" { scanner_push_start_cond(yyscanner, SCANSTATE_XT); return XT; }Why is there a new scanner state? It has no tokens, so it doesn't do anything.
Perhaps a leftover? Or did you plan to make match/target/watcher scoped tokens?
We want to accept two arbitrary strings after "xt" and just complain about the whole thing. Without the scope, something like "xt target exthdr" will make the parser complain about the unexpected keyword.
Cheers, Phil
Florian Westphal
maintainerQuoted 23 lines · Phil Sutter
Quoted 22 lines · Florian Westphal
Quoted 13 lines · Phil Sutter
src/scanner.l +1
-0@@ -214,6 +214,7 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) %s SCANSTATE_TCP %s SCANSTATE_TYPE %s SCANSTATE_VLAN +%s SCANSTATE_XT %s SCANSTATE_CMD_EXPORT %s SCANSTATE_CMD_IMPORT %s SCANSTATE_CMD_LISTsrc/scanner.l addrstring ({macaddr}|{ip4addr}|{ip6addr}) · line 803
Quoted 4 lines
src/scanner.l +1
-0@@ -799,6 +800,8 @@ addrstring ({macaddr}|{ip4addr}|{ip6addr}) "secmark" { scanner_push_start_cond(yyscanner, SCANSTATE_SECMARK); return SECMARK; } +"xt" { scanner_push_start_cond(yyscanner, SCANSTATE_XT); return XT; }Why is there a new scanner state? It has no tokens, so it doesn't do anything.
Quoted 6 lines
Quoted 2 lines
Perhaps a leftover? Or did you plan to make match/target/watcher scoped tokens?
We want to accept two arbitrary strings after "xt" and just complain about the whole thing. Without the scope, something like "xt target exthdr" will make the parser complain about the unexpected keyword.
I see. FWIW I'm fine with the series.
Pablo Neira Ayuso
maintainerQuoted 4 lines · Phil Sutter
Choose a format which provides more information and is easily parseable. Then teach parsers about it and make it explicitly reject the ruleset giving a meaningful explanation. Also update the man pages with some more details.
There is a bugzilla ticket related to xt and json support, you can probably add a Closes: tag link.
Phil Sutter
reviewerQuoted 8 lines · Pablo Neira Ayuso
Quoted 4 lines · Phil Sutter
Choose a format which provides more information and is easily parseable. Then teach parsers about it and make it explicitly reject the ruleset giving a meaningful explanation. Also update the man pages with some more details.
There is a bugzilla ticket related to xt and json support, you can probably add a Closes: tag link.
This should be nfbz#1621, but it's about translating xt to native in JSON format. All my patch does is extend the xt JSON format a bit. AIUI, we would have to extend libxtables to provide translations into JSON.
So even with perfect two-ways translation available, JSON interface is unusable if iptables-nft is in use.
Cheers, Phil
Pablo Neira Ayuso
maintainerQuoted 10 lines · Phil Sutter
Quoted 8 lines · Pablo Neira Ayuso
Quoted 4 lines · Phil Sutter
Choose a format which provides more information and is easily parseable. Then teach parsers about it and make it explicitly reject the ruleset giving a meaningful explanation. Also update the man pages with some more details.
There is a bugzilla ticket related to xt and json support, you can probably add a Closes: tag link.
Quoted 6 lines
This should be nfbz#1621, but it's about translating xt to native in JSON format. All my patch does is extend the xt JSON format a bit. AIUI, we would have to extend libxtables to provide translations into JSON.
So even with perfect two-ways translation available, JSON interface is unusable if iptables-nft is in use.
The output of nftables without translation cannot be restored either, this is also going to provide a hint to the user, without allowing it to restore the JSON file.
Phil Sutter
reviewerPATCH 4/4 xt: Fall back to generic printing from translation
In reply to Phil SutterIf translation is not available or fails, print the generic format instead of calling the print callback (which does not respect output_fp) or silently failing.
--- src/xt.c | 31 +++++++++++++------------------ 1 file changed, 13 insertions(+), 18 deletions(-)
src/xt.c +13 -18
@@ -34,6 +34,12 @@ static void *xt_entry_alloc(const struct xt_stmt *xt, uint32_t af);void xt_stmt_xlate (const struct stmt *stmt,struct output_ctx *octx) { +static const char *typename[NFT_XT_MAX ] = { + [NFT_XT_MATCH ] ="match" , + [NFT_XT_TARGET ] ="target" , + [NFT_XT_WATCHER ] ="watcher" , + }; +int rc =0 ;#ifdef HAVE_LIBXTABLES struct xt_xlate *xl =xt_xlate_alloc (10240 );struct xtables_target *tg;
@@ -69,11 +75,7 @@ void xt_stmt_xlate(const struct stmt *stmt, struct output_ctx *octx) .numeric = 1, }; - mt->xlate (xl, ¶ms); -nft_print (octx,"%s" ,xt_xlate_get (xl)); - }else if (mt->print) { -printf ("#" ); - mt->0 ); + rc = mt->xlate (xl, ¶ms); }xfree (m);break ;
@@ -102,27 +104,20 @@ void xt_stmt_xlate(const struct stmt *stmt, struct output_ctx *octx) .numeric = 1, }; - tg->xlate (xl, ¶ms); - nft_print(octx, "%s", xt_xlate_get(xl)); - }else if (tg->print) { -printf ("#" ); - tg->NULL , t,0 ); + rc = tg->xlate(xl, ¶ms); }xfree (t);break ; } +if (rc ==1 ) +nft_print (octx,"%s" ,xt_xlate_get (xl));xt_xlate_free (xl);xfree (entry); -#else -static const char *typename[NFT_XT_MAX ] = { - [NFT_XT_MATCH ] ="match" , - [NFT_XT_TARGET ] ="target" , - [NFT_XT_WATCHER ] ="watcher" , - }; - -nft_print (octx,"xt %s %s" , typename[stmt->xt.type], stmt->xt.name);#endif +if (!rc) +nft_print (octx,"xt %s %s" , + typename[stmt->xt.type], stmt->xt.name); }void xt_stmt_destroy (struct stmt *stmt)
Signature · 1 line
2.38.0
Phil Sutter
reviewerQuoted 6 lines · Phil Sutter
Alternative approach to my previous dump and restore support of xt compat expressions:
If translation is not available or not successful, fall back to a format which allows to be parsed easily.
Quoted 8 lines
When parsing, reject these expressions explicitly with a meaningful error message.
Phil Sutter (4):
xt: Delay libxtables access until translation
xt: Purify enumnft_xt_type
xt: Rewrite unsupported compat expression dumping
xt: Fall back to generic printing from translation
Series applied.