s3 net: i18n support for net group and net groupmap

diff --git a/source3/po/genmsg b/source3/po/genmsg
index afea8953a602db6ec4b72d2d59ede33e6ba266a3..d7473d533631986731e2c782fa6847502bc6f61f 100755 (executable)
--- a/source3/po/genmsg
+++ b/source3/po/genmsg
@@ -18,6 +18,7 @@ NET_FILES="../utils/net.c ../utils/net_ads.c ../utils/net_ads_gpo.c"
 NET_FILES="${NET_FILES} ../utils/net_afs.c ../utils/net_cache.c"
 NET_FILES="${NET_FILES} ../utils/net_conf.c ../utils/net_dom.c"
 NET_FILES="${NET_FILES} ../utils/net_eventlog.c ../utils/net_file.c"
+NET_FILES="${NET_FILES} ../utils/net_group.c ../utils/net_groupmap.c"
 FILES="../web/swat.c ../web/statuspage.c ../param/loadparm.c ${NET_FILES}"
 LANGS='en ja tr pl fr de it ru'
 

diff --git a/source3/utils/net_group.c b/source3/utils/net_group.c
index 2d5dba8b5882a4638b23fb22b489c53c794cfa23..1ead7861a017a7510c25357d03bb4fc3fb473954 100644 (file)
--- a/source3/utils/net_group.c
+++ b/source3/utils/net_group.c
@@ -24,23 +24,29 @@
 
 int net_group_usage(struct net_context *c, int argc, const char **argv)
 {
-       d_printf("net [<method>] group [misc. options] [targets]"\
-                "\n\tList user groups\n\n");
-       d_printf("net rpc group LIST [global|local|builtin]* [misc. options]"\
-                "\n\tList specific user groups\n\n");
-       d_printf("net [<method>] group DELETE <name> "\
-                "[misc. options] [targets]"\
-                "\n\tDelete specified group\n");
-       d_printf("\nnet [<method>] group ADD <name> [-C comment] [-c container]"\
-                " [misc. options] [targets]\n\tCreate specified group\n");
-       d_printf("\nnet rpc group MEMBERS <name>\n\tList Group Members\n\n");
-       d_printf("\nnet rpc group ADDMEM <group> <member>\n\tAdd Group Members\n\n");
-       d_printf("\nnet rpc group DELMEM <group> <member>\n\tDelete Group Members\n\n");
+       d_printf(_("net [<method>] group [misc. options] [targets]"
+                  "\n\tList user groups\n\n"));
+       d_printf(_("net rpc group LIST [global|local|builtin]* [misc. options]"
+                  "\n\tList specific user groups\n\n"));
+       d_printf(_("net [<method>] group DELETE <name> "
+                  "[misc. options] [targets]"
+                  "\n\tDelete specified group\n"));
+       d_printf(_("\nnet [<method>] group ADD <name> [-C comment] "
+                  "[-c container] [misc. options] [targets]\n"
+                  "\tCreate specified group\n"));
+       d_printf(_("\nnet rpc group MEMBERS <name>\n\tList Group Members\n\n"));
+       d_printf(_("\nnet rpc group ADDMEM <group> <member>\n"
+                  "\tAdd Group Members\n\n"));
+       d_printf(_("\nnet rpc group DELMEM <group> <member>\n"
+                  "\tDelete Group Members\n\n"));
        net_common_methods_usage(c, argc, argv);
        net_common_flags_usage(c, argc, argv);
-       d_printf("\t-C or --comment=<comment>\tdescriptive comment (for add only)\n");
-       d_printf("\t-c or --container=<container>\tLDAP container, defaults to cn=Users (for add in ADS only)\n");
-       d_printf("\t-L or --localgroup\t\tWhen adding groups, create a local group (alias)\n");
+       d_printf(_("\t-C or --comment=<comment>\tdescriptive comment "
+                  "(for add only)\n"));
+       d_printf(_("\t-c or --container=<container>\tLDAP container, "
+                  "defaults to cn=Users (for add in ADS only)\n"));
+       d_printf(_("\t-L or --localgroup\t\tWhen adding groups, "
+                  "create a local group (alias)\n"));
        return -1;
 }
 

