Synchronous libarchive to 2.2.4 from FreeBSD, including fixes related to
[dragonfly.git] / contrib / libarchive-2 / libarchive / archive_write_set_format_cpio_newc.c
1 /*-
2  * Copyright (c) 2003-2007 Tim Kientzle
3  * Copyright (c) 2006 Rudolf Marek SYSGO s.r.o.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "archive_platform.h"
28 __FBSDID("$FreeBSD: src/lib/libarchive/archive_write_set_format_cpio_newc.c,v 1.1 2007/06/22 05:47:00 kientzle Exp $");
29
30 #ifdef HAVE_ERRNO_H
31 #include <errno.h>
32 #endif
33 #include <stdio.h>
34 #ifdef HAVE_STDLIB_H
35 #include <stdlib.h>
36 #endif
37 #ifdef HAVE_STRING_H
38 #include <string.h>
39 #endif
40
41 #include "archive.h"
42 #include "archive_entry.h"
43 #include "archive_private.h"
44 #include "archive_write_private.h"
45
46 static ssize_t  archive_write_newc_data(struct archive_write *,
47                     const void *buff, size_t s);
48 static int      archive_write_newc_finish(struct archive_write *);
49 static int      archive_write_newc_destroy(struct archive_write *);
50 static int      archive_write_newc_finish_entry(struct archive_write *);
51 static int      archive_write_newc_header(struct archive_write *,
52                     struct archive_entry *);
53 static int      format_hex(int64_t, void *, int);
54 static int64_t  format_hex_recursive(int64_t, char *, int);
55
56 struct cpio {
57         uint64_t          entry_bytes_remaining;
58         int               padding;
59 };
60
61 struct cpio_header_newc {
62         char    c_magic[6];
63         char    c_ino[8];
64         char    c_mode[8];
65         char    c_uid[8];
66         char    c_gid[8];
67         char    c_nlink[8];
68         char    c_mtime[8];
69         char    c_filesize[8];
70         char    c_devmajor[8];
71         char    c_devminor[8];
72         char    c_rdevmajor[8];
73         char    c_rdevminor[8];
74         char    c_namesize[8];
75         char    c_checksum[8];
76 };
77
78 /*
79  * Set output format to 'cpio' format.
80  */
81 int
82 archive_write_set_format_cpio_newc(struct archive *_a)
83 {
84         struct archive_write *a = (struct archive_write *)_a;
85         struct cpio *cpio;
86
87         /* If someone else was already registered, unregister them. */
88         if (a->format_destroy != NULL)
89                 (a->format_destroy)(a);
90
91         cpio = (struct cpio *)malloc(sizeof(*cpio));
92         if (cpio == NULL) {
93                 archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
94                 return (ARCHIVE_FATAL);
95         }
96         memset(cpio, 0, sizeof(*cpio));
97         a->format_data = cpio;
98
99         a->pad_uncompressed = 1;
100         a->format_write_header = archive_write_newc_header;
101         a->format_write_data = archive_write_newc_data;
102         a->format_finish_entry = archive_write_newc_finish_entry;
103         a->format_finish = archive_write_newc_finish;
104         a->format_destroy = archive_write_newc_destroy;
105         a->archive_format = ARCHIVE_FORMAT_CPIO_SVR4_NOCRC;
106         a->archive_format_name = "SVR4 cpio nocrc";
107         return (ARCHIVE_OK);
108 }
109
110 static int
111 archive_write_newc_header(struct archive_write *a, struct archive_entry *entry)
112 {
113         struct cpio *cpio;
114         const char *p, *path;
115         int pathlength, ret;
116         struct cpio_header_newc  h;
117         int pad;
118
119         cpio = (struct cpio *)a->format_data;
120         ret = 0;
121
122         path = archive_entry_pathname(entry);
123         pathlength = strlen(path) + 1; /* Include trailing null. */
124
125         memset(&h, 0, sizeof(h));
126         format_hex(0x070701, &h.c_magic, sizeof(h.c_magic));
127         format_hex(archive_entry_devmajor(entry), &h.c_devmajor, sizeof(h.c_devmajor));
128         format_hex(archive_entry_devminor(entry), &h.c_devminor, sizeof(h.c_devminor));
129         if (archive_entry_ino(entry) > 0xffffffff) {
130                 archive_set_error(&a->archive, ERANGE, "large inode number truncated");
131                 ret = ARCHIVE_WARN;
132         }
133
134         format_hex(archive_entry_ino(entry) & 0xffffffff, &h.c_ino, sizeof(h.c_ino));
135         format_hex(archive_entry_mode(entry), &h.c_mode, sizeof(h.c_mode));
136         format_hex(archive_entry_uid(entry), &h.c_uid, sizeof(h.c_uid));
137         format_hex(archive_entry_gid(entry), &h.c_gid, sizeof(h.c_gid));
138         format_hex(archive_entry_nlink(entry), &h.c_nlink, sizeof(h.c_nlink));
139         if (archive_entry_filetype(entry) == AE_IFBLK
140             || archive_entry_filetype(entry) == AE_IFCHR) {
141             format_hex(archive_entry_rdevmajor(entry), &h.c_rdevmajor, sizeof(h.c_rdevmajor));
142             format_hex(archive_entry_rdevminor(entry), &h.c_rdevminor, sizeof(h.c_rdevminor));
143         } else {
144             format_hex(0, &h.c_rdevmajor, sizeof(h.c_rdevmajor));
145             format_hex(0, &h.c_rdevminor, sizeof(h.c_rdevminor));
146         }
147         format_hex(archive_entry_mtime(entry), &h.c_mtime, sizeof(h.c_mtime));
148         format_hex(pathlength, &h.c_namesize, sizeof(h.c_namesize));
149         format_hex(0, &h.c_checksum, sizeof(h.c_checksum));
150
151         /* Symlinks get the link written as the body of the entry. */
152         p = archive_entry_symlink(entry);
153         if (p != NULL  &&  *p != '\0')
154                 format_hex(strlen(p), &h.c_filesize, sizeof(h.c_filesize));
155         else
156                 format_hex(archive_entry_size(entry), &h.c_filesize, sizeof(h.c_filesize));
157
158         ret = (a->compressor.write)(a, &h, sizeof(h));
159         if (ret != ARCHIVE_OK)
160                 return (ARCHIVE_FATAL);
161
162         /* Pad pathname to even length. */
163         ret = (a->compressor.write)(a, path, pathlength);
164         if (ret != ARCHIVE_OK)
165                 return (ARCHIVE_FATAL);
166         pad = 0x3 & - (pathlength + sizeof(struct cpio_header_newc));
167         if (pad)
168                 ret = (a->compressor.write)(a, "\0\0\0", pad);
169         if (ret != ARCHIVE_OK)
170                 return (ARCHIVE_FATAL);
171
172         cpio->entry_bytes_remaining = archive_entry_size(entry);
173         cpio->padding = 3 & (-cpio->entry_bytes_remaining);
174         /* Write the symlink now. */
175         if (p != NULL  &&  *p != '\0')
176                 ret = (a->compressor.write)(a, p, strlen(p));
177
178         return (ret);
179 }
180
181 static ssize_t
182 archive_write_newc_data(struct archive_write *a, const void *buff, size_t s)
183 {
184         struct cpio *cpio;
185         int ret;
186
187         cpio = (struct cpio *)a->format_data;
188         if (s > cpio->entry_bytes_remaining)
189                 s = cpio->entry_bytes_remaining;
190
191         ret = (a->compressor.write)(a, buff, s);
192         cpio->entry_bytes_remaining -= s;
193         if (ret >= 0)
194                 return (s);
195         else
196                 return (ret);
197 }
198
199 /*
200  * Format a number into the specified field.
201  */
202 static int
203 format_hex(int64_t v, void *p, int digits)
204 {
205         int64_t max;
206         int     ret;
207
208         max = (((int64_t)1) << (digits * 4)) - 1;
209         if (v >= 0  &&  v <= max) {
210             format_hex_recursive(v, (char *)p, digits);
211             ret = 0;
212         } else {
213             format_hex_recursive(max, (char *)p, digits);
214             ret = -1;
215         }
216         return (ret);
217 }
218
219 static int64_t
220 format_hex_recursive(int64_t v, char *p, int s)
221 {
222         if (s == 0)
223                 return (v);
224         v = format_hex_recursive(v, p+1, s-1);
225         *p = "0123456789abcdef"[v & 0xf];
226         return (v >>= 4);
227 }
228
229 static int
230 archive_write_newc_finish(struct archive_write *a)
231 {
232         struct cpio *cpio;
233         int er;
234         struct archive_entry *trailer;
235
236         cpio = (struct cpio *)a->format_data;
237         trailer = archive_entry_new();
238         archive_entry_set_nlink(trailer, 1);
239         archive_entry_set_pathname(trailer, "TRAILER!!!");
240         er = archive_write_newc_header(a, trailer);
241         archive_entry_free(trailer);
242         return (er);
243 }
244
245 static int
246 archive_write_newc_destroy(struct archive_write *a)
247 {
248         struct cpio *cpio;
249
250         cpio = (struct cpio *)a->format_data;
251         free(cpio);
252         a->format_data = NULL;
253         return (ARCHIVE_OK);
254 }
255
256 static int
257 archive_write_newc_finish_entry(struct archive_write *a)
258 {
259         struct cpio *cpio;
260         int to_write, ret;
261
262         cpio = (struct cpio *)a->format_data;
263         ret = ARCHIVE_OK;
264         while (cpio->entry_bytes_remaining > 0) {
265                 to_write = cpio->entry_bytes_remaining < a->null_length ?
266                     cpio->entry_bytes_remaining : a->null_length;
267                 ret = (a->compressor.write)(a, a->nulls, to_write);
268                 if (ret != ARCHIVE_OK)
269                         return (ret);
270                 cpio->entry_bytes_remaining -= to_write;
271         }
272         ret = (a->compressor.write)(a, a->nulls, cpio->padding);
273         return (ret);
274 }