383 lines
9.8 KiB
C
383 lines
9.8 KiB
C
/* Copyright (c) 1997-2018 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 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
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include <time.h>
|
|
#include <string.h>
|
|
#include <libintl.h>
|
|
#include <stdint.h>
|
|
|
|
#include <rpcsvc/nis.h>
|
|
#include <shlib-compat.h>
|
|
|
|
static const char *
|
|
nis_nstype2str (const nstype type)
|
|
{
|
|
|
|
/* Name service names mustn't be translated, only UNKNOWN needs it */
|
|
|
|
switch (type)
|
|
{
|
|
case NIS:
|
|
return "NIS";
|
|
case SUNYP:
|
|
return "SUNYP";
|
|
case IVY:
|
|
return "IVY";
|
|
case DNS:
|
|
return "DNS";
|
|
case X500:
|
|
return "X500";
|
|
case DNANS:
|
|
return "DNANS";
|
|
case XCHS:
|
|
return "XCHS";
|
|
case CDS:
|
|
return "CDS";
|
|
default:
|
|
return N_("UNKNOWN");
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_ttl (const uint32_t ttl)
|
|
{
|
|
uint32_t time, s, m, h;
|
|
|
|
time = ttl;
|
|
|
|
h = time / (60 * 60);
|
|
time %= (60 * 60);
|
|
m = time / 60;
|
|
time %= 60;
|
|
s = time;
|
|
printf ("%u:%u:%u\n", h, m, s);
|
|
}
|
|
|
|
static void
|
|
print_flags (const unsigned int flags)
|
|
{
|
|
fputs ("(", stdout);
|
|
|
|
if (flags & TA_SEARCHABLE)
|
|
fputs ("SEARCHABLE, ", stdout);
|
|
|
|
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 unsigned int access)
|
|
{
|
|
char result[17];
|
|
unsigned int acc;
|
|
int i;
|
|
|
|
acc = access; /* Parameter is const ! */
|
|
result[i = 16] = '\0';
|
|
while (i > 0)
|
|
{
|
|
i -= 4;
|
|
result[i + 0] = (acc & NIS_READ_ACC) ? 'r' : '-';
|
|
result[i + 1] = (acc & NIS_MODIFY_ACC) ? 'm' : '-';
|
|
result[i + 2] = (acc & NIS_CREATE_ACC) ? 'c' : '-';
|
|
result[i + 3] = (acc & NIS_DESTROY_ACC) ? 'd' : '-';
|
|
|
|
acc >>= 8;
|
|
}
|
|
fputs (result, stdout);
|
|
}
|
|
libnsl_hidden_nolink_def (nis_print_rights, GLIBC_2_1)
|
|
|
|
void
|
|
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));
|
|
sptr = dir->do_servers.do_servers_val;
|
|
for (i = 0; i < dir->do_servers.do_servers_len; i++)
|
|
{
|
|
if (i == 0)
|
|
fputs (_("Master Server :\n"), stdout);
|
|
else
|
|
fputs (_("Replicate :\n"), stdout);
|
|
printf (_("\tName : %s\n"), sptr->name);
|
|
fputs (_("\tPublic Key : "), stdout);
|
|
switch (sptr->key_type)
|
|
{
|
|
case NIS_PK_NONE:
|
|
fputs (_("None.\n"), stdout);
|
|
break;
|
|
case NIS_PK_DH:
|
|
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 (%d bits)\n"), (sptr->pkey.n_len - 1) * 4);
|
|
break;
|
|
case NIS_PK_KERB:
|
|
fputs (_("Kerberos.\n"), stdout);
|
|
break;
|
|
default:
|
|
printf (_("Unknown (type = %d, bits = %d)\n"), sptr->key_type,
|
|
(sptr->pkey.n_len - 1) * 4);
|
|
break;
|
|
}
|
|
|
|
if (sptr->ep.ep_len != 0)
|
|
{
|
|
unsigned int j;
|
|
|
|
endpoint *ptr;
|
|
ptr = sptr->ep.ep_val;
|
|
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 && ptr->proto[0] != '\0')
|
|
printf ("%s, ", ptr->proto);
|
|
else
|
|
printf ("-, ");
|
|
if (ptr->family != NULL && ptr->family[0] != '\0')
|
|
printf ("%s, ", ptr->family);
|
|
else
|
|
printf ("-, ");
|
|
if (ptr->uaddr != NULL && ptr->uaddr[0] != '\0')
|
|
printf ("%s\n", ptr->uaddr);
|
|
else
|
|
fputs ("-\n", stdout);
|
|
ptr++;
|
|
}
|
|
}
|
|
sptr++;
|
|
}
|
|
|
|
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;
|
|
|
|
ptr = dir->do_armask.do_armask_val;
|
|
for (i = 0; i < dir->do_armask.do_armask_len; i++)
|
|
{
|
|
nis_print_rights (ptr->oa_rights);
|
|
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_nolink_def (nis_print_directory, GLIBC_2_1)
|
|
|
|
void
|
|
nis_print_group (const group_obj *obj)
|
|
{
|
|
unsigned int i;
|
|
|
|
fputs (_("Group Flags :"), stdout);
|
|
if (obj->gr_flags)
|
|
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_nolink_def (nis_print_group, GLIBC_2_1)
|
|
|
|
void
|
|
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);
|
|
fputs (_("Columns :\n"), stdout);
|
|
for (i = 0; i < obj->ta_cols.ta_cols_len; i++)
|
|
{
|
|
printf (_("\t[%d]\tName : %s\n"), i,
|
|
obj->ta_cols.ta_cols_val[i].tc_name);
|
|
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);
|
|
fputc ('\n', stdout);
|
|
}
|
|
}
|
|
libnsl_hidden_nolink_def (nis_print_table, GLIBC_2_1)
|
|
|
|
void
|
|
nis_print_link (const link_obj *obj)
|
|
{
|
|
fputs (_("Linked Object Type : "), stdout);
|
|
nis_print_objtype (obj->li_rtype);
|
|
printf (_("Linked to : %s\n"), obj->li_name);
|
|
/* XXX Print the attributes here, if they exists */
|
|
}
|
|
libnsl_hidden_nolink_def (nis_print_link, GLIBC_2_1)
|
|
|
|
void
|
|
nis_print_entry (const entry_obj *obj)
|
|
{
|
|
unsigned int i;
|
|
|
|
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,
|
|
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)
|
|
fputs (_("Encrypted data\n"), stdout);
|
|
else if ((obj->en_cols.en_cols_val[i].ec_flags & EN_BINARY) == EN_BINARY)
|
|
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",
|
|
(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_nolink_def (nis_print_entry, GLIBC_2_1)
|
|
|
|
void
|
|
nis_print_object (const nis_object * obj)
|
|
{
|
|
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 : "));
|
|
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 NIS_DIRECTORY_OBJ:
|
|
nis_print_directory (&obj->zo_data.objdata_u.di_data);
|
|
break;
|
|
case NIS_GROUP_OBJ:
|
|
nis_print_group (&obj->zo_data.objdata_u.gr_data);
|
|
break;
|
|
case NIS_TABLE_OBJ:
|
|
nis_print_table (&obj->zo_data.objdata_u.ta_data);
|
|
break;
|
|
case NIS_ENTRY_OBJ:
|
|
nis_print_entry (&obj->zo_data.objdata_u.en_data);
|
|
break;
|
|
case NIS_LINK_OBJ:
|
|
nis_print_link (&obj->zo_data.objdata_u.li_data);
|
|
break;
|
|
case NIS_PRIVATE_OBJ:
|
|
printf (_(" Data Length = %u\n"),
|
|
obj->zo_data.objdata_u.po_data.po_data_len);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
libnsl_hidden_nolink_def (nis_print_object, GLIBC_2_1)
|
|
|
|
void
|
|
nis_print_result (const nis_result *res)
|
|
{
|
|
unsigned int i;
|
|
|
|
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);
|
|
nis_print_object (&res->objects.objects_val[i]);
|
|
}
|
|
}
|
|
libnsl_hidden_nolink_def (nis_print_result, GLIBC_2_1)
|