1: /* Copyright (c) 1997, 1998, 1999, 2004 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, write to the Free
   17:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   18:    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: 
   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: }