[thirdparty/glibc.git] / nis / nis_print.c

/* Copyright (c) 1997 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 Library General Public License as
   published by the Free Software Foundation; either version 2 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include <time.h>
#include <rpcsvc/nis.h>
#include <rpcsvc/nislib.h>

static const char *
nis_nstype2str (const nstype type)
{
  switch (type)
    {
    case NIS:
      return N_("NIS");
    case SUNYP:
      return N_("SUNYP");
    case IVY:
      return N_("IVY");
    case DNS:
      return N_("DNS");
    case X500:
      return N_("X500");
    case DNANS:
      return N_("DNANS");
    case XCHS:
      return N_("XCHS");
    case CDS:
      return N_("CDS");
    default:
      return N_("UNKNOWN");
    }
}

static char *
nis_ttl2str (const u_long ttl)
{
  static char buf[64];
  unsigned long int time, s, m, h;

  time = ttl;

  h = time / (60 * 60);
  time %= (60 * 60);
  m = time / 60;
  time %= 60;
  s = time;
  snprintf (buf, 63, "%lu:%02lu:%02lu", h, m, s);

  return buf;
}

static char *
nis_flags2str (const u_long flags)
{
  static char buf[1024];

  snprintf (buf, 1023, "%lu", flags);

  return buf;
}

void
nis_print_rights (const u_long access)
{
  char result[17];
  u_long 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;
    }
  printf ("%s", result);
}

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"), gettext (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:
	  fputs (_("DH.\n"), stdout);
	  break;
	case NIS_PK_RSA:
	  fputs (_("RSA.\n"), stdout);
	  break;
	case NIS_PK_KERB:
	  fputs (_("Kerberous.\n"), stdout);
	  break;
	default:
	  fputs (_("Unknown.\n"), stdout);
	  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 && strlen (ptr->proto) > 0)
		printf ("%s, ", ptr->proto);
	      else
		printf ("-, ");
	      if (ptr->family != NULL && strlen (ptr->family) > 0)
		printf ("%s, ", ptr->family);
	      else
		printf ("-, ");
	      if (ptr->uaddr != NULL && strlen (ptr->uaddr) > 0)
		printf ("%s\n", ptr->uaddr);
	      else
		printf ("-\n");
	      ptr++;
	    }
	}
      sptr++;
    }

  printf (_("Time to live : %s\n"), nis_ttl2str (dir->do_ttl));
  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++)
	{
	  fputs (_("Default Access rights: "), stdout);
	  nis_print_rights (ptr->oa_rights);
	  printf (_("\nDirect Type : %d\n"), ptr->oa_otype);
	  ptr++;
	}
    }
}

void
nis_print_group (const group_obj *obj)
{
  unsigned int i;

  fputs (_("Group Flags :"), stdout);
  if (obj->gr_flags)
    printf ("0x%08lX", 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]);
}

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);
      printf (_("\t\tAttributes    : %s\n"),
	      nis_flags2str (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);
    }
}

void
nis_print_link (const link_obj *obj)
{
  printf (_("Type : %d\n"), obj->li_rtype);
  printf (_("Name : %s\n"), obj->li_name);
  printf (_("Attributes : %d\n"), obj->li_attrs.li_attrs_len);
}

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
	printf ("%s\n", obj->en_cols.en_cols_val[i].ec_value.ec_value_val);
    }
}

void
nis_print_object (const nis_object * obj)
{
  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  : %lu (seconds)\n"), obj->zo_ttl);
  printf (_("Creation Time : %s"), ctime (&obj->zo_oid.ctime));
  printf (_("Mod. Time     : %s"), ctime (&obj->zo_oid.mtime));
  fputs (_("Object Type   : "), stdout);
  switch (obj->zo_data.zo_type)
    {
    case BOGUS_OBJ:
      fputs (_("BOGUS OBJECT\n"), stdout);
      break;
    case NO_OBJ:
      fputs (_("NO OBJECT\n"), stdout);
      break;
    case DIRECTORY_OBJ:
      fputs (_("DIRECTORY\n"), stdout);
      nis_print_directory (&obj->zo_data.objdata_u.di_data);
      break;
    case GROUP_OBJ:
      fputs (_("GROUP\n"), stdout);
      nis_print_group (&obj->zo_data.objdata_u.gr_data);
      break;
    case TABLE_OBJ:
      fputs (_("TABLE\n"), stdout);
      nis_print_table (&obj->zo_data.objdata_u.ta_data);
      break;
    case ENTRY_OBJ:
      fputs (_("ENTRY\n"), stdout);
      nis_print_entry (&obj->zo_data.objdata_u.en_data);
      break;
    case LINK_OBJ:
      fputs (_("LINK\n"), stdout);
      nis_print_link (&obj->zo_data.objdata_u.li_data);
      break;
    case PRIVATE_OBJ:
      fputs (_("PRIVATE\n"), stdout);
      printf (_("    Data Length = %u\n"),
	      obj->zo_data.objdata_u.po_data.po_data_len);
      break;
    default:
      fputs (_("(Unknown object)\n"), stdout);
      break;
    }
}

void
nis_print_result (const nis_result *res)
{
  unsigned int i;

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