nis/nis_print.c

   1 /* Copyright (c) 1997-2013 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <time.h>
  20 #include <string.h>
  21 #include <libintl.h>
  22 #include <stdint.h>
  23
  24 #include <rpcsvc/nis.h>
  25
  26 static const char *
  27 nis_nstype2str (const nstype type)
  28 {
  29
  30 /* Name service names mustn't be translated, only UNKNOWN needs it */
  31
  32   switch (type)
  33     {
  34     case NIS:
  35       return "NIS";
  36     case SUNYP:
  37       return "SUNYP";
  38     case IVY:
  39       return "IVY";
  40     case DNS:
  41       return "DNS";
  42     case X500:
  43       return "X500";
  44     case DNANS:
  45       return "DNANS";
  46     case XCHS:
  47       return "XCHS";
  48     case CDS:
  49       return "CDS";
  50     default:
  51       return N_("UNKNOWN");
  52     }
  53 }
  54
  55 static void
  56 print_ttl (const uint32_t ttl)
  57 {
  58   uint32_t time, s, m, h;
  59
  60   time = ttl;
  61
  62   h = time / (60 * 60);
  63   time %= (60 * 60);
  64   m = time / 60;
  65   time %= 60;
  66   s = time;
  67   printf ("%u:%u:%u\n", h, m, s);
  68 }
  69
  70 static void
  71 print_flags (const unsigned int flags)
  72 {
  73   fputs ("(", stdout);
  74
  75   if (flags & TA_SEARCHABLE)
  76     fputs ("SEARCHABLE, ", stdout);
  77
  78   if (flags & TA_BINARY)
  79     {
  80       fputs ("BINARY DATA", stdout);
  81       if (flags & TA_XDR)
  82         fputs (", XDR ENCODED", stdout);
  83       if (flags & TA_ASN1)
  84         fputs (", ASN.1 ENCODED", stdout);
  85       if (flags & TA_CRYPT)
  86         fputs (", ENCRYPTED", stdout);
  87     }
  88   else
  89     {
  90       fputs ("TEXTUAL DATA", stdout);
  91       if (flags & TA_SEARCHABLE)
  92         {
  93           if (flags & TA_CASE)
  94             fputs (", CASE INSENSITIVE", stdout);
  95           else
  96             fputs (", CASE SENSITIVE", stdout);
  97         }
  98     }
  99
 100   fputs (")\n", stdout);
 101 }
 102
 103 static void
 104 nis_print_objtype (enum zotypes type)
 105 {
 106   switch (type)
 107     {
 108     case NIS_BOGUS_OBJ:
 109       fputs (_("BOGUS OBJECT\n"), stdout);
 110       break;
 111     case NIS_NO_OBJ:
 112       fputs (_("NO OBJECT\n"), stdout);
 113       break;
 114     case NIS_DIRECTORY_OBJ:
 115       fputs (_("DIRECTORY\n"), stdout);
 116       break;
 117     case NIS_GROUP_OBJ:
 118       fputs (_("GROUP\n"), stdout);
 119       break;
 120     case NIS_TABLE_OBJ:
 121       fputs (_("TABLE\n"), stdout);
 122       break;
 123     case NIS_ENTRY_OBJ:
 124       fputs (_("ENTRY\n"), stdout);
 125       break;
 126     case NIS_LINK_OBJ:
 127       fputs (_("LINK\n"), stdout);
 128       break;
 129     case NIS_PRIVATE_OBJ:
 130       fputs (_("PRIVATE\n"), stdout);
 131       break;
 132     default:
 133       fputs (_("(Unknown object)\n"), stdout);
 134       break;
 135     }
 136 }
 137
 138 void
 139 nis_print_rights (const unsigned int access)
 140 {
 141   char result[17];
 142   unsigned int acc;
 143   int i;
 144
 145   acc = access;                 /* Parameter is const ! */
 146   result[i = 16] = '\0';
 147   while (i > 0)
 148     {
 149       i -= 4;
 150       result[i + 0] = (acc & NIS_READ_ACC) ? 'r' : '-';
 151       result[i + 1] = (acc & NIS_MODIFY_ACC) ? 'm' : '-';
 152       result[i + 2] = (acc & NIS_CREATE_ACC) ? 'c' : '-';
 153       result[i + 3] = (acc & NIS_DESTROY_ACC) ? 'd' : '-';
 154
 155       acc >>= 8;
 156     }
 157   fputs (result, stdout);
 158 }
 159 libnsl_hidden_def (nis_print_rights)
 160
 161 void
 162 nis_print_directory (const directory_obj *dir)
 163 {
 164   nis_server *sptr;
 165   unsigned int i;
 166
 167   printf (_("Name : `%s'\n"), dir->do_name);
 168   printf (_("Type : %s\n"), nis_nstype2str (dir->do_type));
 169   sptr = dir->do_servers.do_servers_val;
 170   for (i = 0; i < dir->do_servers.do_servers_len; i++)
 171     {
 172       if (i == 0)
 173         fputs (_("Master Server :\n"), stdout);
 174       else
 175         fputs (_("Replicate :\n"), stdout);
 176       printf (_("\tName       : %s\n"), sptr->name);
 177       fputs (_("\tPublic Key : "), stdout);
 178       switch (sptr->key_type)
 179         {
 180         case NIS_PK_NONE:
 181           fputs (_("None.\n"), stdout);
 182           break;
 183         case NIS_PK_DH:
 184           printf (_("Diffie-Hellmann (%d bits)\n"),
 185                   (sptr->pkey.n_len - 1) * 4);
 186           /* sptr->pkey.n_len counts the last 0, too */
 187           break;
 188         case NIS_PK_RSA:
 189           printf (_("RSA (%d bits)\n"), (sptr->pkey.n_len - 1) * 4);
 190           break;
 191         case NIS_PK_KERB:
 192           fputs (_("Kerberos.\n"), stdout);
 193           break;
 194         default:
 195           printf (_("Unknown (type = %d, bits = %d)\n"), sptr->key_type,
 196                   (sptr->pkey.n_len - 1) * 4);
 197           break;
 198         }
 199
 200       if (sptr->ep.ep_len != 0)
 201         {
 202           unsigned int j;
 203
 204           endpoint *ptr;
 205           ptr = sptr->ep.ep_val;
 206           printf (_("\tUniversal addresses (%u)\n"), sptr->ep.ep_len);
 207           for (j = 0; j < sptr->ep.ep_len; j++)
 208             {
 209               printf ("\t[%d] - ", j + 1);
 210               if (ptr->proto != NULL && ptr->proto[0] != '\0')
 211                 printf ("%s, ", ptr->proto);
 212               else
 213                 printf ("-, ");
 214               if (ptr->family != NULL && ptr->family[0] != '\0')
 215                 printf ("%s, ", ptr->family);
 216               else
 217                 printf ("-, ");
 218               if (ptr->uaddr != NULL && ptr->uaddr[0] != '\0')
 219                 printf ("%s\n", ptr->uaddr);
 220               else
 221                 fputs ("-\n", stdout);
 222               ptr++;
 223             }
 224         }
 225       sptr++;
 226     }
 227
 228   fputs (_("Time to live : "), stdout);
 229   print_ttl (dir->do_ttl);
 230   fputs (_("Default Access rights :\n"), stdout);
 231   if (dir->do_armask.do_armask_len != 0)
 232     {
 233       oar_mask *ptr;
 234
 235       ptr = dir->do_armask.do_armask_val;
 236       for (i = 0; i < dir->do_armask.do_armask_len; i++)
 237         {
 238           nis_print_rights (ptr->oa_rights);
 239           printf (_("\tType         : %s\n"), nis_nstype2str (ptr->oa_otype));
 240           fputs (_("\tAccess rights: "), stdout);
 241           nis_print_rights (ptr->oa_rights);
 242           fputs ("\n", stdout);
 243           ptr++;
 244         }
 245     }
 246 }
 247 libnsl_hidden_def (nis_print_directory)
 248
 249 void
 250 nis_print_group (const group_obj *obj)
 251 {
 252   unsigned int i;
 253
 254   fputs (_("Group Flags :"), stdout);
 255   if (obj->gr_flags)
 256     printf ("0x%08X", obj->gr_flags);
 257   fputs (_("\nGroup Members :\n"), stdout);
 258
 259   for (i = 0; i < obj->gr_members.gr_members_len; i++)
 260     printf ("\t%s\n", obj->gr_members.gr_members_val[i]);
 261 }
 262 libnsl_hidden_def (nis_print_group)
 263
 264 void
 265 nis_print_table (const table_obj *obj)
 266 {
 267   unsigned int i;
 268
 269   printf (_("Table Type          : %s\n"), obj->ta_type);
 270   printf (_("Number of Columns   : %d\n"), obj->ta_maxcol);
 271   printf (_("Character Separator : %c\n"), obj->ta_sep);
 272   printf (_("Search Path         : %s\n"), obj->ta_path);
 273   fputs (_("Columns             :\n"), stdout);
 274   for (i = 0; i < obj->ta_cols.ta_cols_len; i++)
 275     {
 276       printf (_("\t[%d]\tName          : %s\n"), i,
 277               obj->ta_cols.ta_cols_val[i].tc_name);
 278       fputs (_("\t\tAttributes    : "), stdout);
 279       print_flags (obj->ta_cols.ta_cols_val[i].tc_flags);
 280       fputs (_("\t\tAccess Rights : "), stdout);
 281       nis_print_rights (obj->ta_cols.ta_cols_val[i].tc_rights);
 282       fputc ('\n', stdout);
 283     }
 284 }
 285 libnsl_hidden_def (nis_print_table)
 286
 287 void
 288 nis_print_link (const link_obj *obj)
 289 {
 290   fputs (_("Linked Object Type : "), stdout);
 291   nis_print_objtype (obj->li_rtype);
 292   printf (_("Linked to : %s\n"), obj->li_name);
 293   /* XXX Print the attributs here, if they exists */
 294 }
 295 libnsl_hidden_def (nis_print_link)
 296
 297 void
 298 nis_print_entry (const entry_obj *obj)
 299 {
 300   unsigned int i;
 301
 302   printf (_("\tEntry data of type %s\n"), obj->en_type);
 303   for (i = 0; i < obj->en_cols.en_cols_len; i++)
 304     {
 305       printf (_("\t[%u] - [%u bytes] "), i,
 306               obj->en_cols.en_cols_val[i].ec_value.ec_value_len);
 307       if ((obj->en_cols.en_cols_val[i].ec_flags & EN_CRYPT) == EN_CRYPT)
 308         fputs (_("Encrypted data\n"), stdout);
 309       else if ((obj->en_cols.en_cols_val[i].ec_flags & EN_BINARY) == EN_BINARY)
 310         fputs (_("Binary data\n"), stdout);
 311       else if (obj->en_cols.en_cols_val[i].ec_value.ec_value_len == 0)
 312         fputs ("'(nil)'\n", stdout);
 313       else
 314         printf ("'%.*s'\n",
 315                 (int)obj->en_cols.en_cols_val[i].ec_value.ec_value_len,
 316                 obj->en_cols.en_cols_val[i].ec_value.ec_value_val);
 317     }
 318 }
 319 libnsl_hidden_def (nis_print_entry)
 320
 321 void
 322 nis_print_object (const nis_object * obj)
 323 {
 324   time_t buf;
 325
 326   printf (_("Object Name   : %s\n"), obj->zo_name);
 327   printf (_("Directory     : %s\n"), obj->zo_domain);
 328   printf (_("Owner         : %s\n"), obj->zo_owner);
 329   printf (_("Group         : %s\n"), obj->zo_group);
 330   fputs (_("Access Rights : "), stdout);
 331   nis_print_rights (obj->zo_access);
 332   printf (_("\nTime to Live  : "));
 333   print_ttl (obj->zo_ttl);
 334   buf = obj->zo_oid.ctime;
 335   printf (_("Creation Time : %s"), ctime (&buf));
 336   buf = obj->zo_oid.mtime;
 337   printf (_("Mod. Time     : %s"), ctime (&buf));
 338   fputs (_("Object Type   : "), stdout);
 339   nis_print_objtype (obj->zo_data.zo_type);
 340   switch (obj->zo_data.zo_type)
 341     {
 342     case NIS_DIRECTORY_OBJ:
 343       nis_print_directory (&obj->zo_data.objdata_u.di_data);
 344       break;
 345     case NIS_GROUP_OBJ:
 346       nis_print_group (&obj->zo_data.objdata_u.gr_data);
 347       break;
 348     case NIS_TABLE_OBJ:
 349       nis_print_table (&obj->zo_data.objdata_u.ta_data);
 350       break;
 351     case NIS_ENTRY_OBJ:
 352       nis_print_entry (&obj->zo_data.objdata_u.en_data);
 353       break;
 354     case NIS_LINK_OBJ:
 355       nis_print_link (&obj->zo_data.objdata_u.li_data);
 356       break;
 357     case NIS_PRIVATE_OBJ:
 358       printf (_("    Data Length = %u\n"),
 359               obj->zo_data.objdata_u.po_data.po_data_len);
 360       break;
 361     default:
 362       break;
 363     }
 364 }
 365 libnsl_hidden_def (nis_print_object)
 366
 367 void
 368 nis_print_result (const nis_result *res)
 369 {
 370   unsigned int i;
 371
 372   printf (_("Status            : %s\n"), nis_sperrno (NIS_RES_STATUS (res)));
 373   printf (_("Number of objects : %u\n"), res->objects.objects_len);
 374
 375   for (i = 0; i < res->objects.objects_len; i++)
 376     {
 377       printf (_("Object #%d:\n"), i);
 378       nis_print_object (&res->objects.objects_val[i]);
 379     }
 380 }