Import libarchive and bsdtar. The default tar (/usr/bin/tar) can be choosen
[dragonfly.git] / contrib / libarchive / archive_write_set_format_cpio.c
1 /*-
2  * Copyright (c) 2003-2004 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  *    in this position and unchanged.
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.c,v 1.5 2004/11/05 05:26:30 kientzle Exp $");
29
30 #include <sys/stat.h>
31 #include <errno.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 #include "archive.h"
37 #include "archive_entry.h"
38 #include "archive_private.h"
39
40 static int      archive_write_cpio_data(struct archive *, const void *buff,
41                     size_t s);
42 static int      archive_write_cpio_finish(struct archive *);
43 static int      archive_write_cpio_finish_entry(struct archive *);
44 static int      archive_write_cpio_header(struct archive *,
45                     struct archive_entry *);
46 static int      format_octal(int64_t, void *, int);
47 static int64_t  format_octal_recursive(int64_t, char *, int);
48
49 struct cpio {
50         uint64_t          entry_bytes_remaining;
51 };
52
53 struct cpio_header {
54         char    c_magic[6];
55         char    c_dev[6];
56         char    c_ino[6];
57         char    c_mode[6];
58         char    c_uid[6];
59         char    c_gid[6];
60         char    c_nlink[6];
61         char    c_rdev[6];
62         char    c_mtime[11];
63         char    c_namesize[6];
64         char    c_filesize[11];
65 };
66
67 /*
68  * Set output format to 'cpio' format.
69  */
70 int
71 archive_write_set_format_cpio(struct archive *a)
72 {
73         struct cpio *cpio;
74
75         /* If someone else was already registered, unregister them. */
76         if (a->format_finish != NULL)
77                 (a->format_finish)(a);
78
79         cpio = malloc(sizeof(*cpio));
80         if (cpio == NULL) {
81                 archive_set_error(a, ENOMEM, "Can't allocate cpio data");
82                 return (ARCHIVE_FATAL);
83         }
84         memset(cpio, 0, sizeof(*cpio));
85         a->format_data = cpio;
86
87         a->pad_uncompressed = 1;
88         a->format_write_header = archive_write_cpio_header;
89         a->format_write_data = archive_write_cpio_data;
90         a->format_finish_entry = archive_write_cpio_finish_entry;
91         a->format_finish = archive_write_cpio_finish;
92         a->archive_format = ARCHIVE_FORMAT_CPIO_POSIX;
93         a->archive_format_name = "POSIX cpio";
94         return (ARCHIVE_OK);
95 }
96
97 static int
98 archive_write_cpio_header(struct archive *a, struct archive_entry *entry)
99 {
100         struct cpio *cpio;
101         const char *p, *path;
102         int pathlength, ret;
103         const struct stat       *st;
104         struct cpio_header       h;
105
106         cpio = a->format_data;
107         ret = 0;
108
109         path = archive_entry_pathname(entry);
110         pathlength = strlen(path) + 1; /* Include trailing null. */
111         st = archive_entry_stat(entry);
112
113         memset(&h, 0, sizeof(h));
114         format_octal(070707, &h.c_magic, sizeof(h.c_magic));
115         format_octal(st->st_dev, &h.c_dev, sizeof(h.c_dev));
116         /*
117          * TODO: Generate artificial inode numbers rather than just
118          * re-using the ones off the disk.  That way, the 18-bit c_ino
119          * field only limits the number of files in the archive.
120          */
121         if (st->st_ino > 0777777) {
122                 archive_set_error(a, ERANGE, "large inode number truncated");
123                 ret = ARCHIVE_WARN;
124         }
125
126         format_octal(st->st_ino & 0777777, &h.c_ino, sizeof(h.c_ino));
127         format_octal(st->st_mode, &h.c_mode, sizeof(h.c_mode));
128         format_octal(st->st_uid, &h.c_uid, sizeof(h.c_uid));
129         format_octal(st->st_gid, &h.c_gid, sizeof(h.c_gid));
130         format_octal(st->st_nlink, &h.c_nlink, sizeof(h.c_nlink));
131         if(S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode))
132             format_octal(st->st_rdev, &h.c_rdev, sizeof(h.c_rdev));
133         else
134             format_octal(0, &h.c_rdev, sizeof(h.c_rdev));
135         format_octal(st->st_mtime, &h.c_mtime, sizeof(h.c_mtime));
136         format_octal(pathlength, &h.c_namesize, sizeof(h.c_namesize));
137
138         /* Symlinks get the link written as the body of the entry. */
139         p = archive_entry_symlink(entry);
140         if (p != NULL  &&  *p != '\0')
141                 format_octal(strlen(p), &h.c_filesize, sizeof(h.c_filesize));
142         else
143                 format_octal(st->st_size, &h.c_filesize, sizeof(h.c_filesize));
144
145         ret = (a->compression_write)(a, &h, sizeof(h));
146         if (ret != ARCHIVE_OK)
147                 return (ARCHIVE_FATAL);
148
149         ret = (a->compression_write)(a, path, pathlength);
150         if (ret != ARCHIVE_OK)
151                 return (ARCHIVE_FATAL);
152
153         cpio->entry_bytes_remaining = st->st_size;
154
155         /* Write the symlink now. */
156         if (p != NULL  &&  *p != '\0')
157                 ret = (a->compression_write)(a, p, strlen(p));
158
159         return (ret);
160 }
161
162 static int
163 archive_write_cpio_data(struct archive *a, const void *buff, size_t s)
164 {
165         struct cpio *cpio;
166         int ret;
167
168         cpio = a->format_data;
169         if (s > cpio->entry_bytes_remaining)
170                 s = cpio->entry_bytes_remaining;
171
172         ret = (a->compression_write)(a, buff, s);
173         cpio->entry_bytes_remaining -= s;
174         return (ret);
175 }
176
177 /*
178  * Format a number into the specified field.
179  */
180 static int
181 format_octal(int64_t v, void *p, int digits)
182 {
183         int64_t max;
184         int     ret;
185
186         max = (((int64_t)1) << (digits * 3)) - 1;
187         if (v >= 0  &&  v <= max) {
188             format_octal_recursive(v, p, digits);
189             ret = 0;
190         } else {
191             format_octal_recursive(max, p, digits);
192             ret = -1;
193         }
194         return (ret);
195 }
196
197 static int64_t
198 format_octal_recursive(int64_t v, char *p, int s)
199 {
200         if (s == 0)
201                 return (v);
202         v = format_octal_recursive(v, p+1, s-1);
203         *p = '0' + (v & 7);
204         return (v >>= 3);
205 }
206
207 static int
208 archive_write_cpio_finish(struct archive *a)
209 {
210         struct cpio *cpio;
211         struct stat st;
212         int er;
213         struct archive_entry *trailer;
214
215         cpio = a->format_data;
216         trailer = archive_entry_new();
217         memset(&st, 0, sizeof(st));
218         st.st_nlink = 1;
219         archive_entry_copy_stat(trailer, &st);
220         archive_entry_set_pathname(trailer, "TRAILER!!!");
221         er = archive_write_cpio_header(a, trailer);
222         archive_entry_free(trailer);
223
224         free(cpio);
225         a->format_data = NULL;
226         return (er);
227 }
228
229 static int
230 archive_write_cpio_finish_entry(struct archive *a)
231 {
232         struct cpio *cpio;
233         int to_write, ret;
234
235         cpio = a->format_data;
236         ret = ARCHIVE_OK;
237         while (cpio->entry_bytes_remaining > 0) {
238                 to_write = cpio->entry_bytes_remaining < a->null_length ?
239                     cpio->entry_bytes_remaining : a->null_length;
240                 ret = (a->compression_write)(a, a->nulls, to_write);
241                 if (ret != ARCHIVE_OK)
242                         return (ret);
243                 cpio->entry_bytes_remaining -= to_write;
244         }
245         return (ret);
246 }