s3 net: i18n support for net idmap

diff --git a/source3/po/genmsg b/source3/po/genmsg
index 64df29e1ecb49b7955f4042dfe24c76e5f96c003..87cd47dd37636bb2e48cbf12f22b7373e4b9b072 100755 (executable)
--- a/source3/po/genmsg
+++ b/source3/po/genmsg
@@ -28,7 +28,8 @@ add_basedir_to_filelist() {
 
 NET_FILES=`add_basedir_to_filelist ../utils net.c net_ads.c net_ads_gpo.c \
           net_afs.c net_cache.c net_conf.c net_dom.c net_eventlog.c \
-          net_file.c net_group.c net_groupmap.c net_help.c net_help_common.c`
+          net_file.c net_group.c net_groupmap.c net_help.c net_help_common.c \
+          net_idmap.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_idmap.c b/source3/utils/net_idmap.c
index bd363922f659e90c62f8909d54fa410148125ece..5a380da02f12e901fa5b95489a1269a68d35f5bc 100644 (file)
--- a/source3/utils/net_idmap.c
+++ b/source3/utils/net_idmap.c
@@ -22,7 +22,7 @@
 
 #define ALLOC_CHECK(mem) do { \
        if (!mem) { \
-               d_fprintf(stderr, "Out of memory!\n"); \
+               d_fprintf(stderr, _("Out of memory!\n")); \
                talloc_free(ctx); \
                return -1; \
        } } while(0)
