(getspnam_plususer): Preserve original return value.
[kopensolaris-gnu/glibc.git] / nis / nis_print.c
index 7612db3..a8d7e8c 100644 (file)
@@ -1,30 +1,34 @@
-/* Copyright (c) 1997 Free Software Foundation, Inc.
-
+/* Copyright (c) 1997, 1998, 1999, 2004 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
 
    The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
 
    The GNU C Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
+   Lesser General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
 
 #include <time.h>
+#include <string.h>
+#include <libintl.h>
+
 #include <rpcsvc/nis.h>
-#include <rpcsvc/nislib.h>
 
 static const char *
 nis_nstype2str (const nstype type)
 {
+
+/* Name service names mustn't be translated, only UNKNOWN needs it */
+
   switch (type)
     {
     case NIS:
@@ -44,15 +48,14 @@ nis_nstype2str (const nstype type)
     case CDS:
       return "CDS";
     default:
-      return "UNKNOWN";
+      return N_("UNKNOWN");
     }
 }
 
-static char *
-nis_ttl2str (const u_long ttl)
+static void
+print_ttl (const uint32_t ttl)
 {
-  static char buf[64];
-  unsigned long int time, s, m, h;
+  uint32_t time, s, m, h;
 
   time = ttl;
 
@@ -61,26 +64,82 @@ nis_ttl2str (const u_long ttl)
   m = time / 60;
   time %= 60;
   s = time;
-  snprintf (buf, 63, "%lu:%02lu:%02lu", h, m, s);
-
-  return buf;
+  printf ("%u:%u:%u\n", h, m, s);
 }
 
-static char *
-nis_flags2str (const u_long flags)
+static void
+print_flags (const unsigned int flags)
 {
-  static char buf[1024];
+  fputs ("(", stdout);
 
-  snprintf (buf, 1023, "%lu", flags);
+  if (flags & TA_SEARCHABLE)
+    fputs ("SEARCHABLE, ", stdout);
 
-  return buf;
+  if (flags & TA_BINARY)
+    {
+      fputs ("BINARY DATA", stdout);
+      if (flags & TA_XDR)
+       fputs (", XDR ENCODED", stdout);
+      if (flags & TA_ASN1)
+       fputs (", ASN.1 ENCODED", stdout);
+      if (flags & TA_CRYPT)
+       fputs (", ENCRYPTED", stdout);
+    }
+  else
+    {
+      fputs ("TEXTUAL DATA", stdout);
+      if (flags & TA_SEARCHABLE)
+       {
+         if (flags & TA_CASE)
+           fputs (", CASE INSENSITIVE", stdout);
+         else
+           fputs (", CASE SENSITIVE", stdout);
+       }
+    }
+
+  fputs (")\n", stdout);
+}
+
+static void
+nis_print_objtype (enum zotypes type)
+{
+  switch (type)
+    {
+    case NIS_BOGUS_OBJ:
+      fputs (_("BOGUS OBJECT\n"), stdout);
+      break;
+    case NIS_NO_OBJ:
+      fputs (_("NO OBJECT\n"), stdout);
+      break;
+    case NIS_DIRECTORY_OBJ:
+      fputs (_("DIRECTORY\n"), stdout);
+      break;
+    case NIS_GROUP_OBJ:
+      fputs (_("GROUP\n"), stdout);
+      break;
+    case NIS_TABLE_OBJ:
+      fputs (_("TABLE\n"), stdout);
+      break;
+    case NIS_ENTRY_OBJ:
+      fputs (_("ENTRY\n"), stdout);
+      break;
+    case NIS_LINK_OBJ:
+      fputs (_("LINK\n"), stdout);
+      break;
+    case NIS_PRIVATE_OBJ:
+      fputs (_("PRIVATE\n"), stdout);
+      break;
+    default:
+      fputs (_("(Unknown object)\n"), stdout);
+      break;
+    }
 }
 
 void
-nis_print_rights (const u_long access)
+nis_print_rights (const unsigned int access)
 {
   char result[17];
-  u_long acc;
+  unsigned int acc;
   int i;
 
   acc = access;                        /* Parameter is const ! */
@@ -95,42 +154,46 @@ nis_print_rights (const u_long access)
 
       acc >>= 8;
     }
-  printf ("%s", result);
+  fputs (result, stdout);
 }
