nis/nis_print.c

   1 /* Copyright (c) 1997 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
  23 #include <rpcsvc/nis.h>
  24 #include <rpcsvc/nislib.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 char *
  53 nis_ttl2str (const u_long ttl)
  54 {
  55   static char buf[64];
  56   unsigned long int time, s, m, h;
  57
  58   time = ttl;
  59
  60   h = time / (60 * 60);
  61   time %= (60 * 60);
  62   m = time / 60;
  63   time %= 60;
  64   s = time;
  65   snprintf (buf, 63, "%lu:%02lu:%02lu", h, m, s);
  66
  67   return buf;
  68 }
  69
  70 static char *
  71 nis_flags2str (const u_long flags)
  72 {
  73   static char buf[1024];
  74
  75   snprintf (buf, 1023, "%lu", flags);
  76
  77   return buf;
  78 }
  79
  80 static void
  81 nis_print_objtype (enum zotypes type)
  82 {
  83   switch (type)
  84     {
  85     case BOGUS_OBJ:
  86       fputs (_("BOGUS OBJECT\n"), stdout);
  87       break;
  88     case NO_OBJ:
  89       fputs (_("NO OBJECT\n"), stdout);
  90       break;
  91     case DIRECTORY_OBJ:
  92       fputs (_("DIRECTORY\n"), stdout);
  93       break;
  94     case GROUP_OBJ:
  95       fputs (_("GROUP\n"), stdout);
  96       break;
  97     case TABLE_OBJ:
  98       fputs (_("TABLE\n"), stdout);
  99       break;
 100     case ENTRY_OBJ:
 101       fputs (_("ENTRY\n"), stdout);
 102       break;
 103     case LINK_OBJ:
 104       fputs (_("LINK\n"), stdout);
 105       break;
 106     case PRIVATE_OBJ:
 107       fputs (_("PRIVATE\n"), stdout);
 108       break;
 109     default:
 110       fputs (_("(Unknown object)\n"), stdout);
 111       break;
 112     }
 113 }
 114
 115 void
 116 nis_print_rights (const u_long access)
 117 {
 118   char result[17];
 119   u_long acc;
 120   int i;
 121
 122   acc = access;                 /* Parameter is const ! */
 123   result[i = 16] = '\0';
 124   while (i > 0)
 125     {
 126       i -= 4;
 127       result[i + 0] = (acc & NIS_READ_ACC) ? 'r' : '-';
 128       result[i + 1] = (acc & NIS_MODIFY_ACC) ? 'm' : '-';
 129       result[i + 2] = (acc & NIS_CREATE_ACC) ? 'c' : '-';
 130       result[i + 3] = (acc & NIS_DESTROY_ACC) ? 'd' : '-';
 131
 132       acc >>= 8;
 133     }
 134   printf ("%s", result);
 135 }
 136
 137 void
 138 nis_print_directory (const directory_obj *dir)
 139 {
 140   nis_server *sptr;
 141   unsigned int i;
 142
 143   printf (_("Name : '%s'\n"), dir->do_name);
 144   printf (_("Type : %s\n"), gettext (nis_nstype2str (dir->do_type)));
 145   sptr = dir->do_servers.do_servers_val;
 146   for (i = 0; i < dir->do_servers.do_servers_len; i++)
 147     {
 148       if (i == 0)
 149         fputs (_("Master Server :\n"), stdout);
 150       else
 151         fputs (_("Replicate :\n"), stdout);
 152       printf (_("\tName       : %s\n"), sptr->name);
 153       fputs (_("\tPublic Key : "), stdout);
 154       switch (sptr->key_type)
 155         {
 156         case NIS_PK_NONE:
 157           fputs (_("None.\n"), stdout);
 158           break;
 159         case NIS_PK_DH:
 160           fputs (_("DH.\n"), stdout);
 161           break;
 162         case NIS_PK_RSA:
 163           fputs (_("RSA.\n"), stdout);
 164           break;
 165         case NIS_PK_KERB:
 166           fputs (_("Kerberous.\n"), stdout);
 167           break;
 168         default:
 169           fputs (_("Unknown.\n"), stdout);
 170           break;
 171         }
 172
 173       if (sptr->ep.ep_len != 0)
 174         {
 175           unsigned int j;
 176
 177           endpoint *ptr;
 178           ptr = sptr->ep.ep_val;
 179           printf (_("\tUniversal addresses (%u)\n"), sptr->ep.ep_len);
 180           for (j = 0; j < sptr->ep.ep_len; j++)
 181             {
 182               printf ("\t[%d] - ", j + 1);
 183               if (ptr->proto != NULL && strlen (ptr->proto) > 0)
 184                 printf ("%s, ", ptr->proto);
 185               else
 186                 printf ("-, ");
 187               if (ptr->family != NULL && strlen (ptr->family) > 0)
 188                 printf ("%s, ", ptr->family);
 189               else
 190                 printf ("-, ");
 191               if (ptr->uaddr != NULL && strlen (ptr->uaddr) > 0)
 192                 printf ("%s\n", ptr->uaddr);
 193               else
 194                 printf ("-\n");
 195               ptr++;
 196             }
 197         }
 198       sptr++;
 199     }
 200
 201   printf (_("Time to live : %s\n"), nis_ttl2str (dir->do_ttl));
 202   if (dir->do_armask.do_armask_len != 0)
 203     {
 204       oar_mask *ptr;
 205
 206       ptr = dir->do_armask.do_armask_val;
 207       for (i = 0; i < dir->do_armask.do_armask_len; i++)
 208         {
 209           fputs (_("Default Access rights: "), stdout);
 210           nis_print_rights (ptr->oa_rights);
 211           printf (_("\nDirect Type : %d\n"), ptr->oa_otype);
 212           ptr++;
 213         }
 214     }
 215 }
 216
 217 void
 218 nis_print_group (const group_obj *obj)
 219 {
 220   unsigned int i;
 221
 222   fputs (_("Group Flags :"), stdout);
 223   if (obj->gr_flags)
 224     printf ("0x%08lX", obj->gr_flags);
 225   fputs (_("\nGroup Members :\n"), stdout);
 226
 227   for (i = 0; i < obj->gr_members.gr_members_len; i++)
 228     printf ("\t%s\n", obj->gr_members.gr_members_val[i]);
 229 }
 230
 231 void
 232 nis_print_table (const table_obj *obj)
 233 {
 234   unsigned int i;
 235
 236   printf (_("Table Type          : %s\n"), obj->ta_type);
 237   printf (_("Number of Columns   : %d\n"), obj->ta_maxcol);
 238   printf (_("Character Separator : %c\n"), obj->ta_sep);
 239   printf (_("Search Path         : %s\n"), obj->ta_path);
 240   fputs (_("Columns             :\n"), stdout);
 241   for (i = 0; i < obj->ta_cols.ta_cols_len; i++)
 242     {
 243       printf (_("\t[%d]\tName          : %s\n"), i,
 244               obj->ta_cols.ta_cols_val[i].tc_name);
 245       printf (_("\t\tAttributes    : %s\n"),
 246               nis_flags2str (obj->ta_cols.ta_cols_val[i].tc_flags));
 247       fputs (_("\t\tAccess Rights : "), stdout);
 248       nis_print_rights (obj->ta_cols.ta_cols_val[i].tc_rights);
 249       fputc ('\n', stdout);
 250     }
 251 }
 252
 253 void
 254 nis_print_link (const link_obj *obj)
 255 {
 256   fputs (_("Linked Object Type : "), stdout);
 257   nis_print_objtype (obj->li_rtype);
 258   printf (_("Linked to : %s\n"), obj->li_name);
 259   /* XXX Print the attributs here, if they exists */
 260 }
 261
 262 void
 263 nis_print_entry (const entry_obj *obj)
 264 {
 265   unsigned int i;
 266
 267   printf (_("\tEntry data of type %s\n"), obj->en_type);
 268   for (i = 0; i < obj->en_cols.en_cols_len; i++)
 269     {
 270       printf (_("\t[%u] - [%u bytes] "), i,
 271               obj->en_cols.en_cols_val[i].ec_value.ec_value_len);
 272       if ((obj->en_cols.en_cols_val[i].ec_flags & EN_CRYPT) == EN_CRYPT)
 273         fputs (_("Encrypted data\n"), stdout);
 274       else if ((obj->en_cols.en_cols_val[i].ec_flags & EN_BINARY) == EN_BINARY)
 275         fputs (_("Binary data\n"), stdout);
 276       else
 277         printf ("%s\n", obj->en_cols.en_cols_val[i].ec_value.ec_value_val);
 278     }
 279 }
 280
 281 void
 282 nis_print_object (const nis_object * obj)
 283 {
 284   printf (_("Object Name   : %s\n"), obj->zo_name);
 285   printf (_("Directory     : %s\n"), obj->zo_domain);
 286   printf (_("Owner         : %s\n"), obj->zo_owner);
 287   printf (_("Group         : %s\n"), obj->zo_group);
 288   fputs (_("Access Rights : "), stdout);
 289   nis_print_rights (obj->zo_access);
 290   printf (_("\nTime to Live  : %lu (seconds)\n"), obj->zo_ttl);
 291   printf (_("Creation Time : %s"), ctime (&obj->zo_oid.ctime));
 292   printf (_("Mod. Time     : %s"), ctime (&obj->zo_oid.mtime));
 293   fputs (_("Object Type   : "), stdout);
 294   nis_print_objtype (obj->zo_data.zo_type);
 295   switch (obj->zo_data.zo_type)
 296     {
 297     case DIRECTORY_OBJ:
 298       nis_print_directory (&obj->zo_data.objdata_u.di_data);
 299       break;
 300     case GROUP_OBJ:
 301       nis_print_group (&obj->zo_data.objdata_u.gr_data);
 302       break;
 303     case TABLE_OBJ:
 304       nis_print_table (&obj->zo_data.objdata_u.ta_data);
 305       break;
 306     case ENTRY_OBJ:
 307       nis_print_entry (&obj->zo_data.objdata_u.en_data);
 308       break;
 309     case LINK_OBJ:
 310       nis_print_link (&obj->zo_data.objdata_u.li_data);
 311       break;
 312     case PRIVATE_OBJ:
 313       printf (_("    Data Length = %u\n"),
 314               obj->zo_data.objdata_u.po_data.po_data_len);
 315       break;
 316     default:
 317       break;
 318     }
 319 }
 320
 321 void
 322 nis_print_result (const nis_result *res)
 323 {
 324   unsigned int i;
 325
 326   printf (_("Status            : %s\n"), nis_sperrno (res->status));
 327   printf (_("Number of objects : %u\n"), res->objects.objects_len);
 328
 329   for (i = 0; i < res->objects.objects_len; i++)
 330     {
 331       printf (_("Object #%d:\n"), i);
 332       nis_print_object (&res->objects.objects_val[i]);
 333     }
 334 }