1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2021 Oxide Computer Company
24 */
25
26 /*
27 * Copyright (c) 1988 AT&T
28 * All Rights Reserved
29 *
30 */
31
32 /*
33 * Incompatible Archive Header
34 *
35 * The archive file member header used in SunOS 4.1 archive files and
36 * Solaris archive files are incompatible. The header file is:
37 * /usr/include/ar.h, struct ar_hdr.
38 * The member ar_name[] in Solaris comforms with Standard and the
39 * member name terminates with '/'. The SunOS's member does not terminate
40 * with '/' character. A bug 4046054 was filed:
41 * The ar command in Solaris 2.5.1 is incompatible with archives
42 * created on 4.x.
43 *
44 * To handle archive files created in SunOS 4.1 system on Solaris, the
45 * following changes were made:
46 *
47 * 1. file.c/writefile()
48 * Before writing each member files into the output
49 * archive file, ar_name[] is checked. If it is NULL,
50 * it means that the original archive header for this
51 * member was incompatible with Solaris format.
52 *
53 * The original Solaris ar command ended up having
54 * NULL name for the header. The change here uses the
55 * ar_rawname, which is much closer to the original
56 * name.
57 *
58 * 2. cmd.c
59 * For the p command, the code used to use only ar_longname
60 * to seach the matching name. The member is set to NULL
61 * if the archive member header was incompatible.
62 * The ar_rawname is also used to find the matching member name.
63 *
64 * For commands to update the archive file, we do not
65 * use ar_rawname, and just use the ar_longname. The commands are
66 * r (replace), m (modify the position) and d (delete).
67 */
68
69 #include "inc.h"
70
71 /*
72 * Forward Declarations
73 */
74 static void ar_select(int *, unsigned long);
75 static void cleanup(Cmd_info *);
76 static int create_extract(ARFILE *, int, int, Cmd_info *);
77 static char *match(char *, Cmd_info *);
78 static void mesg(int, char *, Cmd_info *);
79 static void movefil(ARFILE *, struct stat *);
80 static FILE *stats(char *, struct stat *);
81
82 /*
83 * Commands
84 */
85 void
rcmd(Cmd_info * cmd_info)86 rcmd(Cmd_info *cmd_info)
87 {
88 FILE *f;
89 ARFILE *fileptr;
90 ARFILE *abifile = NULL;
91 ARFILE *backptr = NULL;
92 ARFILE *endptr;
93 ARFILE *moved_files;
94 ARFILE *prev_entry, *new_listhead, *new_listend;
95 int deleted;
96 struct stat stbuf;
97 char *gfile;
98
99 new_listhead = NULL;
100 new_listend = NULL;
101 prev_entry = NULL;
102
103 for (fileptr = getfile(cmd_info);
104 fileptr; fileptr = getfile(cmd_info)) {
105 deleted = 0;
106 if (!abifile && cmd_info->ponam &&
107 strcmp(fileptr->ar_longname, cmd_info->ponam) == 0)
108 abifile = fileptr;
109 else if (!abifile)
110 backptr = fileptr;
111
112 if (cmd_info->namc == 0 ||
113 (gfile = match(fileptr->ar_longname, cmd_info)) != NULL) {
114 /*
115 * NOTE:
116 * Refer to "Incompatible Archive Header"
117 * blocked comment at the beginning of this file.
118 */
119 f = stats(gfile, &stbuf); /* gfile is set by match */
120 if (f == NULL) {
121 if (cmd_info->namc) {
122 int err = errno;
123 (void) fprintf(stderr,
124 MSG_INTL(MSG_SYS_OPEN),
125 gfile, strerror(err));
126 }
127 /*
128 * Created
129 */
130 mesg('c', gfile, cmd_info);
131 } else {
132 if ((cmd_info->opt_flgs & u_FLAG) &&
133 stbuf.st_mtime <= fileptr->ar_date) {
134 (void) fclose(f);
135 continue;
136 }
137 /*
138 * Replaced
139 */
140 mesg('r', fileptr->ar_longname, cmd_info);
141 movefil(fileptr, &stbuf);
142 /*
143 * Clear the previous contents.
144 */
145 if (fileptr->ar_flag & F_ELFRAW) {
146 /*
147 * clear ar_elf
148 */
149 (void) elf_end(fileptr->ar_elf);
150 fileptr->ar_elf = 0;
151 }
152 /* clear 'ar_flag' */
153 fileptr->ar_flag &= ~F_ELFRAW;
154
155 /*
156 * Defer reading contents until needed, and
157 * then use an in-kernel file-to-file transfer
158 * to avoid excessive in-process memory use.
159 */
160 fileptr->ar_contents = NULL;
161
162 if (fileptr->ar_pathname != NULL)
163 free(fileptr->ar_pathname);
164 if ((fileptr->ar_pathname =
165 malloc(strlen(gfile) + 1)) == NULL) {
166 int err = errno;
167 (void) fprintf(stderr,
168 MSG_INTL(MSG_MALLOC),
169 strerror(err));
170 exit(1);
171 }
172
173 (void) strcpy(fileptr->ar_pathname, gfile);
174 (void) fclose(f);
175
176 if (cmd_info->ponam && (abifile != fileptr)) {
177 deleted = 1;
178 /* remove from archive list */
179 if (prev_entry != NULL)
180 prev_entry->ar_next = NULL;
181 else
182 listhead = NULL;
183 listend = prev_entry;
184
185 /* add to moved list */
186 if (new_listhead == NULL)
187 new_listhead = fileptr;
188 else
189 new_listend->ar_next = fileptr;
190 new_listend = fileptr;
191 }
192 cmd_info->modified++;
193 }
194 }
195 else
196 /*
197 * Unchaged
198 */
199 mesg('u', fileptr->ar_longname, cmd_info);
200
201 if (deleted)
202 deleted = 0;
203 else
204 prev_entry = fileptr;
205 }
206
207 endptr = listend;
208 cleanup(cmd_info);
209 if (cmd_info->ponam && endptr &&
210 (((moved_files = endptr->ar_next) != NULL) || new_listhead)) {
211 if (!abifile) {
212 (void) fprintf(stderr, MSG_INTL(MSG_NOT_FOUND_POSNAM),
213 cmd_info->ponam);
214 exit(2);
215 }
216 endptr->ar_next = NULL;
217
218 /*
219 * link new/moved files into archive entry list...
220 * 1: prepend newlist to moved/appended list
221 */
222 if (new_listhead) {
223 if (!moved_files)
224 listend = new_listend;
225 new_listend->ar_next = moved_files;
226 moved_files = new_listhead;
227 }
228 /* 2: insert at appropriate position... */
229 if (cmd_info->opt_flgs & b_FLAG)
230 abifile = backptr;
231 if (abifile) {
232 listend->ar_next = abifile->ar_next;
233 abifile->ar_next = moved_files;
234 } else {
235 listend->ar_next = listhead;
236 listhead = moved_files;
237 }
238 listend = endptr;
239 } else if (cmd_info->ponam && !abifile)
240 (void) fprintf(stderr, MSG_INTL(MSG_NOT_FOUND_POSNAM),
241 cmd_info->ponam);
242 }
243
244 void
dcmd(Cmd_info * cmd_info)245 dcmd(Cmd_info *cmd_info)
246 {
247 ARFILE *fptr;
248 ARFILE *backptr = NULL;
249
250 for (fptr = getfile(cmd_info); fptr; fptr = getfile(cmd_info)) {
251 if (match(fptr->ar_longname, cmd_info) != NULL) {
252 /*
253 * NOTE:
254 * Refer to "Incompatible Archive Header"
255 * blocked comment at the beginning of this file.
256 */
257
258 /*
259 * Deleted
260 */
261 mesg('d', fptr->ar_longname, cmd_info);
262 if (backptr == NULL) {
263 listhead = NULL;
264 listend = NULL;
265 } else {
266 backptr->ar_next = NULL;
267 listend = backptr;
268 }
269 cmd_info->modified = 1;
270 } else {
271 /*
272 * Unchaged
273 */
274 mesg('u', fptr->ar_longname, cmd_info);
275 backptr = fptr;
276 }
277 }
278 }
279
280 void
xcmd(Cmd_info * cmd_info)281 xcmd(Cmd_info *cmd_info)
282 {
283 int f;
284 ARFILE *next;
285 int rawname = 0;
286 long f_len = 0;
287
288 /*
289 * If -T is specified, get the maximum file name length.
290 */
291 if (cmd_info->opt_flgs & T_FLAG) {
292 f_len = pathconf(MSG_ORIG(MSG_STR_PERIOD), _PC_NAME_MAX);
293 if (f_len == -1) {
294 int err = errno;
295 (void) fprintf(stderr, MSG_INTL(MSG_PATHCONF),
296 strerror(err));
297 exit(1);
298 }
299 }
300 for (next = getfile(cmd_info); next; next = getfile(cmd_info)) {
301 if ((next->ar_longname[0] == 0) && (next->ar_rawname[0] != 0))
302 rawname = 1;
303 if (cmd_info->namc == 0 ||
304 match(next->ar_longname, cmd_info) != NULL ||
305 match(next->ar_rawname, cmd_info) != NULL) {
306 /*
307 * NOTE:
308 * Refer to "Incompatible Archive Header"
309 * blocked comment at the beginning of this file.
310 */
311 f = create_extract(next, rawname, f_len, cmd_info);
312 if (f >= 0) {
313 if (rawname) {
314 /*
315 * eXtracted
316 */
317 mesg('x', next->ar_rawname, cmd_info);
318 if (write(f, next->ar_contents,
319 (unsigned)next->ar_size) !=
320 next->ar_size) {
321 int err = errno;
322 (void) fprintf(stderr,
323 MSG_INTL(MSG_SYS_WRITE),
324 next->ar_rawname,
325 strerror(err));
326 exit(1);
327 }
328 } else {
329 /*
330 * eXtracted
331 */
332 mesg('x', next->ar_longname, cmd_info);
333 if (write(f, next->ar_contents,
334 (unsigned)next->ar_size) !=
335 next->ar_size) {
336 int err = errno;
337 (void) fprintf(stderr,
338 MSG_INTL(MSG_SYS_WRITE),
339 next->ar_longname,
340 strerror(err));
341 exit(1);
342 }
343 }
344 (void) close(f);
345 } else
346 exit(1);
347 }
348 rawname = 0;
349 } /* for */
350 }
351
352 void
pcmd(Cmd_info * cmd_info)353 pcmd(Cmd_info *cmd_info)
354 {
355 ARFILE *next;
356
357 for (next = getfile(cmd_info); next; next = getfile(cmd_info)) {
358 if (cmd_info->namc == 0 ||
359 match(next->ar_longname, cmd_info) != NULL ||
360 match(next->ar_rawname, cmd_info) != NULL) {
361 /*
362 * NOTE:
363 * Refer to "Incompatible Archive Header"
364 * blocked comment at the beginning of this file.
365 */
366 if (cmd_info->opt_flgs & v_FLAG) {
367 (void) fprintf(stdout,
368 MSG_ORIG(MSG_FMT_P_TITLE),
369 next->ar_longname);
370 (void) fflush(stdout);
371 }
372 (void) fwrite(next->ar_contents, sizeof (char),
373 next->ar_size, stdout);
374 }
375 }
376 }
377
378 void
mcmd(Cmd_info * cmd_info)379 mcmd(Cmd_info *cmd_info)
380 {
381 ARFILE *fileptr;
382 ARFILE *abifile = NULL;
383 ARFILE *tmphead = NULL;
384 ARFILE *tmpend = NULL;
385 ARFILE *backptr1 = NULL;
386 ARFILE *backptr2 = NULL;
387
388 for (fileptr = getfile(cmd_info);
389 fileptr; fileptr = getfile(cmd_info)) {
390 if (match(fileptr->ar_longname, cmd_info) != NULL) {
391 /*
392 * position Modified
393 */
394 mesg('m', fileptr->ar_longname, cmd_info);
395 if (tmphead)
396 tmpend->ar_next = fileptr;
397 else
398 tmphead = fileptr;
399 tmpend = fileptr;
400 if (backptr1) {
401 listend = backptr1;
402 listend->ar_next = NULL;
403 }
404 else
405 listhead = NULL;
406 continue;
407 }
408 /*
409 * position Unchaged
410 */
411 mesg('u', fileptr->ar_longname, cmd_info);
412 backptr1 = fileptr;
413 if (cmd_info->ponam && !abifile) {
414 if (strcmp(fileptr->ar_longname, cmd_info->ponam) == 0)
415 abifile = fileptr;
416 else
417 backptr2 = fileptr;
418 }
419 }
420
421 if (!tmphead)
422 return;
423
424 if (!cmd_info->ponam)
425 listend->ar_next = tmphead;
426 else {
427 if (!abifile) {
428 (void) fprintf(stderr, MSG_INTL(MSG_NOT_FOUND_POSNAM),
429 cmd_info->ponam);
430 exit(2);
431 }
432 if (cmd_info->opt_flgs & b_FLAG)
433 abifile = backptr2;
434 if (abifile) {
435 tmpend->ar_next = abifile->ar_next;
436 abifile->ar_next = tmphead;
437 } else {
438 tmphead->ar_next = listhead;
439 listhead = tmphead;
440 }
441 }
442 (cmd_info->modified)++;
443 }
444
445 void
tcmd(Cmd_info * cmd_info)446 tcmd(Cmd_info *cmd_info)
447 {
448 ARFILE *next;
449 int **mp;
450 char buf[DATESIZE];
451 int m1[] = {1, S_IRUSR, 'r', '-'};
452 int m2[] = {1, S_IWUSR, 'w', '-'};
453 int m3[] = {2, S_ISUID, 's', S_IXUSR, 'x', '-'};
454 int m4[] = {1, S_IRGRP, 'r', '-'};
455 int m5[] = {1, S_IWGRP, 'w', '-'};
456 int m6[] = {2, S_ISGID, 's', S_IXGRP, 'x', '-'};
457 int m7[] = {1, S_IROTH, 'r', '-'};
458 int m8[] = {1, S_IWOTH, 'w', '-'};
459 int m9[] = {2, S_ISVTX, 't', S_IXOTH, 'x', '-'};
460 int *m[10];
461
462 m[0] = m1;
463 m[1] = m2;
464 m[2] = m3;
465 m[3] = m4;
466 m[4] = m5;
467 m[5] = m6;
468 m[6] = m7;
469 m[7] = m8;
470 m[8] = m9;
471 m[9] = 0;
472
473 for (next = getfile(cmd_info); next; next = getfile(cmd_info)) {
474 if (cmd_info->namc == 0 ||
475 match(next->ar_longname, cmd_info) != NULL ||
476 match(next->ar_rawname, cmd_info) != NULL) {
477 /*
478 * NOTE:
479 * Refer to "Incompatible Archive Header"
480 * blocked comment at the beginning of this file.
481 */
482 if ((cmd_info->opt_flgs & (t_FLAG | v_FLAG)) ==
483 (t_FLAG | v_FLAG)) {
484 for (mp = &m[0]; mp < &m[9]; )
485 ar_select(*mp++, next->ar_mode);
486
487 (void) fprintf(stdout, MSG_ORIG(MSG_FMT_T_IDSZ),
488 next->ar_uid, next->ar_gid,
489 EC_XWORD(next->ar_size));
490 if ((strftime(buf,
491 DATESIZE, MSG_ORIG(MSG_FMT_T_DATE),
492 localtime(&(next->ar_date)))) == 0) {
493 (void) fprintf(stderr,
494 MSG_INTL(MSG_LOCALTIME));
495 exit(1);
496 }
497 (void) fprintf(stdout,
498 MSG_ORIG(MSG_FMT_SPSTRSP), buf);
499 }
500 if (cmd_info->opt_flgs & t_FLAG) {
501 if ((next->ar_longname[0] == 0) &&
502 (next->ar_rawname[0] != 0)) {
503 (void) fprintf(stdout,
504 MSG_ORIG(MSG_FMT_STRNL),
505 trim(next->ar_rawname));
506 } else {
507 (void) fprintf(stdout,
508 MSG_ORIG(MSG_FMT_STRNL),
509 trim(next->ar_longname));
510 }
511 }
512 }
513 }
514 }
515
516 void
qcmd(Cmd_info * cmd_info)517 qcmd(Cmd_info *cmd_info)
518 {
519 ARFILE *fptr;
520
521 if (cmd_info->opt_flgs & (a_FLAG | b_FLAG)) {
522 (void) fprintf(stderr, MSG_INTL(MSG_USAGE_Q_BAD_ARG));
523 exit(1);
524 }
525 for (fptr = getfile(cmd_info); fptr; fptr = getfile(cmd_info))
526 ;
527 cleanup(cmd_info);
528 }
529
530 /*
531 * Supplementary functions
532 */
533 static char *
match(char * file,Cmd_info * cmd_info)534 match(char *file, Cmd_info *cmd_info)
535 {
536 int i;
537
538 for (i = 0; i < cmd_info->namc; i++) {
539 if (cmd_info->namv[i] == 0)
540 continue;
541 if (strcmp(trim(cmd_info->namv[i]), file) == 0) {
542 file = cmd_info->namv[i];
543 cmd_info->namv[i] = 0;
544 return (file);
545 }
546 }
547 return (NULL);
548 }
549
550 /*
551 * puts the file which was in the list in the linked list
552 */
553 static void
cleanup(Cmd_info * cmd_info)554 cleanup(Cmd_info *cmd_info)
555 {
556 int i;
557 FILE *f;
558 ARFILE *fileptr;
559 struct stat stbuf;
560
561 for (i = 0; i < cmd_info->namc; i++) {
562 if (cmd_info->namv[i] == 0)
563 continue;
564 /*
565 * Appended
566 */
567 mesg('a', cmd_info->namv[i], cmd_info);
568 f = stats(cmd_info->namv[i], &stbuf);
569 if (f == NULL) {
570 int err = errno;
571 (void) fprintf(stderr, MSG_INTL(MSG_SYS_OPEN),
572 cmd_info->namv[i], strerror(err));
573 } else {
574 fileptr = newfile();
575 /* if short name */
576 (void) strncpy(fileptr->ar_name,
577 trim(cmd_info->namv[i]), SNAME);
578
579 if ((fileptr->ar_longname =
580 malloc(strlen(trim(cmd_info->namv[i])) + 1)) ==
581 NULL) {
582 int err = errno;
583 (void) fprintf(stderr, MSG_INTL(MSG_MALLOC),
584 strerror(err));
585 exit(1);
586 }
587
588 (void) strcpy(fileptr->ar_longname,
589 trim(cmd_info->namv[i]));
590
591 if ((fileptr->ar_pathname =
592 malloc(strlen(cmd_info->namv[i]) + 1)) == NULL) {
593 int err = errno;
594 (void) fprintf(stderr, MSG_INTL(MSG_MALLOC),
595 strerror(err));
596 exit(1);
597 }
598
599 (void) strcpy(fileptr->ar_pathname, cmd_info->namv[i]);
600
601 movefil(fileptr, &stbuf);
602
603 /* clear 'ar_flag' */
604 fileptr->ar_flag &= ~F_ELFRAW;
605
606 /*
607 * Defer reading contents until needed, and then use
608 * an in-kernel file-to-file transfer to avoid
609 * excessive in-process memory use.
610 */
611 fileptr->ar_contents = NULL;
612
613 (void) fclose(f);
614 (cmd_info->modified)++;
615 cmd_info->namv[i] = 0;
616 }
617 }
618 }
619
620 /*
621 * insert the file 'file' into the temporary file
622 */
623 static void
movefil(ARFILE * fileptr,struct stat * stbuf)624 movefil(ARFILE *fileptr, struct stat *stbuf)
625 {
626 fileptr->ar_size = stbuf->st_size;
627 fileptr->ar_date = stbuf->st_mtime;
628 fileptr->ar_mode = stbuf->st_mode;
629
630 /*
631 * The format of an 'ar' file includes a 6 character
632 * decimal string to contain the uid.
633 *
634 * If the uid or gid is too big to fit, then set it to
635 * nobody (for want of a better value). Clear the
636 * setuid/setgid bits in the mode to avoid setuid nobody
637 * or setgid nobody files unexpectedly coming into existence.
638 */
639 if ((fileptr->ar_uid = stbuf->st_uid) > 999999) {
640 fileptr->ar_uid = UID_NOBODY;
641 if (S_ISREG(fileptr->ar_mode))
642 fileptr->ar_mode &= ~S_ISUID;
643 }
644 if ((fileptr->ar_gid = stbuf->st_gid) > 999999) {
645 fileptr->ar_gid = GID_NOBODY;
646 if (S_ISREG(fileptr->ar_mode))
647 fileptr->ar_mode &= ~S_ISGID;
648 }
649 }
650
651 static FILE *
stats(char * file,struct stat * stbuf)652 stats(char *file, struct stat *stbuf)
653 {
654 FILE *f;
655
656 f = fopen(file, MSG_ORIG(MSG_STR_LCR));
657 if (f == NULL)
658 return (f);
659 if (stat(file, stbuf) < 0) {
660 (void) fclose(f);
661 return (NULL);
662 }
663 return (f);
664 }
665
666 /*
667 * Used by xcmd()
668 */
669 int
create_extract(ARFILE * a,int rawname,int f_len,Cmd_info * cmd_info)670 create_extract(ARFILE *a, int rawname, int f_len, Cmd_info *cmd_info)
671 {
672
673 int f;
674 char *f_name;
675 char *dup = NULL;
676 if (rawname)
677 f_name = a->ar_rawname;
678 else
679 f_name = a->ar_longname;
680
681 /*
682 * If -T is specified, check the file length.
683 */
684 if (cmd_info->opt_flgs & T_FLAG) {
685 int len;
686 len = strlen(f_name);
687 if (f_len <= len) {
688 dup = malloc(f_len+1);
689 if (dup == NULL) {
690 int err = errno;
691 (void) fprintf(stderr, MSG_INTL(MSG_MALLOC),
692 strerror(err));
693 exit(1);
694 }
695 (void) strncpy(dup, f_name, f_len);
696 }
697 f_name = dup;
698 }
699
700 /*
701 * Bug 4052067 - If a file to be extracted has the same
702 * filename as the archive, the archive gets overwritten
703 * which can lead to a corrupted archive or worse, a ufs
704 * deadlock because libelf has mmap'ed the archive! We
705 * can't rely on strcmp() to test for this case because
706 * the archive could be prefixed with a partial or full
707 * path (and we could be using the rawname from the archive)
708 * This means we have to do the same thing we did for mv,
709 * which is to explicitly check if the file we would extract
710 * to is identical to the archive. Because part of this
711 * test is essentially what the -C flag does, I've merged
712 * the code together.
713 */
714 if (access(f_name, F_OK) != -1) {
715 struct stat s1, s2;
716
717 /*
718 * If -C is specified, this is an error anyway
719 */
720 if (cmd_info->opt_flgs & C_FLAG) {
721 (void) fprintf(stderr, MSG_INTL(MSG_OVERRIDE_WARN),
722 f_name);
723 if (dup != NULL)
724 free(dup);
725 return (-1);
726 }
727
728 /*
729 * Okay, -C wasn't specified. However, now we do
730 * the check to see if the archive would be overwritten
731 * by extracting this file. stat() both objects and
732 * test to see if their identical.
733 */
734 if ((stat(f_name, &s1) == 0) &&
735 (stat(cmd_info->arnam, &s2) == 0)) {
736
737 if ((s1.st_dev == s2.st_dev) &&
738 (s1.st_ino == s2.st_ino)) {
739
740 (void) fprintf(stderr,
741 MSG_INTL(MSG_OVERRIDE_WARN), f_name);
742 if (dup != NULL)
743 free(dup);
744 return (-1);
745 }
746 }
747 }
748
749 /*
750 * Okay to create extraction file...
751 */
752 f = creat(f_name, (mode_t)a->ar_mode & 0777);
753 if (f < 0) {
754 int err = errno;
755 (void) fprintf(stderr, MSG_INTL(MSG_SYS_OPEN), f_name,
756 strerror(err));
757 /*
758 * Created
759 */
760 mesg('c', f_name, cmd_info);
761 }
762 if (dup)
763 free(dup);
764 return (f);
765 }
766
767 static void
mesg(int c,char * file,Cmd_info * cmd_info)768 mesg(int c, char *file, Cmd_info *cmd_info)
769 {
770 #ifdef XPG4
771 /*
772 * XPG4 does not have any message defined for
773 * 'c' operation.
774 * In fact, XPG only defines messages for
775 * d, r, a and x at the present. (03/05/'96)
776 */
777 if (c == 'c' || c == 'u' || c == 'm')
778 return;
779 #endif
780 /*
781 * If 'u' is passed, convert it to 'c'.
782 * 'u' makes more sense since the operation did not
783 * do anything, Unchanged, but 'c' has been used so
784 * I do no want to break the compatibility at this moment.
785 * (03/05/'96).
786 */
787 if (c == 'u')
788 c = 'c';
789 if (cmd_info->opt_flgs & v_FLAG)
790 if (c != 'c')
791 (void) fprintf(stdout, MSG_ORIG(MSG_FMT_FILE), c, file);
792 }
793
794 static void
ar_select(int * pairp,unsigned long mode)795 ar_select(int *pairp, unsigned long mode)
796 {
797 int n, *ap;
798
799 ap = pairp;
800 n = *ap++;
801 while (--n >= 0 && (mode & *ap++) == 0)
802 ap++;
803 (void) putchar(*ap);
804 }
805