Put WARNS?=6 in usr.sbin/Makefile.inc (like in usr.bin/ etc.).
[dragonfly.git] / usr.sbin / kgzip / kgzcmp.c
1 /*
2  * Copyright (c) 1999 Global Technology Associates, Inc.
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 AND CONTRIBUTORS``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
19  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
21  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
23  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
24  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/usr.sbin/kgzip/kgzcmp.c,v 1.2.2.3 2001/07/19 04:37:24 kris Exp $
27  * $DragonFly: src/usr.sbin/kgzip/kgzcmp.c,v 1.4 2004/08/19 21:36:46 joerg Exp $
28  */
29
30 #include <sys/param.h>
31 #include <sys/stat.h>
32 #include <sys/wait.h>
33 #include <machine/elf.h>
34
35 #include <err.h>
36 #include <fcntl.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <unistd.h>
40
41 #include <a.out.h>
42
43 #include "aouthdr.h"
44 #include "elfhdr.h"
45 #include "kgzip.h"
46
47 static void mk_data(const struct iodesc *i, const struct iodesc *,
48                     struct kgz_hdr *, size_t);
49 static int ld_elf(const struct iodesc *, const struct iodesc *,
50                   struct kgz_hdr *, const Elf32_Ehdr *);
51 static int ld_aout(const struct iodesc *, const struct iodesc *,
52                    struct kgz_hdr *, const struct exec *);
53
54 /*
55  * Compress executable and output it in relocatable object format.
56  */
57 void
58 kgzcmp(struct kgz_hdr *kh, const char *f1, const char *f2)
59 {
60     struct iodesc idi, ido;
61
62     if ((idi.fd = open(idi.fname = f1, O_RDONLY)) == -1)
63         err(1, "%s", idi.fname);
64     if ((ido.fd = open(ido.fname = f2, O_CREAT | O_TRUNC | O_WRONLY,
65                        0666)) == -1)
66         err(1, "%s", ido.fname);
67     kh->ident[0] = KGZ_ID0;
68     kh->ident[1] = KGZ_ID1;
69     kh->ident[2] = KGZ_ID2;
70     kh->ident[3] = KGZ_ID3;
71     mk_data(&idi, &ido, kh,
72             (format == F_AOUT ? sizeof(struct kgz_aouthdr0) :
73                                 sizeof(struct kgz_elfhdr)) +
74              sizeof(struct kgz_hdr));
75     kh->dload &= 0xffffff;
76     kh->entry &= 0xffffff;
77     if (format == F_AOUT) {
78         struct kgz_aouthdr0 ahdr0 = aouthdr0;
79         struct kgz_aouthdr1 ahdr1 = aouthdr1;
80         unsigned x = (sizeof(struct kgz_hdr) + kh->nsize) & (16 - 1);
81         if (x) {
82             x = 16 - x;
83             xzero(&ido, x);
84         }
85         xwrite(&ido, &ahdr1, sizeof(ahdr1));
86         ahdr0.a.a_data += kh->nsize + x;
87         xseek(&ido, 0);
88         xwrite(&ido, &ahdr0, sizeof(ahdr0));
89     } else {
90         struct kgz_elfhdr ehdr = elfhdr;
91         ehdr.st[KGZ_ST_KGZ_NDATA].st_size = kh->nsize;
92         ehdr.sh[KGZ_SH_DATA].sh_size += kh->nsize;
93         xseek(&ido, 0);
94         xwrite(&ido, &ehdr, sizeof(ehdr));
95     }
96     xwrite(&ido, kh, sizeof(*kh));
97     xclose(&ido);
98     xclose(&idi);
99 }
100
101 /*
102  * Make encoded (compressed) data.
103  */
104 static void
105 mk_data(const struct iodesc * idi, const struct iodesc * ido,
106         struct kgz_hdr * kh, size_t off)
107 {
108     union {
109         struct exec ex;
110         Elf32_Ehdr ee;
111     } hdr;
112     struct stat sb;
113     struct iodesc idp;
114     int fd[2];
115     pid_t pid;
116     size_t n;
117     int fmt, status, e;
118
119     n = xread(idi, &hdr, sizeof(hdr), 0);
120     fmt = 0;
121     if (n >= sizeof(hdr.ee) && IS_ELF(hdr.ee))
122         fmt = F_ELF;
123     else if (n >= sizeof(hdr.ex) && N_GETMAGIC(hdr.ex) == ZMAGIC)
124         fmt = F_AOUT;
125     if (!fmt)
126         errx(1, "%s: Format not supported", idi->fname);
127     xseek(ido, off);
128     if (pipe(fd))
129         err(1, NULL);
130     switch (pid = fork()) {
131     case -1:
132         err(1, NULL);
133     case 0:
134         close(fd[1]);
135         dup2(fd[0], STDIN_FILENO);
136         close(fd[0]);
137         close(idi->fd);
138         dup2(ido->fd, STDOUT_FILENO);
139         close(ido->fd);
140         execlp("gzip", "gzip", "-9", NULL);
141         warn(NULL);
142         _exit(1);
143     default:
144         close(fd[0]);
145         idp.fname = "(pipe)";
146         idp.fd = fd[1];
147         e = fmt == F_ELF  ? ld_elf(idi, &idp, kh, &hdr.ee) :
148             fmt == F_AOUT ? ld_aout(idi, &idp, kh, &hdr.ex) : -1;
149         close(fd[1]);
150         if ((pid = waitpid(pid, &status, 0)) == -1)
151             err(1, NULL);
152         if (WIFSIGNALED(status) || WEXITSTATUS(status))
153             exit(1);
154     }
155     if (e)
156         errx(1, "%s: Invalid format", idi->fname);
157     if (fstat(ido->fd, &sb))
158         err(1, "%s", ido->fname);
159     kh->nsize = sb.st_size - off;
160 }
161
162 /*
163  * "Load" an ELF-format executable.
164  */
165 static int
166 ld_elf(const struct iodesc * idi, const struct iodesc * ido,
167        struct kgz_hdr * kh, const Elf32_Ehdr * e)
168 {
169     Elf32_Phdr p;
170     size_t load, addr, n;
171     unsigned x, i;
172
173     load = addr = n = 0;
174     for (x = i = 0; i < e->e_phnum; i++) {
175         if (xread(idi, &p, sizeof(p),
176                   e->e_phoff + i * e->e_phentsize) != e->e_phentsize)
177             return -1;
178         if (p.p_type != PT_LOAD)
179             continue;
180         if (!x)
181             load = addr = p.p_vaddr;
182         else {
183             if (p.p_vaddr < addr)
184                 return -1;
185             n = p.p_vaddr - addr;
186             if (n) {
187                 xzero(ido, n);
188                 addr += n;
189             }
190         }
191         if (p.p_memsz < p.p_filesz)
192             return -1;
193         n = p.p_memsz - p.p_filesz;
194         xcopy(idi, ido, p.p_filesz, p.p_offset);
195         addr += p.p_filesz;
196         x++;
197     }
198     if (!x)
199         return -1;
200     kh->dload = load;
201     kh->dsize = addr - load;
202     kh->isize = kh->dsize + n;
203     kh->entry = e->e_entry;
204     return 0;
205 }
206
207 /*
208  * "Load" an a.out-format executable.
209  */
210 static int
211 ld_aout(const struct iodesc * idi, const struct iodesc * ido,
212         struct kgz_hdr * kh, const struct exec * a)
213 {
214     size_t load, addr;
215
216     load = addr = N_TXTADDR(*a);
217     xcopy(idi, ido, a->a_text, N_TXTOFF(*a));
218     addr += a->a_text;
219     if (N_DATADDR(*a) != addr)
220         return -1;
221     xcopy(idi, ido, a->a_data, N_DATOFF(*a));
222     addr += a->a_data;
223     kh->dload = load;
224     kh->dsize = addr - load;
225     kh->isize = kh->dsize + a->a_bss;
226     kh->entry = a->a_entry;
227     return 0;
228 }