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 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * University Copyright- Copyright (c) 1982, 1986, 1988
32 * The Regents of the University of California
33 * All Rights Reserved
34 *
35 * University Acknowledgment- Portions of this document are derived from
36 * software developed by the University of California, Berkeley, and its
37 * contributors.
38 */
39
40 #pragma ident "%Z%%M% %I% %E% SMI"
41
42 #include "libcmdutils.h"
43
44
45 int
46 writefile(int fi, int fo, char *infile, char *outfile, char *asfile,
47 char *atfile, struct stat *s1p, struct stat *s2p)
48 {
49 int mapsize, munmapsize;
50 caddr_t cp;
51 off_t filesize = s1p->st_size;
52 off_t offset;
53 int nbytes;
54 int remains;
55 int n;
56 size_t src_size;
57 size_t targ_size;
58 char *srcbuf;
59 char *targbuf;
60
61 if (asfile != NULL) {
62 src_size = strlen(infile) + strlen(asfile) +
63 strlen(dgettext(TEXT_DOMAIN, " attribute ")) + 1;
64 } else {
65 src_size = strlen(infile) + 1;
66 }
67 srcbuf = malloc(src_size);
68 if (srcbuf == NULL) {
69 (void) fprintf(stderr,
70 dgettext(TEXT_DOMAIN, "could not allocate memory"
71 " for path buffer: "));
72 return (1);
73 }
74 if (asfile != NULL) {
75 (void) snprintf(srcbuf, src_size, "%s%s%s",
76 infile, dgettext(TEXT_DOMAIN, " attribute "), asfile);
77 } else {
78 (void) snprintf(srcbuf, src_size, "%s", infile);
79 }
80
81 if (atfile != NULL) {
82 targ_size = strlen(outfile) + strlen(atfile) +
83 strlen(dgettext(TEXT_DOMAIN, " attribute ")) + 1;
84 } else {
85 targ_size = strlen(outfile) + 1;
86 }
87 targbuf = malloc(targ_size);
88 if (targbuf == NULL) {
89 (void) fprintf(stderr,
90 dgettext(TEXT_DOMAIN, "could not allocate memory"
91 " for path buffer: "));
92 return (1);
93 }
94 if (atfile != NULL) {
95 (void) snprintf(targbuf, targ_size, "%s%s%s",
96 outfile, dgettext(TEXT_DOMAIN, " attribute "), atfile);
97 } else {
98 (void) snprintf(targbuf, targ_size, "%s", outfile);
99 }
100
101 if (ISREG(*s1p) && s1p->st_size > SMALLFILESIZE) {
102 /*
103 * Determine size of initial mapping. This will determine the
104 * size of the address space chunk we work with. This initial
105 * mapping size will be used to perform munmap() in the future.
106 */
107 mapsize = MAXMAPSIZE;
108 if (s1p->st_size < mapsize) mapsize = s1p->st_size;
109 munmapsize = mapsize;
110
111 /*
112 * Mmap time!
113 */
114 if ((cp = mmap((caddr_t)NULL, mapsize, PROT_READ,
115 MAP_SHARED, fi, (off_t)0)) == MAP_FAILED)
116 mapsize = 0; /* can't mmap today */
117 } else
118 mapsize = 0;
119
120 if (mapsize != 0) {
121 offset = 0;
122
123 for (;;) {
124 nbytes = write(fo, cp, mapsize);
125 /*
126 * if we write less than the mmaped size it's due to a
127 * media error on the input file or out of space on
128 * the output file. So, try again, and look for errno.
129 */
130 if ((nbytes >= 0) && (nbytes != (int)mapsize)) {
131 remains = mapsize - nbytes;
132 while (remains > 0) {
133 nbytes = write(fo,
134 cp + mapsize - remains, remains);
135 if (nbytes < 0) {
136 if (errno == ENOSPC)
137 perror(targbuf);
138 else
139 perror(srcbuf);
140 (void) close(fi);
141 (void) close(fo);
142 (void) munmap(cp, munmapsize);
143 if (ISREG(*s2p))
144 (void) unlink(targbuf);
145 return (1);
146 }
147 remains -= nbytes;
148 if (remains == 0)
149 nbytes = mapsize;
150 }
151 }
152 /*
153 * although the write manual page doesn't specify this
154 * as a possible errno, it is set when the nfs read
155 * via the mmap'ed file is accessed, so report the
156 * problem as a source access problem, not a target file
157 * problem
158 */
159 if (nbytes < 0) {
160 if (errno == EACCES)
161 perror(srcbuf);
162 else
163 perror(targbuf);
164 (void) close(fi);
165 (void) close(fo);
166 (void) munmap(cp, munmapsize);
167 if (ISREG(*s2p))
168 (void) unlink(targbuf);
169 if (srcbuf != NULL)
170 free(srcbuf);
171 if (targbuf != NULL)
172 free(targbuf);
173 return (1);
174 }
175 filesize -= nbytes;
176 if (filesize == 0)
177 break;
178 offset += nbytes;
179 if (filesize < mapsize)
180 mapsize = filesize;
181 if (mmap(cp, mapsize, PROT_READ, MAP_SHARED |
182 MAP_FIXED, fi, offset) == MAP_FAILED) {
183 perror(srcbuf);
184 (void) close(fi);
185 (void) close(fo);
186 (void) munmap(cp, munmapsize);
187 if (ISREG(*s2p))
188 (void) unlink(targbuf);
189 if (srcbuf != NULL)
190 free(srcbuf);
191 if (targbuf != NULL)
192 free(targbuf);
193 return (1);
194 }
195 }
196 (void) munmap(cp, munmapsize);
197 } else {
198 char buf[SMALLFILESIZE];
199 for (;;) {
200 n = read(fi, buf, sizeof (buf));
201 if (n == 0) {
202 return (0);
203 } else if (n < 0) {
204 (void) close(fi);
205 (void) close(fo);
206 if (ISREG(*s2p))
207 (void) unlink(targbuf);
208 if (srcbuf != NULL)
209 free(srcbuf);
210 if (targbuf != NULL)
211 free(targbuf);
212 return (1);
213 } else if (write(fo, buf, n) != n) {
214 (void) close(fi);
215 (void) close(fo);
216 if (ISREG(*s2p))
217 (void) unlink(targbuf);
218 if (srcbuf != NULL)
219 free(srcbuf);
220 if (targbuf != NULL)
221 free(targbuf);
222 return (1);
223 }
224 }
225 }
226 if (srcbuf != NULL)
227 free(srcbuf);
228 if (targbuf != NULL)
229 free(targbuf);
230 return (0);
231 }