diff --git a/source3/utils/net_groupmap.c b/source3/utils/net_groupmap.c
index 16c61876649b703165359574402de2167f901d83..74175fef51315d79d747817591dd0758f6dc3348 100644 (file)
--- a/source3/utils/net_groupmap.c
+++ b/source3/utils/net_groupmap.c
@@ -35,14 +35,16 @@ static bool get_sid_from_input(DOM_SID *sid, char *input)
        if (StrnCaseCmp( input, "S-", 2)) {
                /* Perhaps its the NT group name? */
                if (!pdb_getgrnam(&map, input)) {
-                       printf("NT Group %s doesn't exist in mapping DB\n", input);
+                       printf(_("NT Group %s doesn't exist in mapping DB\n"),
+                              input);
                        return false;
                } else {
                        *sid = map.sid;
                }
        } else {
                if (!string_to_sid(sid, input)) {
-                       printf("converting sid %s from a string failed!\n", input);
+                       printf(_("converting sid %s from a string failed!\n"),
+                              input);
                        return false;
                }
        }
@@ -60,12 +62,12 @@ static void print_map_entry ( GROUP_MAP map, bool long_list )
                         sid_string_tos(&map.sid), gidtoname(map.gid));
        else {
                d_printf("%s\n", map.nt_name);
-               d_printf("\tSID       : %s\n", sid_string_tos(&map.sid));
-               d_printf("\tUnix gid  : %u\n", (unsigned int)map.gid);
-               d_printf("\tUnix group: %s\n", gidtoname(map.gid));
-               d_printf("\tGroup type: %s\n",
+               d_printf(_("\tSID       : %s\n"), sid_string_tos(&map.sid));
+               d_printf(_("\tUnix gid  : %u\n"), (unsigned int)map.gid);
+               d_printf(_("\tUnix group: %s\n"), gidtoname(map.gid));
+               d_printf(_("\tGroup type: %s\n"),
                         sid_type_lookup(map.sid_name_use));
-               d_printf("\tComment   : %s\n", map.comment);
+               d_printf(_("\tComment   : %s\n"), map.comment);
        }
 
 }
@@ -79,14 +81,14 @@ static int net_groupmap_list(struct net_context *c, int argc, const char **argv)
        size_t i;
        fstring ntgroup = "";
        fstring sid_string = "";
-       const char list_usage_str[] = "net groupmap list [verbose] "
-                                     "[ntgroup=NT group] [sid=SID]\n"
-                                     "    verbose\tPrint verbose list\n"
-                                     "    ntgroup\tNT group to list\n"
-                                     "    sid\tSID of group to list";
+       const char list_usage_str[] = N_("net groupmap list [verbose] "
+                                        "[ntgroup=NT group] [sid=SID]\n"
+                                        "    verbose\tPrint verbose list\n"
+                                        "    ntgroup\tNT group to list\n"
+                                        "    sid\tSID of group to list");
 
        if (c->display_usage) {
-               d_printf("Usage:\n%s\n", list_usage_str);
+               d_printf(_("Usage:\n%s\n"), list_usage_str);
                return 0;
        }
 
@@ -101,19 +103,19 @@ static int net_groupmap_list(struct net_context *c, int argc, const char **argv)
                else if ( !StrnCaseCmp(argv[i], "ntgroup", strlen("ntgroup")) ) {
                        fstrcpy( ntgroup, get_string_param( argv[i] ) );
                        if ( !ntgroup[0] ) {
-                               d_fprintf(stderr, "must supply a name\n");
+                               d_fprintf(stderr, _("must supply a name\n"));
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "sid", strlen("sid")) ) {
                        fstrcpy( sid_string, get_string_param( argv[i] ) );
                        if ( !sid_string[0] ) {
-                               d_fprintf(stderr, "must supply a SID\n");
+                               d_fprintf(stderr, _("must supply a SID\n"));
                                return -1;
                        }
                }
                else {
-                       d_fprintf(stderr, "Bad option: %s\n", argv[i]);
+                       d_fprintf(stderr, _("Bad option: %s\n"), argv[i]);
                        d_printf("Usage:\n%s\n", list_usage_str);
                        return -1;
                }
@@ -133,7 +135,9 @@ static int net_groupmap_list(struct net_context *c, int argc, const char **argv)
 
                /* Get the current mapping from the database */
                if(!pdb_getgrsid(&map, sid)) {
-                       d_fprintf(stderr, "Failure to local group SID in the database\n");
+                       d_fprintf(stderr,
+                                 _("Failure to local group SID in the "
+                                   "database\n"));
                        return -1;
                }
 
@@ -174,10 +178,12 @@ static int net_groupmap_add(struct net_context *c, int argc, const char **argv)
        GROUP_MAP map;
 
        const char *name_type;
