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