+libnsl_hidden_def (nis_print_rights)
 
 void
-nis_print_directory (const directory_obj * dir)
+nis_print_directory (const directory_obj *dir)
 {
   nis_server *sptr;
   unsigned int i;
 
-  printf ("Name : '%s'\n", dir->do_name);
-  printf ("Type : %s\n", nis_nstype2str (dir->do_type));
+  printf (_("Name : `%s'\n"), dir->do_name);
+  printf (_("Type : %s\n"), nis_nstype2str (dir->do_type));
   sptr = dir->do_servers.do_servers_val;
   for (i = 0; i < dir->do_servers.do_servers_len; i++)
     {
       if (i == 0)
-       printf ("Master Server :\n");
+       fputs (_("Master Server :\n"), stdout);
       else
-       printf ("Replicate :\n");
-      printf ("\tName       : %s\n", sptr->name);
-      printf ("\tPublic Key : ");
+       fputs (_("Replicate :\n"), stdout);
+      printf (_("\tName       : %s\n"), sptr->name);
+      fputs (_("\tPublic Key : "), stdout);
       switch (sptr->key_type)
        {
        case NIS_PK_NONE:
-         printf ("None.\n");
+         fputs (_("None.\n"), stdout);
          break;
        case NIS_PK_DH:
-         printf ("DH.\n");
+         printf (_("Diffie-Hellmann (%d bits)\n"),
+                 (sptr->pkey.n_len - 1) * 4);
+         /* sptr->pkey.n_len counts the last 0, too */
          break;
        case NIS_PK_RSA:
-         printf ("RSA.\n");
+         printf (_("RSA (%d bits)\n"), (sptr->pkey.n_len - 1) * 4);
          break;
        case NIS_PK_KERB:
-         printf ("Kerberous.\n");
+         fputs (_("Kerberos.\n"), stdout);
          break;
        default:
-         printf ("Unknown.\n");
+         printf (_("Unknown (type = %d, bits = %d)\n"), sptr->key_type,
+                 (sptr->pkey.n_len - 1) * 4);
          break;
        }
 
@@ -140,29 +203,31 @@ nis_print_directory (const directory_obj * dir)
 
          endpoint *ptr;
          ptr = sptr->ep.ep_val;
-         printf ("\tUniversal addresses (%u)\n", sptr->ep.ep_len);
+         printf (_("\tUniversal addresses (%u)\n"), sptr->ep.ep_len);
          for (j = 0; j < sptr->ep.ep_len; j++)
            {
              printf ("\t[%d] - ", j + 1);
-             if (ptr->proto != NULL && strlen (ptr->proto) > 0)
+             if (ptr->proto != NULL && ptr->proto[0] != '\0')
                printf ("%s, ", ptr->proto);
              else
                printf ("-, ");
-             if (ptr->family != NULL && strlen (ptr->family) > 0)
+             if (ptr->family != NULL && ptr->family[0] != '\0')
                printf ("%s, ", ptr->family);
              else
                printf ("-, ");
-             if (ptr->uaddr != NULL && strlen (ptr->uaddr) > 0)
+             if (ptr->uaddr != NULL && ptr->uaddr[0] != '\0')
                printf ("%s\n", ptr->uaddr);
              else
-               printf ("-\n");
+               fputs ("-\n", stdout);
              ptr++;
            }
        }
       sptr++;
     }
 
-  printf ("Time to live : %s\n", nis_ttl2str (dir->do_ttl));
+  fputs (_("Time to live : "), stdout);
+  print_ttl (dir->do_ttl);
+  fputs (_("Default Access rights :\n"), stdout);
   if (dir->do_armask.do_armask_len != 0)
     {
       oar_mask *ptr;
@@ -170,140 +235,146 @@ nis_print_directory (const directory_obj * dir)
       ptr = dir->do_armask.do_armask_val;
       for (i = 0; i < dir->do_armask.do_armask_len; i++)
        {
-         printf ("Default Access rights: ");
          nis_print_rights (ptr->oa_rights);
-         printf ("\nDirect Type : %d\n", ptr->oa_otype);
+         printf (_("\tType         : %s\n"), nis_nstype2str (ptr->oa_otype));
+         fputs (_("\tAccess rights: "), stdout);
+         nis_print_rights (ptr->oa_rights);
+         fputs ("\n", stdout);
          ptr++;
        }
     }
 }
