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