typo
[kopensolaris-gnu/glibc.git] / nis / nis_print.c
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 }