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