nis/nis_print.c

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