Typo in Swedish translation
[dpkg/dpkg.git] / dpkg-deb / build.c
1 /*
2  * dpkg-deb - construction and deconstruction of *.deb archives
3  * build.c - building archives
4  *
5  * Copyright © 1994,1995 Ian Jackson <ian@chiark.greenend.org.uk>
6  * Copyright © 2000,2001 Wichert Akkerman <wakkerma@debian.org>
7  * Copyright © 2007-2012 Guillem Jover <guillem@debian.org>
8  *
9  * This is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  */
22
23 #include <config.h>
24 #include <compat.h>
25
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <sys/wait.h>
29
30 #include <errno.h>
31 #include <limits.h>
32 #include <ctype.h>
33 #include <string.h>
34 #include <dirent.h>
35 #include <fcntl.h>
36 #include <unistd.h>
37 #include <stdbool.h>
38 #include <stdint.h>
39 #include <stdlib.h>
40 #include <stdio.h>
41
42 #include <dpkg/i18n.h>
43 #include <dpkg/dpkg.h>
44 #include <dpkg/dpkg-db.h>
45 #include <dpkg/path.h>
46 #include <dpkg/varbuf.h>
47 #include <dpkg/fdio.h>
48 #include <dpkg/buffer.h>
49 #include <dpkg/subproc.h>
50 #include <dpkg/compress.h>
51 #include <dpkg/ar.h>
52 #include <dpkg/options.h>
53
54 #include "dpkg-deb.h"
55
56 /**
57  * Simple structure to store information about a file.
58  */
59 struct file_info {
60   struct file_info *next;
61   struct stat st;
62   char *fn;
63 };
64
65 static struct file_info *
66 file_info_new(const char *filename)
67 {
68   struct file_info *fi;
69
70   fi = m_malloc(sizeof(*fi));
71   fi->fn = m_strdup(filename);
72   fi->next = NULL;
73
74   return fi;
75 }
76
77 static void
78 file_info_free(struct file_info *fi)
79 {
80   free(fi->fn);
81   free(fi);
82 }
83
84 static struct file_info *
85 file_info_find_name(struct file_info *list, const char *filename)
86 {
87   struct file_info *node;
88
89   for (node = list; node; node = node->next)
90     if (strcmp(node->fn, filename) == 0)
91       return node;
92
93   return NULL;
94 }
95
96 /**
97  * Read a filename from the file descriptor and create a file_info struct.
98  *
99  * @return A file_info struct or NULL if there is nothing to read.
100  */
101 static struct file_info *
102 file_info_get(const char *root, int fd)
103 {
104   static struct varbuf fn = VARBUF_INIT;
105   struct file_info *fi;
106   size_t root_len;
107
108   varbuf_reset(&fn);
109   root_len = varbuf_printf(&fn, "%s/", root);
110
111   while (1) {
112     int res;
113
114     varbuf_grow(&fn, 1);
115     res = fd_read(fd, (fn.buf + fn.used), 1);
116     if (res < 0)
117       return NULL;
118     if (res == 0) /* EOF -> parent died. */
119       return NULL;
120     if (fn.buf[fn.used] == '\0')
121       break;
122
123     varbuf_trunc(&fn, fn.used + 1);
124     if (fn.used >= MAXFILENAME)
125       ohshit(_("file name '%.50s...' is too long"), fn.buf + root_len);
126   }
127
128   fi = file_info_new(fn.buf + root_len);
129   if (lstat(fn.buf, &(fi->st)) != 0)
130     ohshite(_("unable to stat file name '%.250s'"), fn.buf);
131
132   return fi;
133 }
134
135 /**
136  * Add a new file_info struct to a single linked list of file_info structs.
137  *
138  * We perform a slight optimization to work around a ‘feature’ in tar: tar
139  * always recurses into subdirectories if you list a subdirectory. So if an
140  * entry is added and the previous entry in the list is its subdirectory we
141  * remove the subdirectory.
142  *
143  * After a file_info struct is added to a list it may no longer be freed, we
144  * assume full responsibility for its memory.
145  */
146 static void
147 file_info_list_append(struct file_info **head, struct file_info **tail,
148                       struct file_info *fi)
149 {
150   if (*head == NULL)
151     *head = *tail = fi;
152   else
153     *tail = (*tail)->next =fi;
154 }
155
156 /**
157  * Free the memory for all entries in a list of file_info structs.
158  */
159 static void
160 file_info_list_free(struct file_info *fi)
161 {
162   while (fi) {
163     struct file_info *fl;
164
165     fl=fi; fi=fi->next;
166     file_info_free(fl);
167   }
168 }
169
170 static const char *const maintainerscripts[] = {
171   PREINSTFILE,
172   POSTINSTFILE,
173   PRERMFILE,
174   POSTRMFILE,
175   NULL,
176 };
177
178 /**
179  * Check control directory and file permissions.
180  */
181 static void
182 check_file_perms(const char *dir)
183 {
184   struct varbuf path = VARBUF_INIT;
185   const char *const *mscriptp;
186   struct stat mscriptstab;
187
188   varbuf_printf(&path, "%s/%s/", dir, BUILDCONTROLDIR);
189   if (lstat(path.buf, &mscriptstab))
190     ohshite(_("unable to stat control directory"));
191   if (!S_ISDIR(mscriptstab.st_mode))
192     ohshit(_("control directory is not a directory"));
193   if ((mscriptstab.st_mode & 07757) != 0755)
194     ohshit(_("control directory has bad permissions %03lo "
195              "(must be >=0755 and <=0775)"),
196            (unsigned long)(mscriptstab.st_mode & 07777));
197
198   for (mscriptp = maintainerscripts; *mscriptp; mscriptp++) {
199     varbuf_reset(&path);
200     varbuf_printf(&path, "%s/%s/%s", dir, BUILDCONTROLDIR, *mscriptp);
201     if (!lstat(path.buf, &mscriptstab)) {
202       if (S_ISLNK(mscriptstab.st_mode))
203         continue;
204       if (!S_ISREG(mscriptstab.st_mode))
205         ohshit(_("maintainer script `%.50s' is not a plain file or symlink"),
206                *mscriptp);
207       if ((mscriptstab.st_mode & 07557) != 0555)
208         ohshit(_("maintainer script `%.50s' has bad permissions %03lo "
209                  "(must be >=0555 and <=0775)"),
210                *mscriptp, (unsigned long)(mscriptstab.st_mode & 07777));
211     } else if (errno != ENOENT) {
212       ohshite(_("maintainer script `%.50s' is not stattable"), *mscriptp);
213     }
214   }
215
216   varbuf_destroy(&path);
217 }
218
219 /**
220  * Check if conffiles contains sane information.
221  */
222 static void
223 check_conffiles(const char *dir)
224 {
225   FILE *cf;
226   struct varbuf controlfile = VARBUF_INIT;
227   char conffilename[MAXCONFFILENAME + 1];
228   struct file_info *conffiles_head = NULL;
229   struct file_info *conffiles_tail = NULL;
230
231   varbuf_printf(&controlfile, "%s/%s/%s", dir, BUILDCONTROLDIR, CONFFILESFILE);
232
233   cf = fopen(controlfile.buf, "r");
234   if (cf == NULL) {
235     if (errno == ENOENT)
236       return;
237
238     ohshite(_("error opening conffiles file"));
239   }
240
241   while (fgets(conffilename, MAXCONFFILENAME + 1, cf)) {
242     struct stat controlstab;
243     int n;
244
245     n = strlen(conffilename);
246     if (!n)
247       ohshite(_("empty string from fgets reading conffiles"));
248
249     if (conffilename[n - 1] != '\n') {
250       int c;
251
252       warning(_("conffile name '%.50s...' is too long, or missing final newline"),
253               conffilename);
254       while ((c = getc(cf)) != EOF && c != '\n');
255
256       continue;
257     }
258
259     conffilename[n - 1] = '\0';
260     varbuf_reset(&controlfile);
261     varbuf_printf(&controlfile, "%s/%s", dir, conffilename);
262     if (lstat(controlfile.buf, &controlstab)) {
263       if (errno == ENOENT) {
264         if ((n > 1) && isspace(conffilename[n - 2]))
265           warning(_("conffile filename '%s' contains trailing white spaces"),
266                   conffilename);
267         ohshit(_("conffile `%.250s' does not appear in package"), conffilename);
268       } else
269         ohshite(_("conffile `%.250s' is not stattable"), conffilename);
270     } else if (!S_ISREG(controlstab.st_mode)) {
271       warning(_("conffile '%s' is not a plain file"), conffilename);
272     }
273
274     if (file_info_find_name(conffiles_head, conffilename)) {
275       warning(_("conffile name '%s' is duplicated"), conffilename);
276     } else {
277       struct file_info *conffile;
278
279       conffile = file_info_new(conffilename);
280       file_info_list_append(&conffiles_head, &conffiles_tail, conffile);
281     }
282   }
283
284   file_info_list_free(conffiles_head);
285   varbuf_destroy(&controlfile);
286
287   if (ferror(cf))
288     ohshite(_("error reading conffiles file"));
289   fclose(cf);
290 }
291
292 static const char *arbitrary_fields[] = {
293   "Built-Using",
294   "Package-Type",
295   "Subarchitecture",
296   "Kernel-Version",
297   "Installer-Menu-Item",
298   "Homepage",
299   "Tag",
300   NULL
301 };
302
303 static const char private_prefix[] = "Private-";
304
305 static bool
306 known_arbitrary_field(const struct arbitraryfield *field)
307 {
308   const char **known;
309
310   /* Always accept fields starting with a private field prefix. */
311   if (strncasecmp(field->name, private_prefix, strlen(private_prefix)) == 0)
312     return true;
313
314   for (known = arbitrary_fields; *known; known++)
315     if (strcasecmp(field->name, *known) == 0)
316       return true;
317
318   return false;
319 }
320
321 /**
322  * Perform some sanity checks on the to-be-built package.
323  *
324  * @return The pkginfo struct from the parsed control file.
325  */
326 static struct pkginfo *
327 check_new_pkg(const char *dir)
328 {
329   struct pkginfo *pkg;
330   struct arbitraryfield *field;
331   char *controlfile;
332   int warns;
333
334   /* Start by reading in the control file so we can check its contents. */
335   m_asprintf(&controlfile, "%s/%s/%s", dir, BUILDCONTROLDIR, CONTROLFILE);
336   parsedb(controlfile, pdb_parse_binary, &pkg);
337
338   if (strspn(pkg->set->name, "abcdefghijklmnopqrstuvwxyz0123456789+-.") !=
339       strlen(pkg->set->name))
340     ohshit(_("package name has characters that aren't lowercase alphanums or `-+.'"));
341   if (pkg->priority == pri_other)
342     warning(_("'%s' contains user-defined Priority value '%s'"),
343             controlfile, pkg->otherpriority);
344   for (field = pkg->available.arbs; field; field = field->next) {
345     if (known_arbitrary_field(field))
346       continue;
347
348     warning(_("'%s' contains user-defined field '%s'"), controlfile,
349             field->name);
350   }
351
352   free(controlfile);
353
354   check_file_perms(dir);
355   check_conffiles(dir);
356
357   warns = warning_get_count();
358   if (warns)
359     warning(P_("ignoring %d warning about the control file(s)\n",
360                "ignoring %d warnings about the control file(s)\n", warns),
361             warns);
362
363   return pkg;
364 }
365
366 /**
367  * Generate the pathname for the to-be-built package.
368  *
369  * @return The pathname for the package being built.
370  */
371 static char *
372 pkg_get_pathname(const char *dir, struct pkginfo *pkg)
373 {
374   char *path;
375   const char *versionstring, *arch_sep;
376
377   versionstring = versiondescribe(&pkg->available.version, vdew_never);
378   arch_sep = pkg->available.arch->type == arch_none ? "" : "_";
379   m_asprintf(&path, "%s/%s_%s%s%s%s", dir, pkg->set->name, versionstring,
380              arch_sep, pkg->available.arch->name, DEBEXT);
381
382   return path;
383 }
384
385 /**
386  * Overly complex function that builds a .deb file.
387  */
388 int
389 do_build(const char *const *argv)
390 {
391   struct dpkg_error err;
392   const char *debar, *dir;
393   bool subdir;
394   char *tfbuf;
395   int arfd;
396   int p1[2], p2[2], p3[2], gzfd;
397   pid_t c1,c2,c3;
398   struct file_info *fi;
399   struct file_info *symlist = NULL;
400   struct file_info *symlist_end = NULL;
401
402   /* Decode our arguments. */
403   dir = *argv++;
404   if (!dir)
405     badusage(_("--%s needs a <directory> argument"), cipaction->olong);
406   subdir = false;
407   debar = *argv++;
408   if (debar != NULL) {
409     struct stat debarstab;
410
411     if (*argv)
412       badusage(_("--%s takes at most two arguments"), cipaction->olong);
413
414     if (stat(debar, &debarstab)) {
415       if (errno != ENOENT)
416         ohshite(_("unable to check for existence of archive `%.250s'"), debar);
417     } else if (S_ISDIR(debarstab.st_mode)) {
418       subdir = true;
419     }
420   } else {
421     char *m;
422
423     m= m_malloc(strlen(dir) + sizeof(DEBEXT));
424     strcpy(m, dir);
425     path_trim_slash_slashdot(m);
426     strcat(m, DEBEXT);
427     debar= m;
428   }
429
430   /* Perform some sanity checks on the to-be-build package. */
431   if (nocheckflag) {
432     if (subdir)
433       ohshit(_("target is directory - cannot skip control file check"));
434     warning(_("not checking contents of control area"));
435     printf(_("dpkg-deb: building an unknown package in '%s'.\n"), debar);
436   } else {
437     struct pkginfo *pkg;
438
439     pkg = check_new_pkg(dir);
440     if (subdir)
441       debar = pkg_get_pathname(debar, pkg);
442     printf(_("dpkg-deb: building package `%s' in `%s'.\n"),
443            pkg->set->name, debar);
444   }
445   m_output(stdout, _("<standard output>"));
446
447   /* Now that we have verified everything its time to actually
448    * build something. Let's start by making the ar-wrapper. */
449   arfd = creat(debar, 0644);
450   if (arfd < 0)
451     ohshite(_("unable to create `%.255s'"), debar);
452   /* Fork a tar to package the control-section of the package. */
453   unsetenv("TAR_OPTIONS");
454   m_pipe(p1);
455   c1 = subproc_fork();
456   if (!c1) {
457     m_dup2(p1[1],1); close(p1[0]); close(p1[1]);
458     if (chdir(dir))
459       ohshite(_("failed to chdir to `%.255s'"), dir);
460     if (chdir(BUILDCONTROLDIR))
461       ohshite(_("failed to chdir to `%.255s'"), ".../DEBIAN");
462     execlp(TAR, "tar", "-cf", "-", "--format=gnu", ".", NULL);
463     ohshite(_("unable to execute %s (%s)"), "tar -cf", TAR);
464   }
465   close(p1[1]);
466   /* Create a temporary file to store the control data in. Immediately
467    * unlink our temporary file so others can't mess with it. */
468   tfbuf = path_make_temp_template("dpkg-deb");
469   gzfd = mkstemp(tfbuf);
470   if (gzfd == -1)
471     ohshite(_("failed to make temporary file (%s)"), _("control member"));
472   /* Make sure it's gone, the fd will remain until we close it. */
473   if (unlink(tfbuf))
474     ohshit(_("failed to unlink temporary file (%s), %s"), _("control member"),
475            tfbuf);
476   free(tfbuf);
477
478   /* And run gzip to compress our control archive. */
479   c2 = subproc_fork();
480   if (!c2) {
481     struct compress_params params;
482
483     params.type = compressor_type_gzip;
484     params.strategy = compressor_strategy_none;
485     params.level = 9;
486
487     compress_filter(&params, p1[0], gzfd, _("compressing control member"));
488     exit(0);
489   }
490   close(p1[0]);
491   subproc_wait_check(c2, "gzip -9c", 0);
492   subproc_wait_check(c1, "tar -cf", 0);
493
494   if (lseek(gzfd, 0, SEEK_SET))
495     ohshite(_("failed to rewind temporary file (%s)"), _("control member"));
496
497   /* We have our first file for the ar-archive. Write a header for it
498    * to the package and insert it. */
499   if (deb_format.major == 0) {
500     struct stat controlstab;
501     char versionbuf[40];
502
503     if (fstat(gzfd, &controlstab))
504       ohshite(_("failed to stat temporary file (%s)"), _("control member"));
505     sprintf(versionbuf, "%-8s\n%jd\n", OLDARCHIVEVERSION,
506             (intmax_t)controlstab.st_size);
507     if (fd_write(arfd, versionbuf, strlen(versionbuf)) < 0)
508       ohshite(_("error writing `%s'"), debar);
509     if (fd_fd_copy(gzfd, arfd, -1, &err) < 0)
510       ohshit(_("cannot copy '%s' into archive '%s': %s"), _("control member"),
511              debar, err.str);
512   } else {
513     const char deb_magic[] = ARCHIVEVERSION "\n";
514
515     dpkg_ar_put_magic(debar, arfd);
516     dpkg_ar_member_put_mem(debar, arfd, DEBMAGIC, deb_magic, strlen(deb_magic));
517     dpkg_ar_member_put_file(debar, arfd, ADMINMEMBER, gzfd, -1);
518   }
519   close(gzfd);
520
521   /* Control is done, now we need to archive the data. */
522   if (deb_format.major == 0) {
523     /* In old format, the data member is just concatenated after the
524      * control member, so we do not need a temporary file and can use
525      * the compression file descriptor. */
526     gzfd = arfd;
527   } else {
528     /* Start by creating a new temporary file. Immediately unlink the
529      * temporary file so others can't mess with it. */
530     tfbuf = path_make_temp_template("dpkg-deb");
531     gzfd = mkstemp(tfbuf);
532     if (gzfd == -1)
533       ohshite(_("failed to make temporary file (%s)"), _("data member"));
534     /* Make sure it's gone, the fd will remain until we close it. */
535     if (unlink(tfbuf))
536       ohshit(_("failed to unlink temporary file (%s), %s"), _("data member"),
537              tfbuf);
538     free(tfbuf);
539   }
540   /* Fork off a tar. We will feed it a list of filenames on stdin later. */
541   m_pipe(p1);
542   m_pipe(p2);
543   c1 = subproc_fork();
544   if (!c1) {
545     m_dup2(p1[0],0); close(p1[0]); close(p1[1]);
546     m_dup2(p2[1],1); close(p2[0]); close(p2[1]);
547     if (chdir(dir))
548       ohshite(_("failed to chdir to `%.255s'"), dir);
549     execlp(TAR, "tar", "-cf", "-", "--format=gnu", "--null", "-T", "-", "--no-recursion", NULL);
550     ohshite(_("unable to execute %s (%s)"), "tar -cf", TAR);
551   }
552   close(p1[0]);
553   close(p2[1]);
554   /* Of course we should not forget to compress the archive as well. */
555   c2 = subproc_fork();
556   if (!c2) {
557     close(p1[1]);
558     compress_filter(&compress_params, p2[0], gzfd, _("compressing data member"));
559     exit(0);
560   }
561   close(p2[0]);
562
563   /* All the pipes are set, now lets run find, and start feeding
564    * filenames to tar. */
565   m_pipe(p3);
566   c3 = subproc_fork();
567   if (!c3) {
568     m_dup2(p3[1],1); close(p3[0]); close(p3[1]);
569     if (chdir(dir))
570       ohshite(_("failed to chdir to `%.255s'"), dir);
571     execlp(FIND, "find", ".", "-path", "./" BUILDCONTROLDIR, "-prune", "-o",
572            "-print0", NULL);
573     ohshite(_("unable to execute %s (%s)"), "find", FIND);
574   }
575   close(p3[1]);
576   /* We need to reorder the files so we can make sure that symlinks
577    * will not appear before their target. */
578   while ((fi = file_info_get(dir, p3[0])) != NULL)
579     if (S_ISLNK(fi->st.st_mode))
580       file_info_list_append(&symlist, &symlist_end, fi);
581     else {
582       if (fd_write(p1[1], fi->fn, strlen(fi->fn) + 1) < 0)
583         ohshite(_("failed to write filename to tar pipe (%s)"),
584                 _("data member"));
585       file_info_free(fi);
586     }
587   close(p3[0]);
588   subproc_wait_check(c3, "find", 0);
589
590   for (fi= symlist;fi;fi= fi->next)
591     if (fd_write(p1[1], fi->fn, strlen(fi->fn) + 1) < 0)
592       ohshite(_("failed to write filename to tar pipe (%s)"), _("data member"));
593   /* All done, clean up wait for tar and gzip to finish their job. */
594   close(p1[1]);
595   file_info_list_free(symlist);
596   subproc_wait_check(c2, _("<compress> from tar -cf"), 0);
597   subproc_wait_check(c1, "tar -cf", 0);
598   /* Okay, we have data.tar as well now, add it to the ar wrapper. */
599   if (deb_format.major == 2) {
600     char datamember[16 + 1];
601
602     sprintf(datamember, "%s%s", DATAMEMBER,
603             compressor_get_extension(compress_params.type));
604
605     if (lseek(gzfd, 0, SEEK_SET))
606       ohshite(_("failed to rewind temporary file (%s)"), _("data member"));
607
608     dpkg_ar_member_put_file(debar, arfd, datamember, gzfd, -1);
609   }
610   if (fsync(arfd))
611     ohshite(_("unable to sync file '%s'"), debar);
612   if (close(arfd))
613     ohshite(_("unable to close file '%s'"), debar);
614
615   return 0;
616 }