@@ -36,12 +36,12 @@ static int net_idmap_dump_one_entry(TDB_CONTEXT *tdb,
                                    void *unused)
 {
        if (strcmp((char *)key.dptr, "USER HWM") == 0) {
-               printf("USER HWM %d\n", IVAL(data.dptr,0));
+               printf(_("USER HWM %d\n"), IVAL(data.dptr,0));
                return 0;
        }
 
        if (strcmp((char *)key.dptr, "GROUP HWM") == 0) {
-               printf("GROUP HWM %d\n", IVAL(data.dptr,0));
+               printf(_("GROUP HWM %d\n"), IVAL(data.dptr,0));
                return 0;
        }
 
@@ -60,17 +60,17 @@ static int net_idmap_dump(struct net_context *c, int argc, const char **argv)
        TDB_CONTEXT *idmap_tdb;
 
        if ( argc != 1  || c->display_usage) {
-               d_printf("Usage:\n"
-                        "net idmap dump <inputfile>\n"
-                        "  Dump current ID mapping.\n"
-                        "    inputfile\tTDB file to read mappings from.\n");
+               d_printf(_("Usage:\n"
+                          "net idmap dump <inputfile>\n"
+                          "  Dump current ID mapping.\n"
+                          "    inputfile\tTDB file to read mappings from.\n"));
                return c->display_usage?0:-1;
        }
 
        idmap_tdb = tdb_open_log(argv[0], 0, TDB_DEFAULT, O_RDONLY, 0);
 
        if (idmap_tdb == NULL) {
-               d_fprintf(stderr, "Could not open idmap: %s\n", argv[0]);
+               d_fprintf(stderr, _("Could not open idmap: %s\n"), argv[0]);
                return -1;
        }
 
@@ -91,16 +91,17 @@ static int net_idmap_restore(struct net_context *c, int argc, const char **argv)
        FILE *input;
 
        if (c->display_usage) {
-               d_printf("Usage:\n"
-                        "net idmap restore [inputfile]\n"
-                        "  Restore ID mappings from file\n"
-                        "    inputfile\tFile to load ID mappings from. If not "
-                        "given, load data from stdin.\n");
+               d_printf(_("Usage:\n"
+                          "net idmap restore [inputfile]\n"
+                          "  Restore ID mappings from file\n"
+                          "    inputfile\tFile to load ID mappings from. If "
+                          "not given, load data from stdin.\n"));
                return 0;
        }
 
        if (! winbind_ping()) {
-               d_fprintf(stderr, "To use net idmap Winbindd must be running.\n");
+               d_fprintf(stderr,
+                         _("To use net idmap Winbindd must be running.\n"));
                return -1;
        }
 
@@ -137,7 +138,8 @@ static int net_idmap_restore(struct net_context *c, int argc, const char **argv)
                        /* set uid hwm */
                        wbc_status = wbcSetUidHwm(idval);
                        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                               d_fprintf(stderr, "Could not set USER HWM: %s\n",
+                               d_fprintf(stderr,
+                                         _("Could not set USER HWM: %s\n"),
                                          wbcErrorString(wbc_status));
                        }
                        continue;
@@ -145,18 +147,20 @@ static int net_idmap_restore(struct net_context *c, int argc, const char **argv)
                        /* set gid hwm */
                        wbc_status = wbcSetGidHwm(idval);
                        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                               d_fprintf(stderr, "Could not set GROUP HWM: %s\n",
+                               d_fprintf(stderr,
+                                         _("Could not set GROUP HWM: %s\n"),
                                          wbcErrorString(wbc_status));
                        }
                        continue;
                } else {
-                       d_fprintf(stderr, "ignoring invalid line [%s]\n", line);
+                       d_fprintf(stderr, _("ignoring invalid line [%s]\n"),
+                                 line);
                        continue;
                }
 
                wbc_status = wbcStringToSid(sid_string, &sid);
                if (!WBC_ERROR_IS_OK(wbc_status)) {
-                       d_fprintf(stderr, "ignoring invalid sid [%s]: %s\n",
+                       d_fprintf(stderr, _("ignoring invalid sid [%s]: %s\n"),
                                  sid_string, wbcErrorString(wbc_status));
                        continue;
                }
@@ -167,7 +171,8 @@ static int net_idmap_restore(struct net_context *c, int argc, const char **argv)
                        wbc_status = wbcSetGidMapping(idval, &sid);
                }
                if (!WBC_ERROR_IS_OK(wbc_status)) {
-                       d_fprintf(stderr, "Could not set mapping of %s %lu to sid %s: %s\n",
+                       d_fprintf(stderr,
+                                 _("Could not set mapping of %s %lu to sid %s: %s\n"),
                                 (type == ID_TYPE_GID) ? "GID" : "UID",
                                 idval, sid_string,
                                 wbcErrorString(wbc_status));
@@ -188,13 +193,13 @@ static int net_idmap_restore(struct net_context *c, int argc, const char **argv)
  **********************************************************/
 static int net_idmap_delete(struct net_context *c, int argc, const char **argv)
 {
-       d_printf("Not Implemented yet\n");
+       d_printf(_("Not Implemented yet\n"));
        return -1;
 }
 
 static int net_idmap_set(struct net_context *c, int argc, const char **argv)
 {
-       d_printf("Not Implemented yet\n");
+       d_printf(_("Not Implemented yet\n"));
        return -1;
 }
 bool idmap_store_secret(const char *backend, bool alloc,
@@ -232,13 +237,13 @@ static int net_idmap_secret(struct net_context *c, int argc, const char **argv)
        bool ret;
 
        if (argc != 2 || c->display_usage) {
-               d_printf("Usage:\n"
-                        "net idmap secret {<DOMAIN>|alloc} <secret>\n"
-                        "  Set the secret for the specified domain "
-                        "(or alloc module)\n"
-                        "    DOMAIN\tDomain to set secret for.\n"
-                        "    alloc\tSet secret for the alloc module\n"
-                        "    secret\tNew secret to set.\n");
+               d_printf(_("Usage:\n"
+                          "net idmap secret {<DOMAIN>|alloc} <secret>\n"
+                          "  Set the secret for the specified domain "
+                          "(or alloc module)\n"
+                          "    DOMAIN\tDomain to set secret for.\n"
+                          "    alloc\tSet secret for the alloc module\n"
+                          "    secret\tNew secret to set.\n"));
                return c->display_usage?0:-1;
        }
 
@@ -262,7 +267,8 @@ static int net_idmap_secret(struct net_context *c, int argc, const char **argv)
        }
 
        if ( ( ! backend) || ( ! strequal(backend, "ldap"))) {
-               d_fprintf(stderr, "The only currently supported backend is LDAP\n");
+               d_fprintf(stderr,
+                         _("The only currently supported backend is LDAP\n"));
                talloc_free(ctx);
                return -1;
        }
@@ -271,7 +277,9 @@ static int net_idmap_secret(struct net_context *c, int argc, const char **argv)
 
                dn = lp_parm_const_string(-1, opt, "ldap_user_dn", NULL);
                if ( ! dn) {
-                       d_fprintf(stderr, "Missing ldap_user_dn option for domain %s\n", domain);
+                       d_fprintf(stderr,
+                                 _("Missing ldap_user_dn option for domain "
+                                   "%s\n"), domain);
                        talloc_free(ctx);
                        return -1;
                }
@@ -280,7 +288,9 @@ static int net_idmap_secret(struct net_context *c, int argc, const char **argv)
        } else {
                dn = lp_parm_const_string(-1, "idmap alloc config", "ldap_user_dn", NULL);
                if ( ! dn) {
-                       d_fprintf(stderr, "Missing ldap_user_dn option for alloc backend\n");
+                       d_fprintf(stderr,
+                                 _("Missing ldap_user_dn option for alloc "
+                                   "backend\n"));
                        talloc_free(ctx);
                        return -1;
                }
@@ -289,27 +299,28 @@ static int net_idmap_secret(struct net_context *c, int argc, const char **argv)
        }
 
        if ( ! ret) {
-               d_fprintf(stderr, "Failed to store secret\n");
+               d_fprintf(stderr, _("Failed to store secret\n"));
                talloc_free(ctx);
                return -1;
        }
 
-       d_printf("Secret stored\n");
+       d_printf(_("Secret stored\n"));
        return 0;
 }
 
 int net_help_idmap(struct net_context *c, int argc, const char **argv)
 {
-       d_printf("net idmap dump <inputfile>\n"
-                "    Dump current id mapping\n");
+       d_printf(_("net idmap dump <inputfile>\n"
+                  "    Dump current id mapping\n"));
 
-       d_printf("net idmap restore\n"
-                "    Restore entries from stdin\n");
+       d_printf(_("net idmap restore\n"
+                  "    Restore entries from stdin\n"));
 
        /* Deliberately *not* document net idmap delete */
 
-       d_printf("net idmap secret <DOMAIN>|alloc <secret>\n"
-                "    Set the secret for the specified DOMAIN (or the alloc module)\n");
+       d_printf(_("net idmap secret <DOMAIN>|alloc <secret>\n"
+                  "    Set the secret for the specified DOMAIN (or the alloc "
+                  "module)\n"));
 
        return -1;
 }
