1 /* Copyright (c) 1997-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 #include <time.h>
19 #include <string.h>
20 #include <libintl.h>
21 #include <stdint.h>
22
23 #include <rpcsvc/nis.h>
24 #include <shlib-compat.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 const char *
56 nis_objtype (const zotypes type)
57 {
58 switch (type)
59 {
60 case NIS_BOGUS_OBJ:
61 return _("BOGUS OBJECT");
62 case NIS_NO_OBJ:
63 return _("NO OBJECT");
64 case NIS_DIRECTORY_OBJ:
65 return _("DIRECTORY");
66 case NIS_GROUP_OBJ:
67 return _("GROUP");
68 case NIS_TABLE_OBJ:
69 return _("TABLE");
70 case NIS_ENTRY_OBJ:
71 return _("ENTRY");
72 case NIS_LINK_OBJ:
73 return _("LINK");
74 case NIS_PRIVATE_OBJ:
75 return _("PRIVATE\n");
76 default:
77 return _("(Unknown object");
78 }
79 }
80
81 static void
82 print_ttl (const uint32_t ttl)
83 {
84 uint32_t time, s, m, h;
85
86 time = ttl;
87
88 h = time / (60 * 60);
89 time %= (60 * 60);
90 m = time / 60;
91 time %= 60;
92 s = time;
93 printf ("%u:%u:%u\n", h, m, s);
94 }
95
96 static void
97 print_flags (const unsigned int flags)
98 {
99 fputs ("(", stdout);
100
101 if (flags & TA_SEARCHABLE)
102 fputs ("SEARCHABLE, ", stdout);
103
104 if (flags & TA_BINARY)
105 {
106 fputs ("BINARY DATA", stdout);
107 if (flags & TA_XDR)
108 fputs (", XDR ENCODED", stdout);
109 if (flags & TA_ASN1)
110 fputs (", ASN.1 ENCODED", stdout);
111 if (flags & TA_CRYPT)
112 fputs (", ENCRYPTED", stdout);
113 }
114 else
115 {
116 fputs ("TEXTUAL DATA", stdout);
117 if (flags & TA_SEARCHABLE)
118 {
119 if (flags & TA_CASE)
120 fputs (", CASE INSENSITIVE", stdout);
121 else
122 fputs (", CASE SENSITIVE", stdout);
123 }
124 }
125
126 fputs (")\n", stdout);
127 }
128
129 static void
130 nis_print_objtype (enum zotypes type)
131 {
132 printf ("%s\n", nis_objtype (type));
133 }
134
135 void
136 nis_print_rights (const unsigned int access)
137 {
138 char result[17];
139 unsigned int acc;
140 int i;
141
142 acc = access; /* Parameter is const ! */
143 result[i = 16] = '\0';
144 while (i > 0)
145 {
146 i -= 4;
147 result[i + 0] = (acc & NIS_READ_ACC) ? 'r' : '-';
148 result[i + 1] = (acc & NIS_MODIFY_ACC) ? 'm' : '-';
149 result[i + 2] = (acc & NIS_CREATE_ACC) ? 'c' : '-';
150 result[i + 3] = (acc & NIS_DESTROY_ACC) ? 'd' : '-';
151
152 acc >>= 8;
153 }
154 fputs (result, stdout);
155 }
156 libnsl_hidden_nolink_def (nis_print_rights, GLIBC_2_1)
157
158 void
159 nis_print_directory (const directory_obj *dir)
160 {
161 nis_server *sptr;
162 unsigned int i;
163
164 printf (_("Name : `%s'\n"), dir->do_name);
165 printf (_("Type : %s\n"), nis_nstype2str (dir->do_type));
166 sptr = dir->do_servers.do_servers_val;
167 for (i = 0; i < dir->do_servers.do_servers_len; i++)
168 {
169 if (i == 0)
170 fputs (_("Master Server :\n"), stdout);
171 else
172 fputs (_("Replicate :\n"), stdout);
173 printf (_("\tName : %s\n"), sptr->name);
174 fputs (_("\tPublic Key : "), stdout);
175 switch (sptr->key_type)
176 {
177 case NIS_PK_NONE:
178 fputs (_("None.\n"), stdout);
179 break;
180 case NIS_PK_DH:
181 printf (_("Diffie-Hellmann (%d bits)\n"),
182 (sptr->pkey.n_len - 1) * 4);
183 /* sptr->pkey.n_len counts the last 0, too */
184 break;
185 case NIS_PK_RSA:
186 printf (_("RSA (%d bits)\n"), (sptr->pkey.n_len - 1) * 4);
187 break;
188 case NIS_PK_KERB:
189 fputs (_("Kerberos.\n"), stdout);
190 break;
191 default:
192 printf (_("Unknown (type = %d, bits = %d)\n"), sptr->key_type,
193 (sptr->pkey.n_len - 1) * 4);
194 break;
195 }
196
197 if (sptr->ep.ep_len != 0)
198 {
199 unsigned int j;
200
201 endpoint *ptr;
202 ptr = sptr->ep.ep_val;
203 printf (_("\tUniversal addresses (%u)\n"), sptr->ep.ep_len);
204 for (j = 0; j < sptr->ep.ep_len; j++)
205 {
206 printf ("\t[%d] - ", j + 1);
207 if (ptr->proto != NULL && ptr->proto[0] != '\0')
208 printf ("%s, ", ptr->proto);
209 else
210 printf ("-, ");
211 if (ptr->family != NULL && ptr->family[0] != '\0')
212 printf ("%s, ", ptr->family);
213 else
214 printf ("-, ");
215 if (ptr->uaddr != NULL && ptr->uaddr[0] != '\0')
216 printf ("%s\n", ptr->uaddr);
217 else
218 fputs ("-\n", stdout);
219 ptr++;
220 }
221 }
222 sptr++;
223 }
224
225 fputs (_("Time to live : "), stdout);
226 print_ttl (dir->do_ttl);
227 fputs (_("Default Access rights :\n"), stdout);
228 if (dir->do_armask.do_armask_len != 0)
229 {
230 oar_mask *ptr;
231
232 ptr = dir->do_armask.do_armask_val;
233 for (i = 0; i < dir->do_armask.do_armask_len; i++)
234 {
235 nis_print_rights (ptr->oa_rights);
236 printf (_("\tType : %s\n"), nis_objtype (ptr->oa_otype));
237 fputs (_("\tAccess rights: "), stdout);
238 nis_print_rights (ptr->oa_rights);
239 fputs ("\n", stdout);
240 ptr++;
241 }
242 }
243 }
244 libnsl_hidden_nolink_def (nis_print_directory, GLIBC_2_1)
245
246 void
247 nis_print_group (const group_obj *obj)
248 {
249 unsigned int i;
250
251 fputs (_("Group Flags :"), stdout);
252 if (obj->gr_flags)
253 printf ("0x%08X", obj->gr_flags);
254 fputs (_("\nGroup Members :\n"), stdout);
255
256 for (i = 0; i < obj->gr_members.gr_members_len; i++)
257 printf ("\t%s\n", obj->gr_members.gr_members_val[i]);
258 }
259 libnsl_hidden_nolink_def (nis_print_group, GLIBC_2_1)
260
261 void
262 nis_print_table (const table_obj *obj)
263 {
264 unsigned int i;
265
266 printf (_("Table Type : %s\n"), obj->ta_type);
267 printf (_("Number of Columns : %d\n"), obj->ta_maxcol);
268 printf (_("Character Separator : %c\n"), obj->ta_sep);
269 printf (_("Search Path : %s\n"), obj->ta_path);
270 fputs (_("Columns :\n"), stdout);
271 for (i = 0; i < obj->ta_cols.ta_cols_len; i++)
272 {
273 printf (_("\t[%d]\tName : %s\n"), i,
274 obj->ta_cols.ta_cols_val[i].tc_name);
275 fputs (_("\t\tAttributes : "), stdout);
276 print_flags (obj->ta_cols.ta_cols_val[i].tc_flags);
277 fputs (_("\t\tAccess Rights : "), stdout);
278 nis_print_rights (obj->ta_cols.ta_cols_val[i].tc_rights);
279 fputc ('\n', stdout);
280 }
281 }
282 libnsl_hidden_nolink_def (nis_print_table, GLIBC_2_1)
283
284 void
285 nis_print_link (const link_obj *obj)
286 {
287 fputs (_("Linked Object Type : "), stdout);
288 nis_print_objtype (obj->li_rtype);
289 printf (_("Linked to : %s\n"), obj->li_name);
290 /* XXX Print the attributes here, if they exists */
291 }
292 libnsl_hidden_nolink_def (nis_print_link, GLIBC_2_1)
293
294 void
295 nis_print_entry (const entry_obj *obj)
296 {
297 unsigned int i;
298
299 printf (_("\tEntry data of type %s\n"), obj->en_type);
300 for (i = 0; i < obj->en_cols.en_cols_len; i++)
301 {
302 printf (_("\t[%u] - [%u bytes] "), i,
303 obj->en_cols.en_cols_val[i].ec_value.ec_value_len);
304 if ((obj->en_cols.en_cols_val[i].ec_flags & EN_CRYPT) == EN_CRYPT)
305 fputs (_("Encrypted data\n"), stdout);
306 else if ((obj->en_cols.en_cols_val[i].ec_flags & EN_BINARY) == EN_BINARY)
307 fputs (_("Binary data\n"), stdout);
308 else if (obj->en_cols.en_cols_val[i].ec_value.ec_value_len == 0)
309 fputs ("'(nil)'\n", stdout);
310 else
311 printf ("'%.*s'\n",
312 (int)obj->en_cols.en_cols_val[i].ec_value.ec_value_len,
313 obj->en_cols.en_cols_val[i].ec_value.ec_value_val);
314 }
315 }
316 libnsl_hidden_nolink_def (nis_print_entry, GLIBC_2_1)
317
318 void
319 nis_print_object (const nis_object * obj)
320 {
321 time_t buf;
322
323 printf (_("Object Name : %s\n"), obj->zo_name);
324 printf (_("Directory : %s\n"), obj->zo_domain);
325 printf (_("Owner : %s\n"), obj->zo_owner);
326 printf (_("Group : %s\n"), obj->zo_group);
327 fputs (_("Access Rights : "), stdout);
328 nis_print_rights (obj->zo_access);
329 printf (_("\nTime to Live : "));
330 print_ttl (obj->zo_ttl);
331 buf = obj->zo_oid.ctime;
332 printf (_("Creation Time : %s"), ctime (&buf));
333 buf = obj->zo_oid.mtime;
334 printf (_("Mod. Time : %s"), ctime (&buf));
335 fputs (_("Object Type : "), stdout);
336 nis_print_objtype (obj->zo_data.zo_type);
337 switch (obj->zo_data.zo_type)
338 {
339 case NIS_DIRECTORY_OBJ:
340 nis_print_directory (&obj->zo_data.objdata_u.di_data);
341 break;
342 case NIS_GROUP_OBJ:
343 nis_print_group (&obj->zo_data.objdata_u.gr_data);
344 break;
345 case NIS_TABLE_OBJ:
346 nis_print_table (&obj->zo_data.objdata_u.ta_data);
347 break;
348 case NIS_ENTRY_OBJ:
349 nis_print_entry (&obj->zo_data.objdata_u.en_data);
350 break;
351 case NIS_LINK_OBJ:
352 nis_print_link (&obj->zo_data.objdata_u.li_data);
353 break;
354 case NIS_PRIVATE_OBJ:
355 printf (_(" Data Length = %u\n"),
356 obj->zo_data.objdata_u.po_data.po_data_len);
357 break;
358 default:
359 break;
360 }
361 }
362 libnsl_hidden_nolink_def (nis_print_object, GLIBC_2_1)
363
364 void
365 nis_print_result (const nis_result *res)
366 {
367 unsigned int i;
368
369 printf (_("Status : %s\n"), nis_sperrno (NIS_RES_STATUS (res)));
370 printf (_("Number of objects : %u\n"), res->objects.objects_len);
371
372 for (i = 0; i < res->objects.objects_len; i++)
373 {
374 printf (_("Object #%d:\n"), i);
375 nis_print_object (&res->objects.objects_val[i]);
376 }
377 }
378 libnsl_hidden_nolink_def (nis_print_result, GLIBC_2_1)