1 /* vi: set sw=4 ts=4: */
3 * mini dpkg implementation for busybox.
4 * this is not meant as a replacement for dpkg
6 * written by glenn mcgrath with the help of others
7 * copyright (c) 2001 by glenn mcgrath
9 * parts of the version comparison code is plucked from the real dpkg
10 * application which is licensed GPLv2 and
11 * copyright (c) 1995 Ian Jackson <ian@chiark.greenend.org.uk>
13 * started life as a busybox implementation of udpkg
15 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
18 * known difference between busybox dpkg and the official dpkg that i don't
19 * consider important, its worth keeping a note of differences anyway, just to
20 * make it easier to maintain.
21 * - the first value for the confflile: field isnt placed on a new line.
22 * - when installing a package the status: field is placed at the end of the
23 * section, rather than just after the package: field.
25 * bugs that need to be fixed
26 * - (unknown, please let me know when you find any)
32 //config: select FEATURE_SEAMLESS_GZ
34 //config: dpkg is a medium-level tool to install, build, remove and manage
35 //config: Debian packages.
37 //config: This implementation of dpkg has a number of limitations,
38 //config: you should use the official dpkg if possible.
40 //applet:IF_DPKG(APPLET(dpkg, BB_DIR_USR_BIN, BB_SUID_DROP))
41 //kbuild:lib-$(CONFIG_DPKG) += dpkg.o
43 //usage:#define dpkg_trivial_usage
44 //usage: "[-ilCPru] [-F OPT] PACKAGE"
45 //usage:#define dpkg_full_usage "\n\n"
46 //usage: "Install, remove and manage Debian packages\n"
47 //usage: IF_LONG_OPTS(
48 //usage: "\n -i,--install Install the package"
49 //usage: "\n -l,--list List of installed packages"
50 //usage: "\n --configure Configure an unpackaged package"
51 //usage: "\n -P,--purge Purge all files of a package"
52 //usage: "\n -r,--remove Remove all but the configuration files for a package"
53 //usage: "\n --unpack Unpack a package, but don't configure it"
54 //usage: "\n --force-depends Ignore dependency problems"
55 //usage: "\n --force-confnew Overwrite existing config files when installing"
56 //usage: "\n --force-confold Keep old config files when installing"
58 //usage: IF_NOT_LONG_OPTS(
59 //usage: "\n -i Install the package"
60 //usage: "\n -l List of installed packages"
61 //usage: "\n -C Configure an unpackaged package"
62 //usage: "\n -P Purge all files of a package"
63 //usage: "\n -r Remove all but the configuration files for a package"
64 //usage: "\n -u Unpack a package, but don't configure it"
65 //usage: "\n -F depends Ignore dependency problems"
66 //usage: "\n -F confnew Overwrite existing config files when installing"
67 //usage: "\n -F confold Keep old config files when installing"
72 #include "bb_archive.h"
74 /* note: if you vary hash_prime sizes be aware,
75 * 1) tweaking these will have a big effect on how much memory this program uses.
76 * 2) for computational efficiency these hash tables should be at least 20%
77 * larger than the maximum number of elements stored in it.
78 * 3) all _hash_prime's must be a prime number or chaos is assured, if your looking
79 * for a prime, try http://www.utm.edu/research/primes/lists/small/10000.txt
80 * 4) if you go bigger than 15 bits you may get into trouble (untested) as its
81 * sometimes cast to an unsigned, if you go to 16 bit you will overlap
82 * int's and chaos is assured, 16381 is the max prime for 14 bit field
85 /* NAME_HASH_PRIME, Stores package names and versions,
86 * I estimate it should be at least 50% bigger than PACKAGE_HASH_PRIME,
87 * as there a lot of duplicate version numbers */
88 #define NAME_HASH_PRIME 16381
90 /* PACKAGE_HASH_PRIME, Maximum number of unique packages,
91 * It must not be smaller than STATUS_HASH_PRIME,
92 * Currently only packages from status_hashtable are stored in here, but in
93 * future this may be used to store packages not only from a status file,
94 * but an available_hashtable, and even multiple packages files.
95 * Package can be stored more than once if they have different versions.
96 * e.g. The same package may have different versions in the status file
97 * and available file */
98 #define PACKAGE_HASH_PRIME 10007
99 typedef struct edge_s
{
100 unsigned operator:4; /* was:3 */
102 unsigned name
:16; /* was:14 */
103 unsigned version
:16; /* was:14 */
106 typedef struct common_node_s
{
107 unsigned name
:16; /* was:14 */
108 unsigned version
:16; /* was:14 */
109 unsigned num_of_edges
:16; /* was:14 */
113 /* Currently it doesnt store packages that have state-status of not-installed
114 * So it only really has to be the size of the maximum number of packages
115 * likely to be installed at any one time, so there is a bit of leeway here */
116 #define STATUS_HASH_PRIME 8191
117 typedef struct status_node_s
{
118 unsigned package
:16; /* was:14 */ /* has to fit PACKAGE_HASH_PRIME */
119 unsigned status
:16; /* was:14 */ /* has to fit STATUS_HASH_PRIME */
125 char *name_hashtable
[NAME_HASH_PRIME
+ 1];
126 common_node_t
*package_hashtable
[PACKAGE_HASH_PRIME
+ 1];
127 status_node_t
*status_hashtable
[STATUS_HASH_PRIME
+ 1];
129 #define G (*ptr_to_globals)
130 #define name_hashtable (G.name_hashtable )
131 #define package_hashtable (G.package_hashtable)
132 #define status_hashtable (G.status_hashtable )
133 #define INIT_G() do { \
134 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
138 /* Even numbers are for 'extras', like ored dependencies or null */
141 EDGE_PRE_DEPENDS
= 1,
142 EDGE_OR_PRE_DEPENDS
= 2,
149 EDGE_RECOMMENDS
= 13,
162 typedef struct deb_file_s
{
165 unsigned package
:16; /* was:14 */
169 static void make_hash(const char *key
, unsigned *start
, unsigned *decrement
, const int hash_prime
)
171 unsigned long hash_num
= key
[0];
172 int len
= strlen(key
);
175 /* Maybe i should have uses a "proper" hashing algorithm here instead
176 * of making one up myself, seems to be working ok though. */
177 for (i
= 1; i
< len
; i
++) {
178 /* shifts the ascii based value and adds it to previous value
179 * shift amount is mod 24 because long int is 32 bit and data
180 * to be shifted is 8, don't want to shift data to where it has
182 hash_num
+= (key
[i
] + key
[i
-1]) << ((key
[i
] * i
) % 24);
184 *start
= (unsigned) hash_num
% hash_prime
;
185 *decrement
= (unsigned) 1 + (hash_num
% (hash_prime
- 1));
188 /* this adds the key to the hash table */
189 static int search_name_hashtable(const char *key
)
191 unsigned probe_address
;
192 unsigned probe_decrement
;
194 make_hash(key
, &probe_address
, &probe_decrement
, NAME_HASH_PRIME
);
195 while (name_hashtable
[probe_address
] != NULL
) {
196 if (strcmp(name_hashtable
[probe_address
], key
) == 0) {
197 return probe_address
;
199 probe_address
-= probe_decrement
;
200 if ((int)probe_address
< 0) {
201 probe_address
+= NAME_HASH_PRIME
;
204 name_hashtable
[probe_address
] = xstrdup(key
);
205 return probe_address
;
208 /* this DOESNT add the key to the hashtable
209 * TODO make it consistent with search_name_hashtable
211 static unsigned search_status_hashtable(const char *key
)
213 unsigned probe_address
;
214 unsigned probe_decrement
;
216 make_hash(key
, &probe_address
, &probe_decrement
, STATUS_HASH_PRIME
);
217 while (status_hashtable
[probe_address
] != NULL
) {
218 if (strcmp(key
, name_hashtable
[package_hashtable
[status_hashtable
[probe_address
]->package
]->name
]) == 0) {
221 probe_address
-= probe_decrement
;
222 if ((int)probe_address
< 0) {
223 probe_address
+= STATUS_HASH_PRIME
;
226 return probe_address
;
229 static int order(char x
)
231 return (x
== '~' ? -1
235 : (unsigned char)x
+ 256
239 /* This code is taken from dpkg and modified slightly to work with busybox */
240 static int version_compare_part(const char *val
, const char *ref
)
245 while (*val
|| *ref
) {
248 while ((*val
&& !isdigit(*val
)) || (*ref
&& !isdigit(*ref
))) {
249 int vc
= order(*val
);
250 int rc
= order(*ref
);
263 while (isdigit(*val
) && isdigit(*ref
)) {
265 first_diff
= *val
- *ref
;
279 /* if ver1 < ver2 return -1,
280 * if ver1 = ver2 return 0,
281 * if ver1 > ver2 return 1,
283 static int version_compare(const unsigned ver1
, const unsigned ver2
)
285 char *ch_ver1
= name_hashtable
[ver1
];
286 char *ch_ver2
= name_hashtable
[ver2
];
287 unsigned epoch1
= 0, epoch2
= 0;
289 char *deb_ver1
, *deb_ver2
;
295 colon
= strchr(ch_ver1
, ':');
297 epoch1
= atoi(ch_ver1
);
300 colon
= strchr(ch_ver2
, ':');
302 epoch2
= atoi(ch_ver2
);
305 if (epoch1
< epoch2
) {
308 if (epoch1
> epoch2
) {
312 /* Compare upstream version */
313 upstream_ver1
= xstrdup(ch_ver1
);
314 upstream_ver2
= xstrdup(ch_ver2
);
316 /* Chop off debian version, and store for later use */
317 deb_ver1
= strrchr(upstream_ver1
, '-');
318 deb_ver2
= strrchr(upstream_ver2
, '-');
325 result
= version_compare_part(upstream_ver1
, upstream_ver2
);
327 /* Compare debian versions */
328 result
= version_compare_part(deb_ver1
, deb_ver2
);
336 static int test_version(const unsigned version1
, const unsigned version2
, const unsigned operator)
338 const int version_result
= version_compare(version1
, version2
);
343 return (version_result
== 0);
345 return (version_result
< 0);
347 return (version_result
<= 0);
349 return (version_result
> 0);
351 return (version_result
>= 0);
356 static int search_package_hashtable(const unsigned name
, const unsigned version
, const unsigned operator)
358 unsigned probe_address
;
359 unsigned probe_decrement
;
361 make_hash(name_hashtable
[name
], &probe_address
, &probe_decrement
, PACKAGE_HASH_PRIME
);
362 while (package_hashtable
[probe_address
] != NULL
) {
363 if (package_hashtable
[probe_address
]->name
== name
) {
364 if (operator == VER_ANY
) {
365 return probe_address
;
367 if (test_version(package_hashtable
[probe_address
]->version
, version
, operator)) {
368 return probe_address
;
371 probe_address
-= probe_decrement
;
372 if ((int)probe_address
< 0) {
373 probe_address
+= PACKAGE_HASH_PRIME
;
376 return probe_address
;
380 * This function searches through the entire package_hashtable looking
381 * for a package which provides "needle". It returns the index into
382 * the package_hashtable for the providing package.
384 * needle is the index into name_hashtable of the package we are
387 * start_at is the index in the package_hashtable to start looking
388 * at. If start_at is -1 then start at the beginning. This is to allow
389 * for repeated searches since more than one package might provide
392 * FIXME: I don't think this is very efficient, but I thought I'd keep
393 * it simple for now until it proves to be a problem.
395 static int search_for_provides(int needle
, int start_at
)
399 for (i
= start_at
+ 1; i
< PACKAGE_HASH_PRIME
; i
++) {
400 p
= package_hashtable
[i
];
403 for (j
= 0; j
< p
->num_of_edges
; j
++)
404 if (p
->edge
[j
]->type
== EDGE_PROVIDES
&& p
->edge
[j
]->name
== needle
)
411 * Add an edge to a node
413 static void add_edge_to_node(common_node_t
*node
, edge_t
*edge
)
415 node
->edge
= xrealloc_vector(node
->edge
, 2, node
->num_of_edges
);
416 node
->edge
[node
->num_of_edges
++] = edge
;
420 * Create one new node and one new edge for every dependency.
422 * Dependencies which contain multiple alternatives are represented as
423 * an EDGE_OR_PRE_DEPENDS or EDGE_OR_DEPENDS node, followed by a
424 * number of EDGE_PRE_DEPENDS or EDGE_DEPENDS nodes. The name field of
425 * the OR edge contains the full dependency string while the version
426 * field contains the number of EDGE nodes which follow as part of
429 static void add_split_dependencies(common_node_t
*parent_node
, const char *whole_line
, unsigned edge_type
)
431 char *line
= xstrdup(whole_line
);
433 char *line_ptr1
= NULL
;
434 char *line_ptr2
= NULL
;
442 field
= strtok_r(line
, ",", &line_ptr1
);
444 /* skip leading spaces */
445 field
+= strspn(field
, " ");
446 line2
= xstrdup(field
);
447 field2
= strtok_r(line2
, "|", &line_ptr2
);
449 if ((edge_type
== EDGE_DEPENDS
|| edge_type
== EDGE_PRE_DEPENDS
)
450 && (strcmp(field
, field2
) != 0)
452 or_edge
= xzalloc(sizeof(edge_t
));
453 or_edge
->type
= edge_type
+ 1;
454 or_edge
->name
= search_name_hashtable(field
);
455 //or_edge->version = 0; // tracks the number of alternatives
456 add_edge_to_node(parent_node
, or_edge
);
460 edge
= xmalloc(sizeof(edge_t
));
461 edge
->type
= edge_type
;
463 /* Skip any extra leading spaces */
464 field2
+= strspn(field2
, " ");
466 /* Get dependency version info */
467 version
= strchr(field2
, '(');
468 if (version
== NULL
) {
469 edge
->operator = VER_ANY
;
470 /* Get the versions hash number, adding it if the number isnt already in there */
471 edge
->version
= search_name_hashtable("ANY");
473 /* Skip leading ' ' or '(' */
474 version
+= strspn(version
, " (");
475 /* Calculate length of any operator characters */
476 offset_ch
= strspn(version
, "<=>");
477 /* Determine operator */
479 if (strncmp(version
, "=", offset_ch
) == 0) {
480 edge
->operator = VER_EQUAL
;
481 } else if (strncmp(version
, "<<", offset_ch
) == 0) {
482 edge
->operator = VER_LESS
;
483 } else if (strncmp(version
, "<=", offset_ch
) == 0) {
484 edge
->operator = VER_LESS_EQUAL
;
485 } else if (strncmp(version
, ">>", offset_ch
) == 0) {
486 edge
->operator = VER_MORE
;
487 } else if (strncmp(version
, ">=", offset_ch
) == 0) {
488 edge
->operator = VER_MORE_EQUAL
;
490 bb_error_msg_and_die("illegal operator");
493 /* skip to start of version numbers */
494 version
+= offset_ch
;
495 version
+= strspn(version
, " ");
497 /* Truncate version at trailing ' ' or ')' */
498 version
[strcspn(version
, " )")] = '\0';
499 /* Get the versions hash number, adding it if the number isnt already in there */
500 edge
->version
= search_name_hashtable(version
);
503 /* Get the dependency name */
504 field2
[strcspn(field2
, " (")] = '\0';
505 edge
->name
= search_name_hashtable(field2
);
510 add_edge_to_node(parent_node
, edge
);
511 field2
= strtok_r(NULL
, "|", &line_ptr2
);
512 } while (field2
!= NULL
);
515 field
= strtok_r(NULL
, ",", &line_ptr1
);
516 } while (field
!= NULL
);
521 static void free_package(common_node_t
*node
)
525 for (i
= 0; i
< node
->num_of_edges
; i
++) {
534 * Gets the next package field from package_buffer, separated into the field name
535 * and field value, it returns the int offset to the first character of the next field
537 static int read_package_field(const char *package_buffer
, char **field_name
, char **field_value
)
539 int offset_name_start
= 0;
540 int offset_name_end
= 0;
541 int offset_value_start
= 0;
542 int offset_value_end
= 0;
547 int exit_flag
= FALSE
;
549 if (package_buffer
== NULL
) {
555 next_offset
= offset
+ 1;
556 switch (package_buffer
[offset
]) {
561 if (offset_name_end
== 0) {
562 offset_name_end
= offset
;
563 offset_value_start
= next_offset
;
565 /* TODO: Name might still have trailing spaces if ':' isnt
566 * immediately after name */
569 /* TODO: The char next_offset may be out of bounds */
570 if (package_buffer
[next_offset
] != ' ') {
576 /* increment the value start point if its a just filler */
577 if (offset_name_start
== offset
) {
580 if (offset_value_start
== offset
) {
581 offset_value_start
++;
586 /* Check that the names are valid */
587 offset_value_end
= offset
;
588 name_length
= offset_name_end
- offset_name_start
;
589 value_length
= offset_value_end
- offset_value_start
;
590 if (name_length
== 0) {
593 if ((name_length
> 0) && (value_length
> 0)) {
597 /* If not valid, start fresh with next field */
599 offset_name_start
= offset
+ 1;
601 offset_value_start
= offset
+ 1;
602 offset_value_end
= offset
+ 1;
609 *field_name
= xstrndup(&package_buffer
[offset_name_start
], name_length
);
612 if (value_length
> 0) {
613 *field_value
= xstrndup(&package_buffer
[offset_value_start
], value_length
);
618 static unsigned fill_package_struct(char *control_buffer
)
620 static const char field_names
[] ALIGN1
=
621 "Package\0""Version\0"
622 "Pre-Depends\0""Depends\0""Replaces\0""Provides\0"
623 "Conflicts\0""Suggests\0""Recommends\0""Enhances\0";
625 common_node_t
*new_node
= xzalloc(sizeof(common_node_t
));
630 int buffer_length
= strlen(control_buffer
);
632 new_node
->version
= search_name_hashtable("unknown");
633 while (field_start
< buffer_length
) {
636 field_start
+= read_package_field(&control_buffer
[field_start
],
637 &field_name
, &field_value
);
639 if (field_name
== NULL
) {
640 goto fill_package_struct_cleanup
;
643 field_num
= index_in_strings(field_names
, field_name
);
645 case 0: /* Package */
646 new_node
->name
= search_name_hashtable(field_value
);
648 case 1: /* Version */
649 new_node
->version
= search_name_hashtable(field_value
);
651 case 2: /* Pre-Depends */
652 add_split_dependencies(new_node
, field_value
, EDGE_PRE_DEPENDS
);
654 case 3: /* Depends */
655 add_split_dependencies(new_node
, field_value
, EDGE_DEPENDS
);
657 case 4: /* Replaces */
658 add_split_dependencies(new_node
, field_value
, EDGE_REPLACES
);
660 case 5: /* Provides */
661 add_split_dependencies(new_node
, field_value
, EDGE_PROVIDES
);
663 case 6: /* Conflicts */
664 add_split_dependencies(new_node
, field_value
, EDGE_CONFLICTS
);
666 case 7: /* Suggests */
667 add_split_dependencies(new_node
, field_value
, EDGE_SUGGESTS
);
669 case 8: /* Recommends */
670 add_split_dependencies(new_node
, field_value
, EDGE_RECOMMENDS
);
672 case 9: /* Enhances */
673 add_split_dependencies(new_node
, field_value
, EDGE_ENHANCES
);
676 fill_package_struct_cleanup
:
681 if (new_node
->version
== search_name_hashtable("unknown")) {
682 free_package(new_node
);
685 num
= search_package_hashtable(new_node
->name
, new_node
->version
, VER_EQUAL
);
686 free_package(package_hashtable
[num
]);
687 package_hashtable
[num
] = new_node
;
691 /* if num = 1, it returns the want status, 2 returns flag, 3 returns status */
692 static unsigned get_status(const unsigned status_node
, const int num
)
694 char *status_string
= name_hashtable
[status_hashtable
[status_node
]->status
];
695 char *state_sub_string
;
696 unsigned state_sub_num
;
700 /* set tmp_string to point to the start of the word number */
701 for (i
= 1; i
< num
; i
++) {
702 /* skip past a word */
703 status_string
+= strcspn(status_string
, " ");
704 /* skip past the separating spaces */
705 status_string
+= strspn(status_string
, " ");
707 len
= strcspn(status_string
, " \n");
708 state_sub_string
= xstrndup(status_string
, len
);
709 state_sub_num
= search_name_hashtable(state_sub_string
);
710 free(state_sub_string
);
711 return state_sub_num
;
714 static void set_status(const unsigned status_node_num
, const char *new_value
, const int position
)
716 const unsigned new_value_num
= search_name_hashtable(new_value
);
717 unsigned want
= get_status(status_node_num
, 1);
718 unsigned flag
= get_status(status_node_num
, 2);
719 unsigned status
= get_status(status_node_num
, 3);
724 want
= new_value_num
;
727 flag
= new_value_num
;
730 status
= new_value_num
;
733 bb_error_msg_and_die("DEBUG ONLY: this shouldnt happen");
736 new_status
= xasprintf("%s %s %s", name_hashtable
[want
], name_hashtable
[flag
], name_hashtable
[status
]);
737 status_hashtable
[status_node_num
]->status
= search_name_hashtable(new_status
);
741 static const char *describe_status(int status_num
)
743 int status_want
, status_state
;
744 if (status_hashtable
[status_num
] == NULL
|| status_hashtable
[status_num
]->status
== 0)
745 return "is not installed or flagged to be installed";
747 status_want
= get_status(status_num
, 1);
748 status_state
= get_status(status_num
, 3);
750 if (status_state
== search_name_hashtable("installed")) {
751 if (status_want
== search_name_hashtable("install"))
752 return "is installed";
753 if (status_want
== search_name_hashtable("deinstall"))
754 return "is marked to be removed";
755 if (status_want
== search_name_hashtable("purge"))
756 return "is marked to be purged";
758 if (status_want
== search_name_hashtable("unknown"))
759 return "is in an indeterminate state";
760 if (status_want
== search_name_hashtable("install"))
761 return "is marked to be installed";
763 return "is not installed or flagged to be installed";
766 static void index_status_file(const char *filename
)
769 char *control_buffer
;
771 status_node_t
*status_node
= NULL
;
774 status_file
= xfopen_for_read(filename
);
775 while ((control_buffer
= xmalloc_fgetline_str(status_file
, "\n\n")) != NULL
) {
776 const unsigned package_num
= fill_package_struct(control_buffer
);
777 if (package_num
!= -1) {
778 status_node
= xmalloc(sizeof(status_node_t
));
779 /* fill_package_struct doesnt handle the status field */
780 status_line
= strstr(control_buffer
, "Status:");
781 if (status_line
!= NULL
) {
783 status_line
+= strspn(status_line
, " \n\t");
784 status_line
= xstrndup(status_line
, strcspn(status_line
, "\n"));
785 status_node
->status
= search_name_hashtable(status_line
);
788 status_node
->package
= package_num
;
789 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[status_node
->package
]->name
]);
790 status_hashtable
[status_num
] = status_node
;
792 free(control_buffer
);
797 static void write_buffer_no_status(FILE *new_status_file
, const char *control_buffer
)
803 start
+= read_package_field(&control_buffer
[start
], &name
, &value
);
807 if (strcmp(name
, "Status") != 0) {
808 fprintf(new_status_file
, "%s: %s\n", name
, value
);
813 /* This could do with a cleanup */
814 static void write_status_file(deb_file_t
**deb_file
)
816 FILE *old_status_file
= xfopen_for_read("/var/lib/dpkg/status");
817 FILE *new_status_file
= xfopen_for_write("/var/lib/dpkg/status.udeb");
819 char *status_from_file
;
820 char *control_buffer
= NULL
;
827 /* Update previously known packages */
828 while ((control_buffer
= xmalloc_fgetline_str(old_status_file
, "\n\n")) != NULL
) {
829 tmp_string
= strstr(control_buffer
, "Package:");
830 if (tmp_string
== NULL
) {
835 tmp_string
+= strspn(tmp_string
, " \n\t");
836 package_name
= xstrndup(tmp_string
, strcspn(tmp_string
, "\n"));
838 tmp_string
= strstr(control_buffer
, "Status:");
839 if (tmp_string
!= NULL
) {
840 /* Separate the status value from the control buffer */
842 tmp_string
+= strspn(tmp_string
, " \n\t");
843 status_from_file
= xstrndup(tmp_string
, strcspn(tmp_string
, "\n"));
845 status_from_file
= NULL
;
848 /* Find this package in the status hashtable */
849 status_num
= search_status_hashtable(package_name
);
850 if (status_hashtable
[status_num
] != NULL
) {
851 const char *status_from_hashtable
= name_hashtable
[status_hashtable
[status_num
]->status
];
852 if (strcmp(status_from_file
, status_from_hashtable
) != 0) {
853 /* New status isnt exactly the same as old status */
854 const int state_status
= get_status(status_num
, 3);
855 if ((strcmp("installed", name_hashtable
[state_status
]) == 0)
856 || (strcmp("unpacked", name_hashtable
[state_status
]) == 0)
858 /* We need to add the control file from the package */
860 while (deb_file
[i
] != NULL
) {
861 if (strcmp(package_name
, name_hashtable
[package_hashtable
[deb_file
[i
]->package
]->name
]) == 0) {
862 /* Write a status file entry with a modified status */
863 /* remove trailing \n's */
864 write_buffer_no_status(new_status_file
, deb_file
[i
]->control_file
);
865 set_status(status_num
, "ok", 2);
866 fprintf(new_status_file
, "Status: %s\n\n",
867 name_hashtable
[status_hashtable
[status_num
]->status
]);
873 /* This is temperary, debugging only */
874 if (deb_file
[i
] == NULL
) {
875 bb_error_msg_and_die("ALERT: cannot find a control file, "
876 "your status file may be broken, status may be "
877 "incorrect for %s", package_name
);
880 else if (strcmp("not-installed", name_hashtable
[state_status
]) == 0) {
881 /* Only write the Package, Status, Priority and Section lines */
882 fprintf(new_status_file
, "Package: %s\n", package_name
);
883 fprintf(new_status_file
, "Status: %s\n", status_from_hashtable
);
888 field_start
+= read_package_field(&control_buffer
[field_start
], &field_name
, &field_value
);
889 if (field_name
== NULL
) {
892 if ((strcmp(field_name
, "Priority") == 0)
893 || (strcmp(field_name
, "Section") == 0)
895 fprintf(new_status_file
, "%s: %s\n", field_name
, field_value
);
899 fputs("\n", new_status_file
);
901 else if (strcmp("config-files", name_hashtable
[state_status
]) == 0) {
902 /* only change the status line */
906 field_start
+= read_package_field(&control_buffer
[field_start
], &field_name
, &field_value
);
907 if (field_name
== NULL
) {
910 /* Setup start point for next field */
911 if (strcmp(field_name
, "Status") == 0) {
912 fprintf(new_status_file
, "Status: %s\n", status_from_hashtable
);
914 fprintf(new_status_file
, "%s: %s\n", field_name
, field_value
);
918 fputs("\n", new_status_file
);
922 /* If the package from the status file wasnt handle above, do it now*/
924 fprintf(new_status_file
, "%s\n\n", control_buffer
);
927 free(status_from_file
);
929 free(control_buffer
);
932 /* Write any new packages */
933 for (i
= 0; deb_file
[i
] != NULL
; i
++) {
934 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[deb_file
[i
]->package
]->name
]);
935 if (strcmp("reinstreq", name_hashtable
[get_status(status_num
, 2)]) == 0) {
936 write_buffer_no_status(new_status_file
, deb_file
[i
]->control_file
);
937 set_status(status_num
, "ok", 2);
938 fprintf(new_status_file
, "Status: %s\n\n", name_hashtable
[status_hashtable
[status_num
]->status
]);
941 fclose(old_status_file
);
942 fclose(new_status_file
);
944 /* Create a separate backfile to dpkg */
945 if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
947 bb_error_msg_and_die("can't create backup status file");
948 /* Its ok if renaming the status file fails because status
949 * file doesnt exist, maybe we are starting from scratch */
950 bb_error_msg("no status file found, creating new one");
953 xrename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status");
956 /* This function returns TRUE if the given package can satisfy a
957 * dependency of type depend_type.
959 * A pre-depends is satisfied only if a package is already installed,
960 * which a regular depends can be satisfied by a package which we want
963 static int package_satisfies_dependency(int package
, int depend_type
)
965 int status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package
]->name
]);
967 /* status could be unknown if package is a pure virtual
968 * provides which cannot satisfy any dependency by itself.
970 if (status_hashtable
[status_num
] == NULL
)
973 switch (depend_type
) {
974 case EDGE_PRE_DEPENDS
: return get_status(status_num
, 3) == search_name_hashtable("installed");
975 case EDGE_DEPENDS
: return get_status(status_num
, 1) == search_name_hashtable("install");
980 static int check_deps(deb_file_t
**deb_file
, int deb_start
/*, int dep_max_count - ?? */)
982 int *conflicts
= NULL
;
983 int conflicts_num
= 0;
987 /* Check for conflicts
988 * TODO: TEST if conflicts with other packages to be installed
990 * Add install packages and the packages they provide
991 * to the list of files to check conflicts for
994 /* Create array of package numbers to check against
995 * installed package for conflicts*/
996 while (deb_file
[i
] != NULL
) {
997 const unsigned package_num
= deb_file
[i
]->package
;
998 conflicts
= xrealloc_vector(conflicts
, 2, conflicts_num
);
999 conflicts
[conflicts_num
] = package_num
;
1001 /* add provides to conflicts list */
1002 for (j
= 0; j
< package_hashtable
[package_num
]->num_of_edges
; j
++) {
1003 if (package_hashtable
[package_num
]->edge
[j
]->type
== EDGE_PROVIDES
) {
1004 const int conflicts_package_num
= search_package_hashtable(
1005 package_hashtable
[package_num
]->edge
[j
]->name
,
1006 package_hashtable
[package_num
]->edge
[j
]->version
,
1007 package_hashtable
[package_num
]->edge
[j
]->operator);
1008 if (package_hashtable
[conflicts_package_num
] == NULL
) {
1009 /* create a new package */
1010 common_node_t
*new_node
= xzalloc(sizeof(common_node_t
));
1011 new_node
->name
= package_hashtable
[package_num
]->edge
[j
]->name
;
1012 new_node
->version
= package_hashtable
[package_num
]->edge
[j
]->version
;
1013 package_hashtable
[conflicts_package_num
] = new_node
;
1015 conflicts
= xrealloc_vector(conflicts
, 2, conflicts_num
);
1016 conflicts
[conflicts_num
] = conflicts_package_num
;
1023 /* Check conflicts */
1025 while (deb_file
[i
] != NULL
) {
1026 const common_node_t
*package_node
= package_hashtable
[deb_file
[i
]->package
];
1028 status_num
= search_status_hashtable(name_hashtable
[package_node
->name
]);
1030 if (get_status(status_num
, 3) == search_name_hashtable("installed")) {
1035 for (j
= 0; j
< package_node
->num_of_edges
; j
++) {
1036 const edge_t
*package_edge
= package_node
->edge
[j
];
1038 if (package_edge
->type
== EDGE_CONFLICTS
) {
1039 const unsigned package_num
=
1040 search_package_hashtable(package_edge
->name
,
1041 package_edge
->version
,
1042 package_edge
->operator);
1044 if (package_hashtable
[package_num
] != NULL
) {
1045 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package_num
]->name
]);
1047 if (get_status(status_num
, 1) == search_name_hashtable("install")) {
1048 result
= test_version(package_hashtable
[deb_file
[i
]->package
]->version
,
1049 package_edge
->version
, package_edge
->operator);
1054 bb_error_msg_and_die("package %s conflicts with %s",
1055 name_hashtable
[package_node
->name
],
1056 name_hashtable
[package_edge
->name
]);
1064 /* Check dependendcies */
1065 for (i
= 0; i
< PACKAGE_HASH_PRIME
; i
++) {
1067 int number_of_alternatives
= 0;
1068 const edge_t
* root_of_alternatives
= NULL
;
1069 const common_node_t
*package_node
= package_hashtable
[i
];
1071 /* If the package node does not exist then this
1072 * package is a virtual one. In which case there are
1073 * no dependencies to check.
1075 if (package_node
== NULL
) continue;
1077 status_num
= search_status_hashtable(name_hashtable
[package_node
->name
]);
1079 /* If there is no status then this package is a
1080 * virtual one provided by something else. In which
1081 * case there are no dependencies to check.
1083 if (status_hashtable
[status_num
] == NULL
) continue;
1085 /* If we don't want this package installed then we may
1086 * as well ignore it's dependencies.
1088 if (get_status(status_num
, 1) != search_name_hashtable("install")) {
1092 /* This code is tested only for EDGE_DEPENDS, since I
1093 * have no suitable pre-depends available. There is no
1094 * reason that it shouldn't work though :-)
1096 for (j
= 0; j
< package_node
->num_of_edges
; j
++) {
1097 const edge_t
*package_edge
= package_node
->edge
[j
];
1098 unsigned package_num
;
1100 if (package_edge
->type
== EDGE_OR_PRE_DEPENDS
1101 || package_edge
->type
== EDGE_OR_DEPENDS
1103 /* start an EDGE_OR_ list */
1104 number_of_alternatives
= package_edge
->version
;
1105 root_of_alternatives
= package_edge
;
1108 if (number_of_alternatives
== 0) { /* not in the middle of an EDGE_OR_ list */
1109 number_of_alternatives
= 1;
1110 root_of_alternatives
= NULL
;
1113 package_num
= search_package_hashtable(package_edge
->name
, package_edge
->version
, package_edge
->operator);
1115 if (package_edge
->type
== EDGE_PRE_DEPENDS
1116 || package_edge
->type
== EDGE_DEPENDS
1121 /* If we are inside an alternative then check
1122 * this edge is the right type.
1124 * EDGE_DEPENDS == OR_DEPENDS -1
1125 * EDGE_PRE_DEPENDS == OR_PRE_DEPENDS -1
1127 if (root_of_alternatives
&& package_edge
->type
!= root_of_alternatives
->type
- 1)
1128 bb_error_msg_and_die("fatal error, package dependencies corrupt: %d != %d - 1",
1129 package_edge
->type
, root_of_alternatives
->type
);
1131 if (package_hashtable
[package_num
] != NULL
)
1132 result
= !package_satisfies_dependency(package_num
, package_edge
->type
);
1134 if (result
) { /* check for other package which provide what we are looking for */
1137 while ((provider
= search_for_provides(package_edge
->name
, provider
)) > -1) {
1138 if (package_hashtable
[provider
] == NULL
) {
1139 puts("Have a provider but no package information for it");
1142 result
= !package_satisfies_dependency(provider
, package_edge
->type
);
1149 /* It must be already installed, or to be installed */
1150 number_of_alternatives
--;
1151 if (result
&& number_of_alternatives
== 0) {
1152 if (root_of_alternatives
)
1153 bb_error_msg_and_die(
1154 "package %s %sdepends on %s, "
1155 "which cannot be satisfied",
1156 name_hashtable
[package_node
->name
],
1157 package_edge
->type
== EDGE_PRE_DEPENDS
? "pre-" : "",
1158 name_hashtable
[root_of_alternatives
->name
]);
1159 bb_error_msg_and_die(
1160 "package %s %sdepends on %s, which %s\n",
1161 name_hashtable
[package_node
->name
],
1162 package_edge
->type
== EDGE_PRE_DEPENDS
? "pre-" : "",
1163 name_hashtable
[package_edge
->name
],
1164 describe_status(status_num
));
1166 if (result
== 0 && number_of_alternatives
) {
1167 /* we've found a package which
1168 * satisfies the dependency,
1169 * so skip over the rest of
1172 j
+= number_of_alternatives
;
1173 number_of_alternatives
= 0;
1182 static char **create_list(const char *filename
)
1189 /* don't use [xw]fopen here, handle error ourself */
1190 list_stream
= fopen_for_read(filename
);
1191 if (list_stream
== NULL
) {
1197 while ((line
= xmalloc_fgetline(list_stream
)) != NULL
) {
1198 file_list
= xrealloc_vector(file_list
, 2, count
);
1199 file_list
[count
++] = line
;
1200 /*file_list[count] = NULL; - xrealloc_vector did it */
1202 fclose(list_stream
);
1207 /* maybe i should try and hook this into remove_file.c somehow */
1208 static int remove_file_array(char **remove_names
, char **exclude_names
)
1210 struct stat path_stat
;
1211 int remove_flag
= 1; /* not removed anything yet */
1214 if (remove_names
== NULL
) {
1217 for (i
= 0; remove_names
[i
] != NULL
; i
++) {
1218 if (exclude_names
!= NULL
) {
1219 for (j
= 0; exclude_names
[j
] != NULL
; j
++) {
1220 if (strcmp(remove_names
[i
], exclude_names
[j
]) == 0) {
1225 /* TODO: why we are checking lstat? we can just try rm/rmdir */
1226 if (lstat(remove_names
[i
], &path_stat
) < 0) {
1229 if (S_ISDIR(path_stat
.st_mode
)) {
1230 remove_flag
&= rmdir(remove_names
[i
]); /* 0 if no error */
1232 remove_flag
&= unlink(remove_names
[i
]); /* 0 if no error */
1237 return (remove_flag
== 0);
1240 static void run_package_script_or_die(const char *package_name
, const char *script_type
)
1245 script_path
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, script_type
);
1247 /* If the file doesnt exist is isnt fatal */
1248 result
= access(script_path
, F_OK
) ? EXIT_SUCCESS
: system(script_path
);
1251 bb_error_msg_and_die("%s failed, exit code %d", script_type
, result
);
1255 The policy manual defines what scripts get called when and with
1256 what arguments. I realize that busybox does not support all of
1257 these scenarios, but it does support some of them; it does not,
1258 however, run them with any parameters in run_package_script_or_die().
1259 Here are the scripts:
1262 preinst install <old_version>
1263 preinst upgrade <old_version>
1264 preinst abort_upgrade <new_version>
1265 postinst configure <most_recent_version>
1266 postinst abort-upgade <new_version>
1267 postinst abort-remove
1268 postinst abort-remove in-favour <package> <version>
1269 postinst abort-deconfigure in-favor <failed_install_package> removing <conflicting_package> <version>
1271 prerm upgrade <new_version>
1272 prerm failed-upgrade <old_version>
1273 prerm remove in-favor <package> <new_version>
1274 prerm deconfigure in-favour <package> <version> removing <package> <version>
1277 postrm upgrade <new_version>
1278 postrm failed-upgrade <old_version>
1279 postrm abort-install
1280 postrm abort-install <old_version>
1281 postrm abort-upgrade <old_version>
1282 postrm disappear <overwriter> <version>
1284 static const char *const all_control_files
[] = {
1285 "preinst", "postinst", "prerm", "postrm",
1286 "list", "md5sums", "shlibs", "conffiles",
1287 "config", "templates"
1290 static char **all_control_list(const char *package_name
)
1293 char **remove_files
;
1295 /* Create a list of all /var/lib/dpkg/info/<package> files */
1296 remove_files
= xzalloc(sizeof(all_control_files
) + sizeof(char*));
1297 while (i
< ARRAY_SIZE(all_control_files
)) {
1298 remove_files
[i
] = xasprintf("/var/lib/dpkg/info/%s.%s",
1299 package_name
, all_control_files
[i
]);
1303 return remove_files
;
1306 static void free_array(char **array
)
1318 /* This function lists information on the installed packages. It loops through
1319 * the status_hashtable to retrieve the info. This results in smaller code than
1320 * scanning the status file. The resulting list, however, is unsorted.
1322 static void list_packages(const char *pattern
)
1326 puts(" Name Version");
1327 puts("+++-==============-==============");
1329 /* go through status hash, dereference package hash and finally strings */
1330 for (i
= 0; i
< STATUS_HASH_PRIME
+1; i
++) {
1331 if (status_hashtable
[i
]) {
1332 const char *stat_str
; /* status string */
1333 const char *name_str
; /* package name */
1334 const char *vers_str
; /* version */
1335 char s1
, s2
; /* status abbreviations */
1336 int spccnt
; /* space count */
1339 stat_str
= name_hashtable
[status_hashtable
[i
]->status
];
1340 name_str
= name_hashtable
[package_hashtable
[status_hashtable
[i
]->package
]->name
];
1341 vers_str
= name_hashtable
[package_hashtable
[status_hashtable
[i
]->package
]->version
];
1343 if (pattern
&& fnmatch(pattern
, name_str
, 0) != 0)
1346 /* get abbreviation for status field 1 */
1347 s1
= stat_str
[0] == 'i' ? 'i' : 'r';
1349 /* get abbreviation for status field 2 */
1350 for (j
= 0, spccnt
= 0; stat_str
[j
] && spccnt
< 2; j
++) {
1351 if (stat_str
[j
] == ' ') spccnt
++;
1355 /* print out the line formatted like Debian dpkg */
1356 printf("%c%c %-14s %s\n", s1
, s2
, name_str
, vers_str
);
1361 static void remove_package(const unsigned package_num
, int noisy
)
1363 const char *package_name
= name_hashtable
[package_hashtable
[package_num
]->name
];
1364 const char *package_version
= name_hashtable
[package_hashtable
[package_num
]->version
];
1365 const unsigned status_num
= search_status_hashtable(package_name
);
1366 const int package_name_length
= strlen(package_name
);
1367 char **remove_files
;
1368 char **exclude_files
;
1369 char list_name
[package_name_length
+ 25];
1370 char conffile_name
[package_name_length
+ 30];
1373 printf("Removing %s (%s)...\n", package_name
, package_version
);
1375 /* Run prerm script */
1376 run_package_script_or_die(package_name
, "prerm");
1378 /* Create a list of files to remove, and a separate list of those to keep */
1379 sprintf(list_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "list");
1380 remove_files
= create_list(list_name
);
1382 sprintf(conffile_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "conffiles");
1383 exclude_files
= create_list(conffile_name
);
1385 /* Some directories can't be removed straight away, so do multiple passes */
1386 while (remove_file_array(remove_files
, exclude_files
))
1388 free_array(exclude_files
);
1389 free_array(remove_files
);
1391 /* Create a list of files in /var/lib/dpkg/info/<package>.* to keep */
1392 exclude_files
= xzalloc(sizeof(exclude_files
[0]) * 3);
1393 exclude_files
[0] = xstrdup(conffile_name
);
1394 exclude_files
[1] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "postrm");
1396 /* Create a list of all /var/lib/dpkg/info/<package> files */
1397 remove_files
= all_control_list(package_name
);
1399 remove_file_array(remove_files
, exclude_files
);
1400 free_array(remove_files
);
1401 free_array(exclude_files
);
1403 /* rename <package>.conffiles to <package>.list
1404 * The conffiles control file isn't required in Debian packages, so don't
1405 * error out if it's missing. */
1406 rename(conffile_name
, list_name
);
1408 /* Change package status */
1409 set_status(status_num
, "config-files", 3);
1412 static void purge_package(const unsigned package_num
)
1414 const char *package_name
= name_hashtable
[package_hashtable
[package_num
]->name
];
1415 const char *package_version
= name_hashtable
[package_hashtable
[package_num
]->version
];
1416 const unsigned status_num
= search_status_hashtable(package_name
);
1417 char **remove_files
;
1418 char **exclude_files
;
1419 char list_name
[strlen(package_name
) + 25];
1421 printf("Purging %s (%s)...\n", package_name
, package_version
);
1423 /* Run prerm script */
1424 run_package_script_or_die(package_name
, "prerm");
1426 /* Create a list of files to remove */
1427 sprintf(list_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "list");
1428 remove_files
= create_list(list_name
);
1430 /* Some directories cant be removed straight away, so do multiple passes */
1431 while (remove_file_array(remove_files
, NULL
))
1433 free_array(remove_files
);
1435 /* Create a list of all /var/lib/dpkg/info/<package> files */
1436 remove_files
= all_control_list(package_name
);
1438 /* Delete all of them except the postrm script */
1439 exclude_files
= xzalloc(sizeof(exclude_files
[0]) * 2);
1440 exclude_files
[0] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "postrm");
1441 remove_file_array(remove_files
, exclude_files
);
1442 free_array(exclude_files
);
1444 /* Run and remove postrm script */
1445 run_package_script_or_die(package_name
, "postrm");
1446 remove_file_array(remove_files
, NULL
);
1448 free_array(remove_files
);
1450 /* Change package status */
1451 set_status(status_num
, "not-installed", 3);
1454 static archive_handle_t
*init_archive_deb_ar(const char *filename
)
1456 archive_handle_t
*ar_handle
;
1458 /* Setup an ar archive handle that refers to the gzip sub archive */
1459 ar_handle
= init_handle();
1460 ar_handle
->filter
= filter_accept_list_reassign
;
1461 ar_handle
->src_fd
= xopen(filename
, O_RDONLY
);
1466 static void init_archive_deb_control(archive_handle_t
*ar_handle
)
1468 archive_handle_t
*tar_handle
;
1470 /* Setup the tar archive handle */
1471 tar_handle
= init_handle();
1472 tar_handle
->src_fd
= ar_handle
->src_fd
;
1474 /* We don't care about data.tar.* or debian-binary, just control.tar.* */
1475 #if ENABLE_FEATURE_SEAMLESS_GZ
1476 llist_add_to(&(ar_handle
->accept
), (char*)"control.tar.gz");
1478 #if ENABLE_FEATURE_SEAMLESS_BZ2
1479 llist_add_to(&(ar_handle
->accept
), (char*)"control.tar.bz2");
1482 /* Assign the tar handle as a subarchive of the ar handle */
1483 ar_handle
->dpkg__sub_archive
= tar_handle
;
1486 static void init_archive_deb_data(archive_handle_t
*ar_handle
)
1488 archive_handle_t
*tar_handle
;
1490 /* Setup the tar archive handle */
1491 tar_handle
= init_handle();
1492 tar_handle
->src_fd
= ar_handle
->src_fd
;
1494 /* We don't care about control.tar.* or debian-binary, just data.tar.* */
1495 #if ENABLE_FEATURE_SEAMLESS_GZ
1496 llist_add_to(&(ar_handle
->accept
), (char*)"data.tar.gz");
1498 #if ENABLE_FEATURE_SEAMLESS_BZ2
1499 llist_add_to(&(ar_handle
->accept
), (char*)"data.tar.bz2");
1502 /* Assign the tar handle as a subarchive of the ar handle */
1503 ar_handle
->dpkg__sub_archive
= tar_handle
;
1506 static void FAST_FUNC
data_extract_to_buffer(archive_handle_t
*archive_handle
)
1508 unsigned size
= archive_handle
->file_header
->size
;
1510 archive_handle
->dpkg__buffer
= xzalloc(size
+ 1);
1511 xread(archive_handle
->src_fd
, archive_handle
->dpkg__buffer
, size
);
1514 static char *deb_extract_control_file_to_buffer(archive_handle_t
*ar_handle
, llist_t
*myaccept
)
1516 ar_handle
->dpkg__sub_archive
->action_data
= data_extract_to_buffer
;
1517 ar_handle
->dpkg__sub_archive
->accept
= myaccept
;
1518 ar_handle
->dpkg__sub_archive
->filter
= filter_accept_list
;
1520 unpack_ar_archive(ar_handle
);
1521 close(ar_handle
->src_fd
);
1523 return ar_handle
->dpkg__sub_archive
->dpkg__buffer
;
1526 static void append_control_file_to_llist(const char *package_name
, const char *control_name
, llist_t
**ll
)
1529 char *filename
, *line
;
1531 filename
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, control_name
);
1532 fp
= fopen_for_read(filename
);
1535 while ((line
= xmalloc_fgetline(fp
)) != NULL
)
1536 llist_add_to(ll
, line
);
1541 static char FAST_FUNC
filter_rename_config(archive_handle_t
*archive_handle
)
1544 char *name_ptr
= archive_handle
->file_header
->name
+ 1;
1546 /* Is this file marked as config file? */
1547 if (!find_list_entry(archive_handle
->accept
, name_ptr
))
1548 return EXIT_SUCCESS
; /* no */
1550 fd
= open(name_ptr
, O_RDONLY
);
1553 char *md5line
, *buf
;
1556 /* Calculate MD5 of existing file */
1557 buf
= xmalloc(4096);
1559 while ((count
= safe_read(fd
, buf
, 4096)) > 0)
1560 md5_hash(&md5
, buf
, count
);
1561 md5_end(&md5
, buf
); /* using buf as result storage */
1564 md5line
= xmalloc(16 * 2 + 2 + strlen(name_ptr
) + 1);
1565 sprintf(bin2hex(md5line
, buf
, 16), " %s", name_ptr
);
1568 /* Is it changed after install? */
1569 if (find_list_entry(archive_handle
->accept
, md5line
) == NULL
) {
1570 printf("Warning: Creating %s as %s.dpkg-new\n", name_ptr
, name_ptr
);
1571 archive_handle
->file_header
->name
= xasprintf("%s.dpkg-new", archive_handle
->file_header
->name
);
1575 return EXIT_SUCCESS
;
1578 static void FAST_FUNC
data_extract_all_prefix(archive_handle_t
*archive_handle
)
1580 char *name_ptr
= archive_handle
->file_header
->name
;
1582 /* Skip all leading "/" */
1583 while (*name_ptr
== '/')
1585 /* Skip all leading "./" and "../" */
1586 while (name_ptr
[0] == '.') {
1587 if (name_ptr
[1] == '.')
1589 if (name_ptr
[1] != '/')
1594 if (name_ptr
[0] != '\0') {
1595 archive_handle
->file_header
->name
= xasprintf("%s%s", archive_handle
->dpkg__buffer
, name_ptr
);
1596 data_extract_all(archive_handle
);
1597 if (fnmatch("*.dpkg-new", archive_handle
->file_header
->name
, 0) == 0) {
1598 /* remove .dpkg-new suffix */
1599 archive_handle
->file_header
->name
[strlen(archive_handle
->file_header
->name
) - 9] = '\0';
1606 OPT_configure
= (1 << 0),
1607 OPT_install
= (1 << 1),
1608 OPT_list_installed
= (1 << 2),
1609 OPT_purge
= (1 << 3),
1610 OPT_remove
= (1 << 4),
1611 OPT_unpack
= (1 << 5),
1612 OPTMASK_cmd
= (1 << 6) - 1,
1614 OPT_force
= (1 << 6),
1615 OPT_force_ignore_depends
= (1 << 7),
1616 OPT_force_confnew
= (1 << 8),
1617 OPT_force_confold
= (1 << 9),
1620 static void unpack_package(deb_file_t
*deb_file
)
1622 const char *package_name
= name_hashtable
[package_hashtable
[deb_file
->package
]->name
];
1623 const unsigned status_num
= search_status_hashtable(package_name
);
1624 const unsigned status_package_num
= status_hashtable
[status_num
]->package
;
1626 char *list_filename
;
1627 archive_handle_t
*archive_handle
;
1629 llist_t
*accept_list
;
1630 llist_t
*conffile_list
;
1633 /* If existing version, remove it first */
1634 conffile_list
= NULL
;
1635 if (strcmp(name_hashtable
[get_status(status_num
, 3)], "installed") == 0) {
1636 /* Package is already installed, remove old version first */
1637 printf("Preparing to replace %s %s (using %s)...\n", package_name
,
1638 name_hashtable
[package_hashtable
[status_package_num
]->version
],
1639 deb_file
->filename
);
1641 /* Read md5sums from old package */
1642 if (!(option_mask32
& OPT_force_confold
))
1643 append_control_file_to_llist(package_name
, "md5sums", &conffile_list
);
1645 remove_package(status_package_num
, 0);
1647 printf("Unpacking %s (from %s)...\n", package_name
, deb_file
->filename
);
1650 /* Extract control.tar.gz to /var/lib/dpkg/info/<package>.filename */
1651 info_prefix
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "");
1652 archive_handle
= init_archive_deb_ar(deb_file
->filename
);
1653 init_archive_deb_control(archive_handle
);
1657 while (i
< ARRAY_SIZE(all_control_files
)) {
1658 char *c
= xasprintf("./%s", all_control_files
[i
]);
1659 llist_add_to(&accept_list
, c
);
1662 archive_handle
->dpkg__sub_archive
->accept
= accept_list
;
1663 archive_handle
->dpkg__sub_archive
->filter
= filter_accept_list
;
1664 archive_handle
->dpkg__sub_archive
->action_data
= data_extract_all_prefix
;
1665 archive_handle
->dpkg__sub_archive
->dpkg__buffer
= info_prefix
;
1666 archive_handle
->dpkg__sub_archive
->ah_flags
|= ARCHIVE_UNLINK_OLD
;
1667 unpack_ar_archive(archive_handle
);
1669 /* Run the preinst prior to extracting */
1670 run_package_script_or_die(package_name
, "preinst");
1672 /* Don't overwrite existing config files */
1673 if (!(option_mask32
& OPT_force_confnew
))
1674 append_control_file_to_llist(package_name
, "conffiles", &conffile_list
);
1676 /* Extract data.tar.gz to the root directory */
1677 archive_handle
= init_archive_deb_ar(deb_file
->filename
);
1678 init_archive_deb_data(archive_handle
);
1679 archive_handle
->dpkg__sub_archive
->accept
= conffile_list
;
1680 /* Why ARCHIVE_REMEMBER_NAMES?
1681 * We want names collected in ->passed list even if conffile_list
1682 * is NULL (otherwise get_header_tar may optimize name saving out):
1684 archive_handle
->dpkg__sub_archive
->ah_flags
|= ARCHIVE_REMEMBER_NAMES
| ARCHIVE_UNLINK_OLD
;
1685 archive_handle
->dpkg__sub_archive
->filter
= filter_rename_config
;
1686 archive_handle
->dpkg__sub_archive
->action_data
= data_extract_all_prefix
;
1687 archive_handle
->dpkg__sub_archive
->dpkg__buffer
= (char*)"/"; /* huh? */
1688 unpack_ar_archive(archive_handle
);
1690 /* Create the list file */
1691 list_filename
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "list");
1692 out_stream
= xfopen_for_write(list_filename
);
1693 archive_handle
->dpkg__sub_archive
->passed
= llist_rev(archive_handle
->dpkg__sub_archive
->passed
);
1694 while (archive_handle
->dpkg__sub_archive
->passed
) {
1695 char *filename
= llist_pop(&archive_handle
->dpkg__sub_archive
->passed
);
1696 /* the leading . has been stripped by data_extract_all_prefix already */
1697 fprintf(out_stream
, "%s\n", filename
);
1703 set_status(status_num
, "install", 1);
1704 set_status(status_num
, "unpacked", 3);
1707 free(list_filename
);
1710 static void configure_package(deb_file_t
*deb_file
)
1712 const char *package_name
= name_hashtable
[package_hashtable
[deb_file
->package
]->name
];
1713 const char *package_version
= name_hashtable
[package_hashtable
[deb_file
->package
]->version
];
1714 const int status_num
= search_status_hashtable(package_name
);
1716 printf("Setting up %s (%s)...\n", package_name
, package_version
);
1718 /* Run the postinst script */
1719 /* TODO: handle failure gracefully */
1720 run_package_script_or_die(package_name
, "postinst");
1722 /* Change status to reflect success */
1723 set_status(status_num
, "install", 1);
1724 set_status(status_num
, "installed", 3);
1727 int dpkg_main(int argc
, char **argv
) MAIN_EXTERNALLY_VISIBLE
;
1728 int dpkg_main(int argc UNUSED_PARAM
, char **argv
)
1730 deb_file_t
**deb_file
= NULL
;
1731 status_node_t
*status_node
;
1739 #if ENABLE_LONG_OPTS
1740 static const char dpkg_longopts
[] ALIGN1
=
1741 // FIXME: we use -C non-compatibly, should be:
1742 // "-C|--audit Check for broken package(s)"
1743 "configure\0" No_argument
"C"
1744 "force\0" Required_argument
"F"
1745 "install\0" No_argument
"i"
1746 "list\0" No_argument
"l"
1747 "purge\0" No_argument
"P"
1748 "remove\0" No_argument
"r"
1749 "unpack\0" No_argument
"u"
1750 "force-depends\0" No_argument
"\xff"
1751 "force-confnew\0" No_argument
"\xfe"
1752 "force-confold\0" No_argument
"\xfd"
1758 IF_LONG_OPTS(applet_long_options
= dpkg_longopts
);
1759 opt
= getopt32(argv
, "CilPruF:", &str_f
);
1761 //if (opt & OPT_configure) ... // -C
1762 if (opt
& OPT_force
) { // -F (--force in official dpkg)
1763 if (strcmp(str_f
, "depends") == 0)
1764 opt
|= OPT_force_ignore_depends
;
1765 else if (strcmp(str_f
, "confnew") == 0)
1766 opt
|= OPT_force_confnew
;
1767 else if (strcmp(str_f
, "confold") == 0)
1768 opt
|= OPT_force_confold
;
1771 option_mask32
= opt
;
1773 //if (opt & OPT_install) ... // -i
1774 //if (opt & OPT_list_installed) ... // -l
1775 //if (opt & OPT_purge) ... // -P
1776 //if (opt & OPT_remove) ... // -r
1777 //if (opt & OPT_unpack) ... // -u (--unpack in official dpkg)
1778 if (!(opt
& OPTMASK_cmd
) /* no cmd */
1779 || ((opt
& OPTMASK_cmd
) & ((opt
& OPTMASK_cmd
)-1)) /* more than one cmd */
1784 /* puts("(Reading database ... xxxxx files and directories installed.)"); */
1785 index_status_file("/var/lib/dpkg/status");
1787 /* if the list action was given print the installed packages and exit */
1788 if (opt
& OPT_list_installed
) {
1789 list_packages(argv
[0]); /* param can be NULL */
1790 return EXIT_SUCCESS
;
1793 /* Read arguments and store relevant info in structs */
1795 /* deb_count = nb_elem - 1 and we need nb_elem + 1 to allocate terminal node [NULL pointer] */
1796 deb_file
= xrealloc_vector(deb_file
, 2, deb_count
);
1797 deb_file
[deb_count
] = xzalloc(sizeof(deb_file
[0][0]));
1798 if (opt
& (OPT_install
| OPT_unpack
)) {
1799 /* -i/-u: require filename */
1800 archive_handle_t
*archive_handle
;
1801 llist_t
*control_list
= NULL
;
1803 /* Extract the control file */
1804 llist_add_to(&control_list
, (char*)"./control");
1805 archive_handle
= init_archive_deb_ar(argv
[0]);
1806 init_archive_deb_control(archive_handle
);
1807 deb_file
[deb_count
]->control_file
= deb_extract_control_file_to_buffer(archive_handle
, control_list
);
1808 if (deb_file
[deb_count
]->control_file
== NULL
) {
1809 bb_error_msg_and_die("can't extract control file");
1811 deb_file
[deb_count
]->filename
= xstrdup(argv
[0]);
1812 package_num
= fill_package_struct(deb_file
[deb_count
]->control_file
);
1814 if (package_num
== -1) {
1815 bb_error_msg("invalid control file in %s", argv
[0]);
1819 deb_file
[deb_count
]->package
= (unsigned) package_num
;
1821 /* Add the package to the status hashtable */
1822 if (opt
& (OPT_unpack
| OPT_install
)) {
1823 /* Try and find a currently installed version of this package */
1824 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[deb_file
[deb_count
]->package
]->name
]);
1825 /* If no previous entry was found initialise a new entry */
1826 if (status_hashtable
[status_num
] == NULL
1827 || status_hashtable
[status_num
]->status
== 0
1829 status_node
= xmalloc(sizeof(status_node_t
));
1830 status_node
->package
= deb_file
[deb_count
]->package
;
1831 /* reinstreq isnt changed to "ok" until the package control info
1832 * is written to the status file*/
1833 status_node
->status
= search_name_hashtable("install reinstreq not-installed");
1834 status_hashtable
[status_num
] = status_node
;
1836 set_status(status_num
, "install", 1);
1837 set_status(status_num
, "reinstreq", 2);
1840 } else if (opt
& (OPT_configure
| OPT_purge
| OPT_remove
)) {
1841 /* -C/-p/-r: require package name */
1842 deb_file
[deb_count
]->package
= search_package_hashtable(
1843 search_name_hashtable(argv
[0]),
1844 search_name_hashtable("ANY"), VER_ANY
);
1845 if (package_hashtable
[deb_file
[deb_count
]->package
] == NULL
) {
1846 bb_error_msg_and_die("package %s is uninstalled or unknown", argv
[0]);
1848 package_num
= deb_file
[deb_count
]->package
;
1849 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package_num
]->name
]);
1850 state_status
= get_status(status_num
, 3);
1852 /* check package status is "installed" */
1853 if (opt
& OPT_remove
) {
1854 if (strcmp(name_hashtable
[state_status
], "not-installed") == 0
1855 || strcmp(name_hashtable
[state_status
], "config-files") == 0
1857 bb_error_msg_and_die("%s is already removed", name_hashtable
[package_hashtable
[package_num
]->name
]);
1859 set_status(status_num
, "deinstall", 1);
1860 } else if (opt
& OPT_purge
) {
1861 /* if package status is "conf-files" then its ok */
1862 if (strcmp(name_hashtable
[state_status
], "not-installed") == 0) {
1863 bb_error_msg_and_die("%s is already purged", name_hashtable
[package_hashtable
[package_num
]->name
]);
1865 set_status(status_num
, "purge", 1);
1872 bb_error_msg_and_die("no package files specified");
1873 deb_file
[deb_count
] = NULL
;
1875 /* Check that the deb file arguments are installable */
1876 if (!(opt
& OPT_force_ignore_depends
)) {
1877 if (!check_deps(deb_file
, 0 /*, deb_count*/)) {
1878 bb_error_msg_and_die("dependency check failed");
1882 /* TODO: install or remove packages in the correct dependency order */
1883 for (i
= 0; i
< deb_count
; i
++) {
1884 /* Remove or purge packages */
1885 if (opt
& OPT_remove
) {
1886 remove_package(deb_file
[i
]->package
, 1);
1888 else if (opt
& OPT_purge
) {
1889 purge_package(deb_file
[i
]->package
);
1891 else if (opt
& OPT_unpack
) {
1892 unpack_package(deb_file
[i
]);
1894 else if (opt
& OPT_install
) {
1895 unpack_package(deb_file
[i
]);
1896 /* package is configured in second pass below */
1898 else if (opt
& OPT_configure
) {
1899 configure_package(deb_file
[i
]);
1902 /* configure installed packages */
1903 if (opt
& OPT_install
) {
1904 for (i
= 0; i
< deb_count
; i
++)
1905 configure_package(deb_file
[i
]);
1908 write_status_file(deb_file
);
1910 if (ENABLE_FEATURE_CLEAN_UP
) {
1911 for (i
= 0; i
< deb_count
; i
++) {
1912 free(deb_file
[i
]->control_file
);
1913 free(deb_file
[i
]->filename
);
1919 for (i
= 0; i
< NAME_HASH_PRIME
; i
++) {
1920 free(name_hashtable
[i
]);
1923 for (i
= 0; i
< PACKAGE_HASH_PRIME
; i
++) {
1924 free_package(package_hashtable
[i
]);
1927 for (i
= 0; i
< STATUS_HASH_PRIME
; i
++) {
1928 free(status_hashtable
[i
]);
1931 free(status_hashtable
);
1932 free(package_hashtable
);
1933 free(name_hashtable
);
1936 return EXIT_SUCCESS
;