@@ -325,41 +336,41 @@ static int net_idmap_aclmapset(struct net_context *c, int argc, const char **arg
        NTSTATUS status;
 
        if (argc != 3 || c->display_usage) {
-               d_fprintf(stderr, "usage: net idmap aclmapset <tdb> "
-                         "<src-sid> <dst-sid>\n");
+               d_fprintf(stderr, _("usage: net idmap aclmapset <tdb> "
+                                   "<src-sid> <dst-sid>\n"));
                return -1;
        }
 
        if (!(mem_ctx = talloc_init("net idmap aclmapset"))) {
-               d_fprintf(stderr, "talloc_init failed\n");
+               d_fprintf(stderr, _("talloc_init failed\n"));
                return -1;
        }
 
        if (!(db = db_open(mem_ctx, argv[0], 0, TDB_DEFAULT,
                           O_RDWR|O_CREAT, 0600))) {
-               d_fprintf(stderr, "db_open failed: %s\n", strerror(errno));
+               d_fprintf(stderr, _("db_open failed: %s\n"), strerror(errno));
                goto fail;
        }
 
        if (!string_to_sid(&src_sid, argv[1])) {
-               d_fprintf(stderr, "%s is not a valid sid\n", argv[1]);
+               d_fprintf(stderr, _("%s is not a valid sid\n"), argv[1]);
                goto fail;
        }
 
        if (!string_to_sid(&dst_sid, argv[2])) {
-               d_fprintf(stderr, "%s is not a valid sid\n", argv[2]);
+               d_fprintf(stderr, _("%s is not a valid sid\n"), argv[2]);
                goto fail;
        }
 
        if (!(src = sid_string_talloc(mem_ctx, &src_sid))
            || !(dst = sid_string_talloc(mem_ctx, &dst_sid))) {
-               d_fprintf(stderr, "talloc_strdup failed\n");
+               d_fprintf(stderr, _("talloc_strdup failed\n"));
                goto fail;
        }
 
        if (!(rec = db->fetch_locked(
                      db, mem_ctx, string_term_tdb_data(src)))) {
-               d_fprintf(stderr, "could not fetch db record\n");
+               d_fprintf(stderr, _("could not fetch db record\n"));
                goto fail;
        }
 
@@ -367,7 +378,7 @@ static int net_idmap_aclmapset(struct net_context *c, int argc, const char **arg
        TALLOC_FREE(rec);
 
        if (!NT_STATUS_IS_OK(status)) {
-               d_fprintf(stderr, "could not store record: %s\n",
+               d_fprintf(stderr, _("could not store record: %s\n"),
                          nt_errstr(status));
                goto fail;
        }
@@ -388,49 +399,49 @@ int net_idmap(struct net_context *c, int argc, const char **argv)
                        "dump",
                        net_idmap_dump,
                        NET_TRANSPORT_LOCAL,
-                       "Dump the current ID mappings",
-                       "net idmap dump\n"
-                       "  Dump the current ID mappings"
+                       N_("Dump the current ID mappings"),
+                       N_("net idmap dump\n"
+                          "  Dump the current ID mappings")
                },
                {
                        "restore",
                        net_idmap_restore,
                        NET_TRANSPORT_LOCAL,
-                       "Restore entries from stdin",
-                       "net idmap restore\n"
-                       "  Restore entries from stdin"
+                       N_("Restore entries from stdin"),
+                       N_("net idmap restore\n"
+                          "  Restore entries from stdin")
                },
                {
                        "setmap",
                        net_idmap_set,
                        NET_TRANSPORT_LOCAL,
-                       "Not implemented yet",
-                       "net idmap setmap\n"
-                       "  Not implemented yet"
+                       N_("Not implemented yet"),
+                       N_("net idmap setmap\n"
+                          "  Not implemented yet")
                },
                {
                        "delete",
                        net_idmap_delete,
                        NET_TRANSPORT_LOCAL,
-                       "Not implemented yet",
-                       "net idmap delete\n"
-                       "  Not implemented yet"
+                       N_("Not implemented yet"),
+                       N_("net idmap delete\n"
+                          "  Not implemented yet")
                },
                {
                        "secret",
                        net_idmap_secret,
                        NET_TRANSPORT_LOCAL,
-                       "Set secret for specified domain",
-                       "net idmap secret {<DOMAIN>|alloc} <secret>\n"
-                       "  Set secret for specified domain or alloc module"
+                       N_("Set secret for specified domain"),
+                       N_("net idmap secret {<DOMAIN>|alloc} <secret>\n"
+                          "  Set secret for specified domain or alloc module")
                },
                {
                        "aclmapset",
                        net_idmap_aclmapset,
                        NET_TRANSPORT_LOCAL,
-                       "Set acl map",
-                       "net idmap aclmapset\n"
-                       "  Set acl map"
+                       N_("Set acl map"),
+                       N_("net idmap aclmapset\n"
+                          "  Set acl map")
                },
                {NULL, NULL, 0, NULL, NULL}
        };