+libnsl_hidden_def (nis_print_directory)
 
 void
-nis_print_group (const group_obj * obj)
+nis_print_group (const group_obj *obj)
 {
   unsigned int i;
 
-  printf ("Group Flags :");
+  fputs (_("Group Flags :"), stdout);
   if (obj->gr_flags)
-    printf ("0x%08lX", obj->gr_flags);
-  printf ("\nGroup Members :\n");
+    printf ("0x%08X", obj->gr_flags);
+  fputs (_("\nGroup Members :\n"), stdout);
 
   for (i = 0; i < obj->gr_members.gr_members_len; i++)
     printf ("\t%s\n", obj->gr_members.gr_members_val[i]);
 }
+libnsl_hidden_def (nis_print_group)
 
 void
-nis_print_table (const table_obj * obj)
+nis_print_table (const table_obj *obj)
 {
   unsigned int i;
 
-  printf ("Table Type          : %s\n", obj->ta_type);
-  printf ("Number of Columns   : %d\n", obj->ta_maxcol);
-  printf ("Character Separator : %c\n", obj->ta_sep);
-  printf ("Search Path         : %s\n", obj->ta_path);
-  printf ("Columns             :\n");
+  printf (_("Table Type          : %s\n"), obj->ta_type);
+  printf (_("Number of Columns   : %d\n"), obj->ta_maxcol);
+  printf (_("Character Separator : %c\n"), obj->ta_sep);
+  printf (_("Search Path         : %s\n"), obj->ta_path);
+  fputs (_("Columns             :\n"), stdout);
   for (i = 0; i < obj->ta_cols.ta_cols_len; i++)
     {
-      printf ("\t[%d]\tName          : %s\n", i,
+      printf (_("\t[%d]\tName          : %s\n"), i,
              obj->ta_cols.ta_cols_val[i].tc_name);
-      printf ("\t\tAttributes    : %s\n",
-             nis_flags2str (obj->ta_cols.ta_cols_val[i].tc_flags));
-      printf ("\t\tAccess Rights : ");
+      fputs (_("\t\tAttributes    : "), stdout);
+      print_flags (obj->ta_cols.ta_cols_val[i].tc_flags);
+      fputs (_("\t\tAccess Rights : "), stdout);
       nis_print_rights (obj->ta_cols.ta_cols_val[i].tc_rights);
-      printf ("\n");
+      fputc ('\n', stdout);
     }
 }
+libnsl_hidden_def (nis_print_table)
 
 void
-nis_print_link (const link_obj * obj)
+nis_print_link (const link_obj *obj)
 {
-  printf ("Type : %d\n", obj->li_rtype);
-  printf ("Name : %s\n", obj->li_name);
-  printf ("Attributes : %d\n", obj->li_attrs.li_attrs_len);
+  fputs (_("Linked Object Type : "), stdout);
+  nis_print_objtype (obj->li_rtype);
+  printf (_("Linked to : %s\n"), obj->li_name);
+  /* XXX Print the attributs here, if they exists */
 }
+libnsl_hidden_def (nis_print_link)
 
-void 
-nis_print_entry (const entry_obj * obj)
+void
+nis_print_entry (const entry_obj *obj)
 {
   unsigned int i;
 
-  printf ("\tEntry data of type %s\n", obj->en_type);
+  printf (_("\tEntry data of type %s\n"), obj->en_type);
   for (i = 0; i < obj->en_cols.en_cols_len; i++)
     {
-      printf ("\t[%u] - [%u bytes] ", i,
+      printf (_("\t[%u] - [%u bytes] "), i,
              obj->en_cols.en_cols_val[i].ec_value.ec_value_len);
       if ((obj->en_cols.en_cols_val[i].ec_flags & EN_CRYPT) == EN_CRYPT)
-       printf ("Encrypted data\n");
+       fputs (_("Encrypted data\n"), stdout);
       else if ((obj->en_cols.en_cols_val[i].ec_flags & EN_BINARY) == EN_BINARY)
-       printf ("Binary data\n");
+       fputs (_("Binary data\n"), stdout);
+      else if (obj->en_cols.en_cols_val[i].ec_value.ec_value_len == 0)
+       fputs ("'(nil)'\n", stdout);
       else
-       printf ("%s\n", obj->en_cols.en_cols_val[i].ec_value.ec_value_val);
+       printf ("'%.*s'\n",
+               (int)obj->en_cols.en_cols_val[i].ec_value.ec_value_len,
+               obj->en_cols.en_cols_val[i].ec_value.ec_value_val);
     }
 }
+libnsl_hidden_def (nis_print_entry)
 
 void
 nis_print_object (const nis_object * obj)
 {
-  printf ("Object Name   : %s\n", obj->zo_name);
-  printf ("Directory     : %s\n", obj->zo_domain);
-  printf ("Owner         : %s\n", obj->zo_owner);
-  printf ("Group         : %s\n", obj->zo_group);
-  printf ("Access Rights : ");
+  time_t buf;
+
+  printf (_("Object Name   : %s\n"), obj->zo_name);
+  printf (_("Directory     : %s\n"), obj->zo_domain);
+  printf (_("Owner         : %s\n"), obj->zo_owner);
+  printf (_("Group         : %s\n"), obj->zo_group);
+  fputs (_("Access Rights : "), stdout);
   nis_print_rights (obj->zo_access);
-  printf ("\nTime to Live  : %lu (seconds)\n", obj->zo_ttl);
-  printf ("Creation Time : %s", ctime (&obj->zo_oid.ctime));
-  printf ("Mod. Time     : %s", ctime (&obj->zo_oid.mtime));
-  printf ("Object Type   : ");
+  printf (_("\nTime to Live  : "));
+  print_ttl (obj->zo_ttl);
+  buf = obj->zo_oid.ctime;
+  printf (_("Creation Time : %s"), ctime (&buf));
+  buf = obj->zo_oid.mtime;
+  printf (_("Mod. Time     : %s"), ctime (&buf));
+  fputs (_("Object Type   : "), stdout);
+  nis_print_objtype (obj->zo_data.zo_type);
   switch (obj->zo_data.zo_type)
     {
-    case BOGUS_OBJ:
-      printf ("BOGUS OBJECT\n");
-      break;
-    case NO_OBJ:
-      printf ("NO OBJECT\n");
-      break;
-    case DIRECTORY_OBJ:
-      printf ("DIRECTORY\n");
+    case NIS_DIRECTORY_OBJ:
       nis_print_directory (&obj->zo_data.objdata_u.di_data);
       break;
-    case GROUP_OBJ:
-      printf ("GROUP\n");
+    case NIS_GROUP_OBJ:
       nis_print_group (&obj->zo_data.objdata_u.gr_data);
       break;
-    case TABLE_OBJ:
-      printf ("TABLE\n");
+    case NIS_TABLE_OBJ:
       nis_print_table (&obj->zo_data.objdata_u.ta_data);
       break;
-    case ENTRY_OBJ:
-      printf ("ENTRY\n");
+    case NIS_ENTRY_OBJ:
       nis_print_entry (&obj->zo_data.objdata_u.en_data);
       break;
-    case LINK_OBJ:
-      printf ("LINK\n");
+    case NIS_LINK_OBJ:
       nis_print_link (&obj->zo_data.objdata_u.li_data);
       break;
-    case PRIVATE_OBJ:
-      printf ("PRIVATE\n");
-      printf ("    Data Length = %u\n",
+    case NIS_PRIVATE_OBJ:
+      printf (_("    Data Length = %u\n"),
              obj->zo_data.objdata_u.po_data.po_data_len);
       break;
     default:
-      printf ("(Unknown object)\n");
       break;
     }
 }
+libnsl_hidden_def (nis_print_object)
 
 void
-nis_print_result (const nis_result * res)
+nis_print_result (const nis_result *res)
 {
   unsigned int i;
 
-  printf ("Status            : %s\n", nis_sperrno (res->status));
-  printf ("Number of objects : %u\n", res->objects.objects_len);
+  printf (_("Status            : %s\n"), nis_sperrno (NIS_RES_STATUS (res)));
+  printf (_("Number of objects : %u\n"), res->objects.objects_len);
 
   for (i = 0; i < res->objects.objects_len; i++)
     {
-      printf ("Object #%d:\n", i);
+      printf (_("Object #%d:\n"), i);
       nis_print_object (&res->objects.objects_val[i]);
     }
 }