-       const char add_usage_str[] = "net groupmap add {rid=<int>|sid=<string>}"
-                                    " unixgroup=<string> "
-                                    "[type=<domain|local|builtin>] "
-                                    "[ntgroup=<string>] [comment=<string>]";
+       const char add_usage_str[] = N_("net groupmap add "
+                                       "{rid=<int>|sid=<string>}"
+                                       " unixgroup=<string> "
+                                       "[type=<domain|local|builtin>] "
+                                       "[ntgroup=<string>] "
+                                       "[comment=<string>]");
 
        ZERO_STRUCT(map);
 
@@ -186,7 +192,7 @@ static int net_groupmap_add(struct net_context *c, int argc, const char **argv)
        name_type = "domain group";
 
        if (c->display_usage) {
-               d_printf("Usage\n%s\n", add_usage_str);
+               d_printf(_("Usage\n%s\n"), add_usage_str);
                return 0;
        }
 
@@ -195,35 +201,38 @@ static int net_groupmap_add(struct net_context *c, int argc, const char **argv)
                if ( !StrnCaseCmp(argv[i], "rid", strlen("rid")) ) {
                        rid = get_int_param(argv[i]);
                        if ( rid < DOMAIN_GROUP_RID_ADMINS ) {
-                               d_fprintf(stderr, "RID must be greater than %d\n", (uint32)DOMAIN_GROUP_RID_ADMINS-1);
+                               d_fprintf(stderr,
+                                         _("RID must be greater than %d\n"),
+                                         (uint32)DOMAIN_GROUP_RID_ADMINS-1);
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "unixgroup", strlen("unixgroup")) ) {
                        fstrcpy( unixgrp, get_string_param( argv[i] ) );
                        if ( !unixgrp[0] ) {
-                               d_fprintf(stderr, "must supply a name\n");
+                               d_fprintf(stderr,_( "must supply a name\n"));
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "ntgroup", strlen("ntgroup")) ) {
                        fstrcpy( ntgroup, get_string_param( argv[i] ) );
                        if ( !ntgroup[0] ) {
-                               d_fprintf(stderr, "must supply a name\n");
+                               d_fprintf(stderr, _("must supply a name\n"));
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "sid", strlen("sid")) ) {
                        fstrcpy( string_sid, get_string_param( argv[i] ) );
                        if ( !string_sid[0] ) {
-                               d_fprintf(stderr, "must supply a SID\n");
+                               d_fprintf(stderr, _("must supply a SID\n"));
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "comment", strlen("comment")) ) {
                        fstrcpy( ntcomment, get_string_param( argv[i] ) );
                        if ( !ntcomment[0] ) {
-                               d_fprintf(stderr, "must supply a comment string\n");
+                               d_fprintf(stderr,
+                                         _("must supply a comment string\n"));
                                return -1;
                        }
                }
@@ -246,44 +255,46 @@ static int net_groupmap_add(struct net_context *c, int argc, const char **argv)
                                        name_type = "alias (local) group";
                                        break;
                                default:
-                                       d_fprintf(stderr, "unknown group type %s\n", type);
+                                       d_fprintf(stderr,
+                                                 _("unknown group type %s\n"),
+                                                 type);
                                        return -1;
                        }
                }
                else {
-                       d_fprintf(stderr, "Bad option: %s\n", argv[i]);
+                       d_fprintf(stderr, _("Bad option: %s\n"), argv[i]);
                        return -1;
                }
        }
 
        if ( !unixgrp[0] ) {
-               d_printf("Usage:\n%s\n", add_usage_str);
+               d_printf(_("Usage:\n%s\n"), add_usage_str);
                return -1;
        }
 
        if ( (gid = nametogid(unixgrp)) == (gid_t)-1 ) {
-               d_fprintf(stderr, "Can't lookup UNIX group %s\n", unixgrp);
+               d_fprintf(stderr, _("Can't lookup UNIX group %s\n"), unixgrp);
                return -1;
        }
 
        {
                if (pdb_getgrgid(&map, gid)) {
-                       d_printf("Unix group %s already mapped to SID %s\n",
+                       d_printf(_("Unix group %s already mapped to SID %s\n"),
                                 unixgrp, sid_string_tos(&map.sid));
                        return -1;
                }
        }
 
        if ( (rid == 0) && (string_sid[0] == '\0') ) {
-               d_printf("No rid or sid specified, choosing a RID\n");
+               d_printf(_("No rid or sid specified, choosing a RID\n"));
                if (pdb_capabilities() & PDB_CAP_STORE_RIDS) {
                        if (!pdb_new_rid(&rid)) {
-                               d_printf("Could not get new RID\n");
+                               d_printf(_("Could not get new RID\n"));
                        }
                } else {
                        rid = algorithmic_pdb_gid_to_group_rid(gid);
                }
-               d_printf("Got RID %d\n", rid);
+               d_printf(_("Got RID %d\n"), rid);
        }
 
        /* append the rid to our own domain/machine SID if we don't have a full SID */
@@ -314,11 +325,11 @@ static int net_groupmap_add(struct net_context *c, int argc, const char **argv)
                fstrcpy( ntgroup, unixgrp );
 
        if (!NT_STATUS_IS_OK(add_initial_entry(gid, string_sid, sid_type, ntgroup, ntcomment))) {
-               d_fprintf(stderr, "adding entry for group %s failed!\n", ntgroup);
+               d_fprintf(stderr, _("adding entry for group %s failed!\n"), ntgroup);
                return -1;
        }
 
-       d_printf("Successfully added group %s to the mapping db as a %s\n",
+       d_printf(_("Successfully added group %s to the mapping db as a %s\n"),
                 ntgroup, name_type);
        return 0;
 }
@@ -335,14 +346,14 @@ static int net_groupmap_modify(struct net_context *c, int argc, const char **arg
        enum lsa_SidType sid_type = SID_NAME_UNKNOWN;
        int i;
        gid_t gid;
-       const char modify_usage_str[] = "net groupmap modify "
-                                       "{ntgroup=<string>|sid=<SID>} "
-                                       "[comment=<string>] "
-                                       "[unixgroup=<string>] "
-                                       "[type=<domain|local>]";
+       const char modify_usage_str[] = N_("net groupmap modify "
+                                          "{ntgroup=<string>|sid=<SID>} "
+                                          "[comment=<string>] "
+                                          "[unixgroup=<string>] "
+                                          "[type=<domain|local>]");
 
        if (c->display_usage) {
-               d_printf("Usage:\n%s\n", modify_usage_str);
+               d_printf(_("Usage:\n%s\n"), modify_usage_str);
                return 0;
        }
 
@@ -351,28 +362,30 @@ static int net_groupmap_modify(struct net_context *c, int argc, const char **arg
                if ( !StrnCaseCmp(argv[i], "ntgroup", strlen("ntgroup")) ) {
                        fstrcpy( ntgroup, get_string_param( argv[i] ) );
                        if ( !ntgroup[0] ) {
-                               d_fprintf(stderr, "must supply a name\n");
+                               d_fprintf(stderr, _("must supply a name\n"));
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "sid", strlen("sid")) ) {
                        fstrcpy( sid_string, get_string_param( argv[i] ) );
                        if ( !sid_string[0] ) {
-                               d_fprintf(stderr, "must supply a name\n");
+                               d_fprintf(stderr, _("must supply a name\n"));
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "comment", strlen("comment")) ) {
                        fstrcpy( ntcomment, get_string_param( argv[i] ) );
                        if ( !ntcomment[0] ) {
-                               d_fprintf(stderr, "must supply a comment string\n");
+                               d_fprintf(stderr,
+                                         _("must supply a comment string\n"));
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "unixgroup", strlen("unixgroup")) ) {
                        fstrcpy( unixgrp, get_string_param( argv[i] ) );
                        if ( !unixgrp[0] ) {
-                               d_fprintf(stderr, "must supply a group name\n");
+                               d_fprintf(stderr,
+                                         _("must supply a group name\n"));
                                return -1;
                        }
                }
@@ -390,13 +403,13 @@ static int net_groupmap_modify(struct net_context *c, int argc, const char **arg
                        }
                }
                else {
-                       d_fprintf(stderr, "Bad option: %s\n", argv[i]);
+                       d_fprintf(stderr, _("Bad option: %s\n"), argv[i]);
                        return -1;
                }
        }
 
        if ( !ntgroup[0] && !sid_string[0] ) {
-               d_printf("Usage:\n%s\n", modify_usage_str);
+               d_printf(_("Usage:\n%s\n"), modify_usage_str);
                return -1;
        }
 
@@ -417,7 +430,8 @@ static int net_groupmap_modify(struct net_context *c, int argc, const char **arg
 
        /* Get the current mapping from the database */
        if(!pdb_getgrsid(&map, sid)) {
-               d_fprintf(stderr, "Failure to local group SID in the database\n");
+               d_fprintf(stderr,
+                        _("Failed to find local group SID in the database\n"));
                return -1;
        }
 
@@ -426,12 +440,14 @@ static int net_groupmap_modify(struct net_context *c, int argc, const char **arg
         * We disallow changing Builtin groups !!! (SID problem)
         */
        if (sid_type == SID_NAME_UNKNOWN) {
-               d_fprintf(stderr, "Can't map to an unknown group type.\n");
+               d_fprintf(stderr, _("Can't map to an unknown group type.\n"));
                return -1;
         }
 
        if (map.sid_name_use == SID_NAME_WKN_GRP) {
-               d_fprintf(stderr, "You can only change between domain and local groups.\n");
+               d_fprintf(stderr,
+                         _("You can only change between domain and local "
+                           "groups.\n"));
                return -1;
        }
 
@@ -447,7 +463,8 @@ static int net_groupmap_modify(struct net_context *c, int argc, const char **arg
        if ( unixgrp[0] ) {
                gid = nametogid( unixgrp );
                if ( gid == -1 ) {
-                       d_fprintf(stderr, "Unable to lookup UNIX group %s.  Make sure the group exists.\n",
+                       d_fprintf(stderr, _("Unable to lookup UNIX group %s.  "
+                                           "Make sure the group exists.\n"),
                                unixgrp);
                        return -1;
                }
@@ -456,11 +473,11 @@ static int net_groupmap_modify(struct net_context *c, int argc, const char **arg
        }
 
        if ( !NT_STATUS_IS_OK(pdb_update_group_mapping_entry(&map)) ) {
-               d_fprintf(stderr, "Could not update group database\n");
+               d_fprintf(stderr, _("Could not update group database\n"));
                return -1;
        }
 
-       d_printf("Updated mapping entry for %s\n", map.nt_name);
+       d_printf(_("Updated mapping entry for %s\n"), map.nt_name);
 
        return 0;
 }
@@ -471,11 +488,11 @@ static int net_groupmap_delete(struct net_context *c, int argc, const char **arg
        fstring ntgroup = "";
        fstring sid_string = "";
        int i;
-       const char delete_usage_str[] = "net groupmap delete "
-                                       "{ntgroup=<string>|sid=<SID>}";
+       const char delete_usage_str[] = N_("net groupmap delete "
+                                          "{ntgroup=<string>|sid=<SID>}");
 
        if (c->display_usage) {
-               d_printf("Usage:\n%s\n", delete_usage_str);
+               d_printf(_("Usage:\n%s\n"), delete_usage_str);
                return 0;
        }
 
@@ -484,25 +501,25 @@ static int net_groupmap_delete(struct net_context *c, int argc, const char **arg
                if ( !StrnCaseCmp(argv[i], "ntgroup", strlen("ntgroup")) ) {
                        fstrcpy( ntgroup, get_string_param( argv[i] ) );
                        if ( !ntgroup[0] ) {
-                               d_fprintf(stderr, "must supply a name\n");
+                               d_fprintf(stderr, _("must supply a name\n"));
                                return -1;
                        }
                }
                else if ( !StrnCaseCmp(argv[i], "sid", strlen("sid")) ) {
                        fstrcpy( sid_string, get_string_param( argv[i] ) );
                        if ( !sid_string[0] ) {
-                               d_fprintf(stderr, "must supply a SID\n");
+                               d_fprintf(stderr, _("must supply a SID\n"));
                                return -1;
                        }
                }
                else {
-                       d_fprintf(stderr, "Bad option: %s\n", argv[i]);
+                       d_fprintf(stderr, _("Bad option: %s\n"), argv[i]);
                        return -1;
                }
        }
 
        if ( !ntgroup[0] && !sid_string[0]) {
-               d_printf("Usage:\n%s\n", delete_usage_str);
+               d_printf(_("Usage:\n%s\n"), delete_usage_str);
                return -1;
        }
 
@@ -512,16 +529,19 @@ static int net_groupmap_delete(struct net_context *c, int argc, const char **arg
                fstrcpy( ntgroup, sid_string );
 
        if ( !get_sid_from_input(&sid, ntgroup) ) {
-               d_fprintf(stderr, "Unable to resolve group %s to a SID\n", ntgroup);
+               d_fprintf(stderr, _("Unable to resolve group %s to a SID\n"),
+                         ntgroup);
                return -1;
        }
 
        if ( !NT_STATUS_IS_OK(pdb_delete_group_mapping_entry(sid)) ) {
-               d_fprintf(stderr, "Failed to removing group %s from the mapping db!\n", ntgroup);
+               d_fprintf(stderr,
+                         _("Failed to remove group %s from the mapping db!\n"),
+                         ntgroup);
                return -1;
        }
 
-       d_printf("Sucessfully removed %s from the mapping db\n", ntgroup);
+       d_printf(_("Sucessfully removed %s from the mapping db\n"), ntgroup);
 
        return 0;
 }
@@ -534,13 +554,13 @@ static int net_groupmap_set(struct net_context *c, int argc, const char **argv)
        bool have_map = false;
 
        if ((argc < 1) || (argc > 2) || c->display_usage) {
-               d_printf("Usage: net groupmap set \"NT Group\" "
-                        "[\"unix group\"] [-C \"comment\"] [-L] [-D]\n");
+               d_printf(_("Usage: net groupmap set \"NT Group\" "
+                        "[\"unix group\"] [-C \"comment\"] [-L] [-D]\n"));
                return -1;
        }
 
        if ( c->opt_localgroup && c->opt_domaingroup ) {
-               d_printf("Can only specify -L or -D, not both\n");
+               d_printf(_("Can only specify -L or -D, not both\n"));
                return -1;
        }
 
@@ -550,7 +570,8 @@ static int net_groupmap_set(struct net_context *c, int argc, const char **argv)
                grp = getgrnam(argv[1]);
 
                if (grp == NULL) {
-                       d_fprintf(stderr, "Could not find unix group %s\n", argv[1]);
+                       d_fprintf(stderr, _("Could not find unix group %s\n"),
+                                 argv[1]);
                        return -1;
                }
        }
@@ -569,8 +590,9 @@ static int net_groupmap_set(struct net_context *c, int argc, const char **argv)
                /* Ok, add it */
 
                if (grp == NULL) {
-                       d_fprintf(stderr, "Could not find group mapping for %s\n",
-                                ntgroup);
+                       d_fprintf(stderr,
+                                 _("Could not find group mapping for %s\n"),
+                                 ntgroup);
                        return -1;
                }
 
@@ -579,7 +601,8 @@ static int net_groupmap_set(struct net_context *c, int argc, const char **argv)
                if (c->opt_rid == 0) {
                        if ( pdb_capabilities() & PDB_CAP_STORE_RIDS ) {
                                if ( !pdb_new_rid((uint32*)&c->opt_rid) ) {
-                                       d_fprintf( stderr, "Could not allocate new RID\n");
+                                       d_fprintf( stderr,
+                                           _("Could not allocate new RID\n"));
                                        return -1;
                                }
                        } else {
@@ -595,8 +618,9 @@ static int net_groupmap_set(struct net_context *c, int argc, const char **argv)
                fstrcpy(map.comment, "");
 
                if (!NT_STATUS_IS_OK(pdb_add_group_mapping_entry(&map))) {
-                       d_fprintf(stderr, "Could not add mapping entry for %s\n",
-                                ntgroup);
+                       d_fprintf(stderr,
+                                 _("Could not add mapping entry for %s\n"),
+                                 ntgroup);
                        return -1;
                }
        }
@@ -605,8 +629,10 @@ static int net_groupmap_set(struct net_context *c, int argc, const char **argv)
 
        if ( c->opt_localgroup || c->opt_domaingroup ) {
                if (map.sid_name_use == SID_NAME_WKN_GRP) {
-                       d_fprintf(stderr, "Can't change type of the BUILTIN group %s\n",
-                                map.nt_name);
+                       d_fprintf(stderr,
+                                 _("Can't change type of the BUILTIN "
+                                   "group %s\n"),
+                                 map.nt_name);
                        return -1;
                }
        }
@@ -631,7 +657,8 @@ static int net_groupmap_set(struct net_context *c, int argc, const char **argv)
                map.gid = grp->gr_gid;
 
        if (!NT_STATUS_IS_OK(pdb_update_group_mapping_entry(&map))) {
-               d_fprintf(stderr, "Could not update group mapping for %s\n", ntgroup);
+               d_fprintf(stderr, _("Could not update group mapping for %s\n"),
+                         ntgroup);
                return -1;
        }
 
@@ -644,25 +671,25 @@ static int net_groupmap_cleanup(struct net_context *c, int argc, const char **ar
        size_t i, entries;
 
        if (c->display_usage) {
-               d_printf("Usage:\n"
-                        "net groupmap cleanup\n"
-                        "    Delete all group mappings\n");
+               d_printf(_("Usage:\n"
+                          "net groupmap cleanup\n"
+                          "    Delete all group mappings\n"));
                return 0;
        }
 
        if (!pdb_enum_group_mapping(NULL, SID_NAME_UNKNOWN, &map, &entries,
                                    ENUM_ALL_MAPPED)) {
-               d_fprintf(stderr, "Could not list group mappings\n");
+               d_fprintf(stderr, _("Could not list group mappings\n"));
                return -1;
        }
 
        for (i=0; i<entries; i++) {
 
                if (map[i].gid == -1)
-                       printf("Group %s is not mapped\n", map[i].nt_name);
+                       printf(_("Group %s is not mapped\n"), map[i].nt_name);
 
                if (!sid_check_is_in_our_domain(&map[i].sid)) {
-                       printf("Deleting mapping for NT Group %s, sid %s\n",
+                       printf(_("Deleting mapping for NT Group %s, sid %s\n"),
                               map[i].nt_name,
                               sid_string_tos(&map[i].sid));
                        pdb_delete_group_mapping_entry(map[i].sid);
@@ -682,12 +709,12 @@ static int net_groupmap_addmem(struct net_context *c, int argc, const char **arg
             c->display_usage ||
             !string_to_sid(&alias, argv[0]) ||
             !string_to_sid(&member, argv[1]) ) {
-               d_printf("Usage: net groupmap addmem alias-sid member-sid\n");
+               d_printf(_("Usage: net groupmap addmem alias-sid member-sid\n"));
                return -1;
        }
 
        if (!NT_STATUS_IS_OK(pdb_add_aliasmem(&alias, &member))) {
-               d_fprintf(stderr, "Could not add sid %s to alias %s\n",
+               d_fprintf(stderr, _("Could not add sid %s to alias %s\n"),
                         argv[1], argv[0]);
                return -1;
        }
@@ -703,12 +730,12 @@ static int net_groupmap_delmem(struct net_context *c, int argc, const char **arg
             c->display_usage ||
             !string_to_sid(&alias, argv[0]) ||
             !string_to_sid(&member, argv[1]) ) {
-               d_printf("Usage: net groupmap delmem alias-sid member-sid\n");
+               d_printf(_("Usage: net groupmap delmem alias-sid member-sid\n"));
                return -1;
        }
 
        if (!NT_STATUS_IS_OK(pdb_del_aliasmem(&alias, &member))) {
-               d_fprintf(stderr, "Could not delete sid %s from alias %s\n",
+               d_fprintf(stderr, _("Could not delete sid %s from alias %s\n"),
                         argv[1], argv[0]);
                return -1;
        }
@@ -725,7 +752,7 @@ static int net_groupmap_listmem(struct net_context *c, int argc, const char **ar
        if ( (argc != 1) ||
             c->display_usage ||
             !string_to_sid(&alias, argv[0]) ) {
-               d_printf("Usage: net groupmap listmem alias-sid\n");
+               d_printf(_("Usage: net groupmap listmem alias-sid\n"));
                return -1;
        }
 
@@ -734,7 +761,8 @@ static int net_groupmap_listmem(struct net_context *c, int argc, const char **ar
 
        if (!NT_STATUS_IS_OK(pdb_enum_aliasmem(&alias, talloc_tos(),
                                               &members, &num))) {
-               d_fprintf(stderr, "Could not list members for sid %s\n", argv[0]);
+               d_fprintf(stderr, _("Could not list members for sid %s\n"),
+                         argv[0]);
                return -1;
        }
 
@@ -760,7 +788,7 @@ static bool print_alias_memberships(TALLOC_CTX *mem_ctx,
        if (!NT_STATUS_IS_OK(pdb_enum_alias_memberships(
                                     mem_ctx, domain_sid, member, 1,
                                     &alias_rids, &num_alias_rids))) {
-               d_fprintf(stderr, "Could not list memberships for sid %s\n",
+               d_fprintf(stderr, _("Could not list memberships for sid %s\n"),
                         sid_string_tos(member));
                return false;
        }
@@ -783,20 +811,20 @@ static int net_groupmap_memberships(struct net_context *c, int argc, const char
        if ( (argc != 1) ||
             c->display_usage ||
             !string_to_sid(&member, argv[0]) ) {
-               d_printf("Usage: net groupmap memberof sid\n");
+               d_printf(_("Usage: net groupmap memberof sid\n"));
                return -1;
        }
 
        mem_ctx = talloc_init("net_groupmap_memberships");
        if (mem_ctx == NULL) {
-               d_fprintf(stderr, "talloc_init failed\n");
+               d_fprintf(stderr, _("talloc_init failed\n"));
                return -1;
        }
 
        domain_sid = get_global_sam_sid();
        builtin_sid = string_sid_talloc(mem_ctx, "S-1-5-32");
        if ((domain_sid == NULL) || (builtin_sid == NULL)) {
-               d_fprintf(stderr, "Could not get domain sid\n");
+               d_fprintf(stderr, _("Could not get domain sid\n"));
                return -1;
        }
 
@@ -819,88 +847,89 @@ int net_groupmap(struct net_context *c, int argc, const char **argv)
                        "add",
                        net_groupmap_add,
                        NET_TRANSPORT_LOCAL,
-                       "Create a new group mapping",
-                       "net groupmap add\n"
-                       "    Create a new group mapping"
+                       N_("Create a new group mapping"),
+                       N_("net groupmap add\n"
+                          "    Create a new group mapping")
                },
                {
                        "modify",
                        net_groupmap_modify,
                        NET_TRANSPORT_LOCAL,
-                       "Update a group mapping",
-                       "net groupmap modify\n"
-                       "    Modify an existing group mapping"
+                       N_("Update a group mapping"),
+                       N_("net groupmap modify\n"
+                          "    Modify an existing group mapping")
                },
                {
                        "delete",
                        net_groupmap_delete,
                        NET_TRANSPORT_LOCAL,
-                       "Remove a group mapping",
-                       "net groupmap delete\n"
-                       "    Remove a group mapping"
+                       N_("Remove a group mapping"),
+                       N_("net groupmap delete\n"
+                          "    Remove a group mapping")
                },
                {
                        "set",
                        net_groupmap_set,
                        NET_TRANSPORT_LOCAL,
-                       "Set group mapping",
-                       "net groupmap set\n"
-                       "    Set a group mapping"
+                       N_("Set group mapping"),
+                       N_("net groupmap set\n"
+                          "    Set a group mapping")
                },
                {
                        "cleanup",
                        net_groupmap_cleanup,
                        NET_TRANSPORT_LOCAL,
-                       "Remove foreign group mapping entries",
-                       "net groupmap cleanup\n"
-                       "    Remove foreign group mapping entries"
+                       N_("Remove foreign group mapping entries"),
+                       N_("net groupmap cleanup\n"
+                          "    Remove foreign group mapping entries")
                },
                {
                        "addmem",
                        net_groupmap_addmem,
                        NET_TRANSPORT_LOCAL,
-                       "Add a foreign alias member",
-                       "net groupmap addmem\n"
-                       "    Add a foreign alias member"
+                       N_("Add a foreign alias member"),
+                       N_("net groupmap addmem\n"
+                          "    Add a foreign alias member")
                },
                {
                        "delmem",
                        net_groupmap_delmem,
                        NET_TRANSPORT_LOCAL,
-                       "Delete foreign alias member",
-                       "net groupmap delmem\n"
-                       "    Delete foreign alias member"
+                       N_("Delete foreign alias member"),
+                       N_("net groupmap delmem\n"
+                          "    Delete foreign alias member")
                },
                {
                        "listmem",
                        net_groupmap_listmem,
                        NET_TRANSPORT_LOCAL,
-                       "List foreign group members",
-                       "net groupmap listmem\n"
-                       "    List foreign alias members"
+                       N_("List foreign group members"),
+                       N_("net groupmap listmem\n"
+                          "    List foreign alias members")
                },
                {
                        "memberships",
                        net_groupmap_memberships,
                        NET_TRANSPORT_LOCAL,
-                       "List foreign group memberships",
-                       "net groupmap memberships\n"
-                       "    List foreign group memberships"
+                       N_("List foreign group memberships"),
+                       N_("net groupmap memberships\n"
+                          "    List foreign group memberships")
                },
                {
                        "list",
                        net_groupmap_list,
                        NET_TRANSPORT_LOCAL,
-                       "List current group map",
-                       "net groupmap list\n"
-                       "    List current group map"
+                       N_("List current group map"),
+                       N_("net groupmap list\n"
+                          "    List current group map")
                },
                {NULL, NULL, 0, NULL, NULL}
        };
 
        /* we shouldn't have silly checks like this */
        if (getuid() != 0) {
-               d_fprintf(stderr, "You must be root to edit group mappings.\n");
+               d_fprintf(stderr,
+                         _("You must be root to edit group mappings.\n"));
                return -1;
        }