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.
19 * known difference between busybox dpkg and the official dpkg that i don't
20 * consider important, its worth keeping a note of differences anyway, just to
21 * make it easier to maintain.
22 * - the first value for the confflile: field isnt placed on a new line.
23 * - when installing a package the status: field is placed at the end of the
24 * section, rather than just after the package: field.
26 * bugs that need to be fixed
27 * - (unknown, please let me know when you find any)
31 //usage:#define dpkg_trivial_usage
32 //usage: "[-ilCPru] [-F OPT] PACKAGE"
33 //usage:#define dpkg_full_usage "\n\n"
34 //usage: "Install, remove and manage Debian packages\n"
35 //usage: IF_LONG_OPTS(
36 //usage: "\n -i,--install Install the package"
37 //usage: "\n -l,--list List of installed packages"
38 //usage: "\n --configure Configure an unpackaged package"
39 //usage: "\n -P,--purge Purge all files of a package"
40 //usage: "\n -r,--remove Remove all but the configuration files for a package"
41 //usage: "\n --unpack Unpack a package, but don't configure it"
42 //usage: "\n --force-depends Ignore dependency problems"
43 //usage: "\n --force-confnew Overwrite existing config files when installing"
44 //usage: "\n --force-confold Keep old config files when installing"
46 //usage: IF_NOT_LONG_OPTS(
47 //usage: "\n -i Install the package"
48 //usage: "\n -l List of installed packages"
49 //usage: "\n -C Configure an unpackaged package"
50 //usage: "\n -P Purge all files of a package"
51 //usage: "\n -r Remove all but the configuration files for a package"
52 //usage: "\n -u Unpack a package, but don't configure it"
53 //usage: "\n -F depends Ignore dependency problems"
54 //usage: "\n -F confnew Overwrite existing config files when installing"
55 //usage: "\n -F confold Keep old config files when installing"
60 #include "bb_archive.h"
62 /* note: if you vary hash_prime sizes be aware,
63 * 1) tweaking these will have a big effect on how much memory this program uses.
64 * 2) for computational efficiency these hash tables should be at least 20%
65 * larger than the maximum number of elements stored in it.
66 * 3) all _hash_prime's must be a prime number or chaos is assured, if your looking
67 * for a prime, try http://www.utm.edu/research/primes/lists/small/10000.txt
68 * 4) if you go bigger than 15 bits you may get into trouble (untested) as its
69 * sometimes cast to an unsigned, if you go to 16 bit you will overlap
70 * int's and chaos is assured, 16381 is the max prime for 14 bit field
73 /* NAME_HASH_PRIME, Stores package names and versions,
74 * I estimate it should be at least 50% bigger than PACKAGE_HASH_PRIME,
75 * as there a lot of duplicate version numbers */
76 #define NAME_HASH_PRIME 16381
78 /* PACKAGE_HASH_PRIME, Maximum number of unique packages,
79 * It must not be smaller than STATUS_HASH_PRIME,
80 * Currently only packages from status_hashtable are stored in here, but in
81 * future this may be used to store packages not only from a status file,
82 * but an available_hashtable, and even multiple packages files.
83 * Package can be stored more than once if they have different versions.
84 * e.g. The same package may have different versions in the status file
85 * and available file */
86 #define PACKAGE_HASH_PRIME 10007
87 typedef struct edge_s
{
88 unsigned operator:4; /* was:3 */
90 unsigned name
:16; /* was:14 */
91 unsigned version
:16; /* was:14 */
94 typedef struct common_node_s
{
95 unsigned name
:16; /* was:14 */
96 unsigned version
:16; /* was:14 */
97 unsigned num_of_edges
:16; /* was:14 */
101 /* Currently it doesnt store packages that have state-status of not-installed
102 * So it only really has to be the size of the maximum number of packages
103 * likely to be installed at any one time, so there is a bit of leeway here */
104 #define STATUS_HASH_PRIME 8191
105 typedef struct status_node_s
{
106 unsigned package
:16; /* was:14 */ /* has to fit PACKAGE_HASH_PRIME */
107 unsigned status
:16; /* was:14 */ /* has to fit STATUS_HASH_PRIME */
113 char *name_hashtable
[NAME_HASH_PRIME
+ 1];
114 common_node_t
*package_hashtable
[PACKAGE_HASH_PRIME
+ 1];
115 status_node_t
*status_hashtable
[STATUS_HASH_PRIME
+ 1];
117 #define G (*ptr_to_globals)
118 #define name_hashtable (G.name_hashtable )
119 #define package_hashtable (G.package_hashtable)
120 #define status_hashtable (G.status_hashtable )
121 #define INIT_G() do { \
122 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
126 /* Even numbers are for 'extras', like ored dependencies or null */
129 EDGE_PRE_DEPENDS
= 1,
130 EDGE_OR_PRE_DEPENDS
= 2,
137 EDGE_RECOMMENDS
= 13,
150 typedef struct deb_file_s
{
153 unsigned package
:16; /* was:14 */
157 static void make_hash(const char *key
, unsigned *start
, unsigned *decrement
, const int hash_prime
)
159 unsigned long hash_num
= key
[0];
160 int len
= strlen(key
);
163 /* Maybe i should have uses a "proper" hashing algorithm here instead
164 * of making one up myself, seems to be working ok though. */
165 for (i
= 1; i
< len
; i
++) {
166 /* shifts the ascii based value and adds it to previous value
167 * shift amount is mod 24 because long int is 32 bit and data
168 * to be shifted is 8, don't want to shift data to where it has
170 hash_num
+= (key
[i
] + key
[i
-1]) << ((key
[i
] * i
) % 24);
172 *start
= (unsigned) hash_num
% hash_prime
;
173 *decrement
= (unsigned) 1 + (hash_num
% (hash_prime
- 1));
176 /* this adds the key to the hash table */
177 static int search_name_hashtable(const char *key
)
179 unsigned probe_address
;
180 unsigned probe_decrement
;
182 make_hash(key
, &probe_address
, &probe_decrement
, NAME_HASH_PRIME
);
183 while (name_hashtable
[probe_address
] != NULL
) {
184 if (strcmp(name_hashtable
[probe_address
], key
) == 0) {
185 return probe_address
;
187 probe_address
-= probe_decrement
;
188 if ((int)probe_address
< 0) {
189 probe_address
+= NAME_HASH_PRIME
;
192 name_hashtable
[probe_address
] = xstrdup(key
);
193 return probe_address
;
196 /* this DOESNT add the key to the hashtable
197 * TODO make it consistent with search_name_hashtable
199 static unsigned search_status_hashtable(const char *key
)
201 unsigned probe_address
;
202 unsigned probe_decrement
;
204 make_hash(key
, &probe_address
, &probe_decrement
, STATUS_HASH_PRIME
);
205 while (status_hashtable
[probe_address
] != NULL
) {
206 if (strcmp(key
, name_hashtable
[package_hashtable
[status_hashtable
[probe_address
]->package
]->name
]) == 0) {
209 probe_address
-= probe_decrement
;
210 if ((int)probe_address
< 0) {
211 probe_address
+= STATUS_HASH_PRIME
;
214 return probe_address
;
217 static int order(char x
)
219 return (x
== '~' ? -1
223 : (unsigned char)x
+ 256
227 /* This code is taken from dpkg and modified slightly to work with busybox */
228 static int version_compare_part(const char *val
, const char *ref
)
233 while (*val
|| *ref
) {
236 while ((*val
&& !isdigit(*val
)) || (*ref
&& !isdigit(*ref
))) {
237 int vc
= order(*val
);
238 int rc
= order(*ref
);
251 while (isdigit(*val
) && isdigit(*ref
)) {
253 first_diff
= *val
- *ref
;
267 /* if ver1 < ver2 return -1,
268 * if ver1 = ver2 return 0,
269 * if ver1 > ver2 return 1,
271 static int version_compare(const unsigned ver1
, const unsigned ver2
)
273 char *ch_ver1
= name_hashtable
[ver1
];
274 char *ch_ver2
= name_hashtable
[ver2
];
275 unsigned epoch1
= 0, epoch2
= 0;
277 char *deb_ver1
, *deb_ver2
;
283 colon
= strchr(ch_ver1
, ':');
285 epoch1
= atoi(ch_ver1
);
288 colon
= strchr(ch_ver2
, ':');
290 epoch2
= atoi(ch_ver2
);
293 if (epoch1
< epoch2
) {
296 if (epoch1
> epoch2
) {
300 /* Compare upstream version */
301 upstream_ver1
= xstrdup(ch_ver1
);
302 upstream_ver2
= xstrdup(ch_ver2
);
304 /* Chop off debian version, and store for later use */
305 deb_ver1
= strrchr(upstream_ver1
, '-');
306 deb_ver2
= strrchr(upstream_ver2
, '-');
313 result
= version_compare_part(upstream_ver1
, upstream_ver2
);
315 /* Compare debian versions */
316 result
= version_compare_part(deb_ver1
, deb_ver2
);
324 static int test_version(const unsigned version1
, const unsigned version2
, const unsigned operator)
326 const int version_result
= version_compare(version1
, version2
);
331 return (version_result
== 0);
333 return (version_result
< 0);
335 return (version_result
<= 0);
337 return (version_result
> 0);
339 return (version_result
>= 0);
344 static int search_package_hashtable(const unsigned name
, const unsigned version
, const unsigned operator)
346 unsigned probe_address
;
347 unsigned probe_decrement
;
349 make_hash(name_hashtable
[name
], &probe_address
, &probe_decrement
, PACKAGE_HASH_PRIME
);
350 while (package_hashtable
[probe_address
] != NULL
) {
351 if (package_hashtable
[probe_address
]->name
== name
) {
352 if (operator == VER_ANY
) {
353 return probe_address
;
355 if (test_version(package_hashtable
[probe_address
]->version
, version
, operator)) {
356 return probe_address
;
359 probe_address
-= probe_decrement
;
360 if ((int)probe_address
< 0) {
361 probe_address
+= PACKAGE_HASH_PRIME
;
364 return probe_address
;
368 * This function searches through the entire package_hashtable looking
369 * for a package which provides "needle". It returns the index into
370 * the package_hashtable for the providing package.
372 * needle is the index into name_hashtable of the package we are
375 * start_at is the index in the package_hashtable to start looking
376 * at. If start_at is -1 then start at the beginning. This is to allow
377 * for repeated searches since more than one package might provide
380 * FIXME: I don't think this is very efficient, but I thought I'd keep
381 * it simple for now until it proves to be a problem.
383 static int search_for_provides(int needle
, int start_at
)
387 for (i
= start_at
+ 1; i
< PACKAGE_HASH_PRIME
; i
++) {
388 p
= package_hashtable
[i
];
391 for (j
= 0; j
< p
->num_of_edges
; j
++)
392 if (p
->edge
[j
]->type
== EDGE_PROVIDES
&& p
->edge
[j
]->name
== needle
)
399 * Add an edge to a node
401 static void add_edge_to_node(common_node_t
*node
, edge_t
*edge
)
403 node
->edge
= xrealloc_vector(node
->edge
, 2, node
->num_of_edges
);
404 node
->edge
[node
->num_of_edges
++] = edge
;
408 * Create one new node and one new edge for every dependency.
410 * Dependencies which contain multiple alternatives are represented as
411 * an EDGE_OR_PRE_DEPENDS or EDGE_OR_DEPENDS node, followed by a
412 * number of EDGE_PRE_DEPENDS or EDGE_DEPENDS nodes. The name field of
413 * the OR edge contains the full dependency string while the version
414 * field contains the number of EDGE nodes which follow as part of
417 static void add_split_dependencies(common_node_t
*parent_node
, const char *whole_line
, unsigned edge_type
)
419 char *line
= xstrdup(whole_line
);
421 char *line_ptr1
= NULL
;
422 char *line_ptr2
= NULL
;
430 field
= strtok_r(line
, ",", &line_ptr1
);
432 /* skip leading spaces */
433 field
+= strspn(field
, " ");
434 line2
= xstrdup(field
);
435 field2
= strtok_r(line2
, "|", &line_ptr2
);
437 if ((edge_type
== EDGE_DEPENDS
|| edge_type
== EDGE_PRE_DEPENDS
)
438 && (strcmp(field
, field2
) != 0)
440 or_edge
= xzalloc(sizeof(edge_t
));
441 or_edge
->type
= edge_type
+ 1;
442 or_edge
->name
= search_name_hashtable(field
);
443 //or_edge->version = 0; // tracks the number of alternatives
444 add_edge_to_node(parent_node
, or_edge
);
448 edge
= xmalloc(sizeof(edge_t
));
449 edge
->type
= edge_type
;
451 /* Skip any extra leading spaces */
452 field2
+= strspn(field2
, " ");
454 /* Get dependency version info */
455 version
= strchr(field2
, '(');
456 if (version
== NULL
) {
457 edge
->operator = VER_ANY
;
458 /* Get the versions hash number, adding it if the number isnt already in there */
459 edge
->version
= search_name_hashtable("ANY");
461 /* Skip leading ' ' or '(' */
462 version
+= strspn(version
, " (");
463 /* Calculate length of any operator characters */
464 offset_ch
= strspn(version
, "<=>");
465 /* Determine operator */
467 if (strncmp(version
, "=", offset_ch
) == 0) {
468 edge
->operator = VER_EQUAL
;
469 } else if (strncmp(version
, "<<", offset_ch
) == 0) {
470 edge
->operator = VER_LESS
;
471 } else if (strncmp(version
, "<=", offset_ch
) == 0) {
472 edge
->operator = VER_LESS_EQUAL
;
473 } else if (strncmp(version
, ">>", offset_ch
) == 0) {
474 edge
->operator = VER_MORE
;
475 } else if (strncmp(version
, ">=", offset_ch
) == 0) {
476 edge
->operator = VER_MORE_EQUAL
;
478 bb_error_msg_and_die("illegal operator");
481 /* skip to start of version numbers */
482 version
+= offset_ch
;
483 version
+= strspn(version
, " ");
485 /* Truncate version at trailing ' ' or ')' */
486 version
[strcspn(version
, " )")] = '\0';
487 /* Get the versions hash number, adding it if the number isnt already in there */
488 edge
->version
= search_name_hashtable(version
);
491 /* Get the dependency name */
492 field2
[strcspn(field2
, " (")] = '\0';
493 edge
->name
= search_name_hashtable(field2
);
498 add_edge_to_node(parent_node
, edge
);
499 field2
= strtok_r(NULL
, "|", &line_ptr2
);
500 } while (field2
!= NULL
);
503 field
= strtok_r(NULL
, ",", &line_ptr1
);
504 } while (field
!= NULL
);
509 static void free_package(common_node_t
*node
)
513 for (i
= 0; i
< node
->num_of_edges
; i
++) {
522 * Gets the next package field from package_buffer, separated into the field name
523 * and field value, it returns the int offset to the first character of the next field
525 static int read_package_field(const char *package_buffer
, char **field_name
, char **field_value
)
527 int offset_name_start
= 0;
528 int offset_name_end
= 0;
529 int offset_value_start
= 0;
530 int offset_value_end
= 0;
535 int exit_flag
= FALSE
;
537 if (package_buffer
== NULL
) {
543 next_offset
= offset
+ 1;
544 switch (package_buffer
[offset
]) {
549 if (offset_name_end
== 0) {
550 offset_name_end
= offset
;
551 offset_value_start
= next_offset
;
553 /* TODO: Name might still have trailing spaces if ':' isnt
554 * immediately after name */
557 /* TODO: The char next_offset may be out of bounds */
558 if (package_buffer
[next_offset
] != ' ') {
564 /* increment the value start point if its a just filler */
565 if (offset_name_start
== offset
) {
568 if (offset_value_start
== offset
) {
569 offset_value_start
++;
574 /* Check that the names are valid */
575 offset_value_end
= offset
;
576 name_length
= offset_name_end
- offset_name_start
;
577 value_length
= offset_value_end
- offset_value_start
;
578 if (name_length
== 0) {
581 if ((name_length
> 0) && (value_length
> 0)) {
585 /* If not valid, start fresh with next field */
587 offset_name_start
= offset
+ 1;
589 offset_value_start
= offset
+ 1;
590 offset_value_end
= offset
+ 1;
597 *field_name
= xstrndup(&package_buffer
[offset_name_start
], name_length
);
600 if (value_length
> 0) {
601 *field_value
= xstrndup(&package_buffer
[offset_value_start
], value_length
);
606 static unsigned fill_package_struct(char *control_buffer
)
608 static const char field_names
[] ALIGN1
=
609 "Package\0""Version\0"
610 "Pre-Depends\0""Depends\0""Replaces\0""Provides\0"
611 "Conflicts\0""Suggests\0""Recommends\0""Enhances\0";
613 common_node_t
*new_node
= xzalloc(sizeof(common_node_t
));
618 int buffer_length
= strlen(control_buffer
);
620 new_node
->version
= search_name_hashtable("unknown");
621 while (field_start
< buffer_length
) {
624 field_start
+= read_package_field(&control_buffer
[field_start
],
625 &field_name
, &field_value
);
627 if (field_name
== NULL
) {
628 goto fill_package_struct_cleanup
;
631 field_num
= index_in_strings(field_names
, field_name
);
633 case 0: /* Package */
634 new_node
->name
= search_name_hashtable(field_value
);
636 case 1: /* Version */
637 new_node
->version
= search_name_hashtable(field_value
);
639 case 2: /* Pre-Depends */
640 add_split_dependencies(new_node
, field_value
, EDGE_PRE_DEPENDS
);
642 case 3: /* Depends */
643 add_split_dependencies(new_node
, field_value
, EDGE_DEPENDS
);
645 case 4: /* Replaces */
646 add_split_dependencies(new_node
, field_value
, EDGE_REPLACES
);
648 case 5: /* Provides */
649 add_split_dependencies(new_node
, field_value
, EDGE_PROVIDES
);
651 case 6: /* Conflicts */
652 add_split_dependencies(new_node
, field_value
, EDGE_CONFLICTS
);
654 case 7: /* Suggests */
655 add_split_dependencies(new_node
, field_value
, EDGE_SUGGESTS
);
657 case 8: /* Recommends */
658 add_split_dependencies(new_node
, field_value
, EDGE_RECOMMENDS
);
660 case 9: /* Enhances */
661 add_split_dependencies(new_node
, field_value
, EDGE_ENHANCES
);
664 fill_package_struct_cleanup
:
669 if (new_node
->version
== search_name_hashtable("unknown")) {
670 free_package(new_node
);
673 num
= search_package_hashtable(new_node
->name
, new_node
->version
, VER_EQUAL
);
674 free_package(package_hashtable
[num
]);
675 package_hashtable
[num
] = new_node
;
679 /* if num = 1, it returns the want status, 2 returns flag, 3 returns status */
680 static unsigned get_status(const unsigned status_node
, const int num
)
682 char *status_string
= name_hashtable
[status_hashtable
[status_node
]->status
];
683 char *state_sub_string
;
684 unsigned state_sub_num
;
688 /* set tmp_string to point to the start of the word number */
689 for (i
= 1; i
< num
; i
++) {
690 /* skip past a word */
691 status_string
+= strcspn(status_string
, " ");
692 /* skip past the separating spaces */
693 status_string
+= strspn(status_string
, " ");
695 len
= strcspn(status_string
, " \n");
696 state_sub_string
= xstrndup(status_string
, len
);
697 state_sub_num
= search_name_hashtable(state_sub_string
);
698 free(state_sub_string
);
699 return state_sub_num
;
702 static void set_status(const unsigned status_node_num
, const char *new_value
, const int position
)
704 const unsigned new_value_num
= search_name_hashtable(new_value
);
705 unsigned want
= get_status(status_node_num
, 1);
706 unsigned flag
= get_status(status_node_num
, 2);
707 unsigned status
= get_status(status_node_num
, 3);
712 want
= new_value_num
;
715 flag
= new_value_num
;
718 status
= new_value_num
;
721 bb_error_msg_and_die("DEBUG ONLY: this shouldnt happen");
724 new_status
= xasprintf("%s %s %s", name_hashtable
[want
], name_hashtable
[flag
], name_hashtable
[status
]);
725 status_hashtable
[status_node_num
]->status
= search_name_hashtable(new_status
);
729 static const char *describe_status(int status_num
)
731 int status_want
, status_state
;
732 if (status_hashtable
[status_num
] == NULL
|| status_hashtable
[status_num
]->status
== 0)
733 return "is not installed or flagged to be installed";
735 status_want
= get_status(status_num
, 1);
736 status_state
= get_status(status_num
, 3);
738 if (status_state
== search_name_hashtable("installed")) {
739 if (status_want
== search_name_hashtable("install"))
740 return "is installed";
741 if (status_want
== search_name_hashtable("deinstall"))
742 return "is marked to be removed";
743 if (status_want
== search_name_hashtable("purge"))
744 return "is marked to be purged";
746 if (status_want
== search_name_hashtable("unknown"))
747 return "is in an indeterminate state";
748 if (status_want
== search_name_hashtable("install"))
749 return "is marked to be installed";
751 return "is not installed or flagged to be installed";
754 static void index_status_file(const char *filename
)
757 char *control_buffer
;
759 status_node_t
*status_node
= NULL
;
762 status_file
= xfopen_for_read(filename
);
763 while ((control_buffer
= xmalloc_fgetline_str(status_file
, "\n\n")) != NULL
) {
764 const unsigned package_num
= fill_package_struct(control_buffer
);
765 if (package_num
!= -1) {
766 status_node
= xmalloc(sizeof(status_node_t
));
767 /* fill_package_struct doesnt handle the status field */
768 status_line
= strstr(control_buffer
, "Status:");
769 if (status_line
!= NULL
) {
771 status_line
+= strspn(status_line
, " \n\t");
772 status_line
= xstrndup(status_line
, strcspn(status_line
, "\n"));
773 status_node
->status
= search_name_hashtable(status_line
);
776 status_node
->package
= package_num
;
777 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[status_node
->package
]->name
]);
778 status_hashtable
[status_num
] = status_node
;
780 free(control_buffer
);
785 static void write_buffer_no_status(FILE *new_status_file
, const char *control_buffer
)
791 start
+= read_package_field(&control_buffer
[start
], &name
, &value
);
795 if (strcmp(name
, "Status") != 0) {
796 fprintf(new_status_file
, "%s: %s\n", name
, value
);
801 /* This could do with a cleanup */
802 static void write_status_file(deb_file_t
**deb_file
)
804 FILE *old_status_file
= xfopen_for_read("/var/lib/dpkg/status");
805 FILE *new_status_file
= xfopen_for_write("/var/lib/dpkg/status.udeb");
807 char *status_from_file
;
808 char *control_buffer
= NULL
;
815 /* Update previously known packages */
816 while ((control_buffer
= xmalloc_fgetline_str(old_status_file
, "\n\n")) != NULL
) {
817 tmp_string
= strstr(control_buffer
, "Package:");
818 if (tmp_string
== NULL
) {
823 tmp_string
+= strspn(tmp_string
, " \n\t");
824 package_name
= xstrndup(tmp_string
, strcspn(tmp_string
, "\n"));
826 tmp_string
= strstr(control_buffer
, "Status:");
827 if (tmp_string
!= NULL
) {
828 /* Separate the status value from the control buffer */
830 tmp_string
+= strspn(tmp_string
, " \n\t");
831 status_from_file
= xstrndup(tmp_string
, strcspn(tmp_string
, "\n"));
833 status_from_file
= NULL
;
836 /* Find this package in the status hashtable */
837 status_num
= search_status_hashtable(package_name
);
838 if (status_hashtable
[status_num
] != NULL
) {
839 const char *status_from_hashtable
= name_hashtable
[status_hashtable
[status_num
]->status
];
840 if (strcmp(status_from_file
, status_from_hashtable
) != 0) {
841 /* New status isnt exactly the same as old status */
842 const int state_status
= get_status(status_num
, 3);
843 if ((strcmp("installed", name_hashtable
[state_status
]) == 0)
844 || (strcmp("unpacked", name_hashtable
[state_status
]) == 0)
846 /* We need to add the control file from the package */
848 while (deb_file
[i
] != NULL
) {
849 if (strcmp(package_name
, name_hashtable
[package_hashtable
[deb_file
[i
]->package
]->name
]) == 0) {
850 /* Write a status file entry with a modified status */
851 /* remove trailing \n's */
852 write_buffer_no_status(new_status_file
, deb_file
[i
]->control_file
);
853 set_status(status_num
, "ok", 2);
854 fprintf(new_status_file
, "Status: %s\n\n",
855 name_hashtable
[status_hashtable
[status_num
]->status
]);
861 /* This is temperary, debugging only */
862 if (deb_file
[i
] == NULL
) {
863 bb_error_msg_and_die("ALERT: cannot find a control file, "
864 "your status file may be broken, status may be "
865 "incorrect for %s", package_name
);
868 else if (strcmp("not-installed", name_hashtable
[state_status
]) == 0) {
869 /* Only write the Package, Status, Priority and Section lines */
870 fprintf(new_status_file
, "Package: %s\n", package_name
);
871 fprintf(new_status_file
, "Status: %s\n", status_from_hashtable
);
876 field_start
+= read_package_field(&control_buffer
[field_start
], &field_name
, &field_value
);
877 if (field_name
== NULL
) {
880 if ((strcmp(field_name
, "Priority") == 0)
881 || (strcmp(field_name
, "Section") == 0)
883 fprintf(new_status_file
, "%s: %s\n", field_name
, field_value
);
887 fputs("\n", new_status_file
);
889 else if (strcmp("config-files", name_hashtable
[state_status
]) == 0) {
890 /* only change the status line */
894 field_start
+= read_package_field(&control_buffer
[field_start
], &field_name
, &field_value
);
895 if (field_name
== NULL
) {
898 /* Setup start point for next field */
899 if (strcmp(field_name
, "Status") == 0) {
900 fprintf(new_status_file
, "Status: %s\n", status_from_hashtable
);
902 fprintf(new_status_file
, "%s: %s\n", field_name
, field_value
);
906 fputs("\n", new_status_file
);
910 /* If the package from the status file wasnt handle above, do it now*/
912 fprintf(new_status_file
, "%s\n\n", control_buffer
);
915 free(status_from_file
);
917 free(control_buffer
);
920 /* Write any new packages */
921 for (i
= 0; deb_file
[i
] != NULL
; i
++) {
922 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[deb_file
[i
]->package
]->name
]);
923 if (strcmp("reinstreq", name_hashtable
[get_status(status_num
, 2)]) == 0) {
924 write_buffer_no_status(new_status_file
, deb_file
[i
]->control_file
);
925 set_status(status_num
, "ok", 2);
926 fprintf(new_status_file
, "Status: %s\n\n", name_hashtable
[status_hashtable
[status_num
]->status
]);
929 fclose(old_status_file
);
930 fclose(new_status_file
);
932 /* Create a separate backfile to dpkg */
933 if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
935 bb_error_msg_and_die("can't create backup status file");
936 /* Its ok if renaming the status file fails because status
937 * file doesnt exist, maybe we are starting from scratch */
938 bb_error_msg("no status file found, creating new one");
941 xrename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status");
944 /* This function returns TRUE if the given package can satisfy a
945 * dependency of type depend_type.
947 * A pre-depends is satisfied only if a package is already installed,
948 * which a regular depends can be satisfied by a package which we want
951 static int package_satisfies_dependency(int package
, int depend_type
)
953 int status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package
]->name
]);
955 /* status could be unknown if package is a pure virtual
956 * provides which cannot satisfy any dependency by itself.
958 if (status_hashtable
[status_num
] == NULL
)
961 switch (depend_type
) {
962 case EDGE_PRE_DEPENDS
: return get_status(status_num
, 3) == search_name_hashtable("installed");
963 case EDGE_DEPENDS
: return get_status(status_num
, 1) == search_name_hashtable("install");
968 static int check_deps(deb_file_t
**deb_file
, int deb_start
/*, int dep_max_count - ?? */)
970 int *conflicts
= NULL
;
971 int conflicts_num
= 0;
975 /* Check for conflicts
976 * TODO: TEST if conflicts with other packages to be installed
978 * Add install packages and the packages they provide
979 * to the list of files to check conflicts for
982 /* Create array of package numbers to check against
983 * installed package for conflicts*/
984 while (deb_file
[i
] != NULL
) {
985 const unsigned package_num
= deb_file
[i
]->package
;
986 conflicts
= xrealloc_vector(conflicts
, 2, conflicts_num
);
987 conflicts
[conflicts_num
] = package_num
;
989 /* add provides to conflicts list */
990 for (j
= 0; j
< package_hashtable
[package_num
]->num_of_edges
; j
++) {
991 if (package_hashtable
[package_num
]->edge
[j
]->type
== EDGE_PROVIDES
) {
992 const int conflicts_package_num
= search_package_hashtable(
993 package_hashtable
[package_num
]->edge
[j
]->name
,
994 package_hashtable
[package_num
]->edge
[j
]->version
,
995 package_hashtable
[package_num
]->edge
[j
]->operator);
996 if (package_hashtable
[conflicts_package_num
] == NULL
) {
997 /* create a new package */
998 common_node_t
*new_node
= xzalloc(sizeof(common_node_t
));
999 new_node
->name
= package_hashtable
[package_num
]->edge
[j
]->name
;
1000 new_node
->version
= package_hashtable
[package_num
]->edge
[j
]->version
;
1001 package_hashtable
[conflicts_package_num
] = new_node
;
1003 conflicts
= xrealloc_vector(conflicts
, 2, conflicts_num
);
1004 conflicts
[conflicts_num
] = conflicts_package_num
;
1011 /* Check conflicts */
1013 while (deb_file
[i
] != NULL
) {
1014 const common_node_t
*package_node
= package_hashtable
[deb_file
[i
]->package
];
1016 status_num
= search_status_hashtable(name_hashtable
[package_node
->name
]);
1018 if (get_status(status_num
, 3) == search_name_hashtable("installed")) {
1023 for (j
= 0; j
< package_node
->num_of_edges
; j
++) {
1024 const edge_t
*package_edge
= package_node
->edge
[j
];
1026 if (package_edge
->type
== EDGE_CONFLICTS
) {
1027 const unsigned package_num
=
1028 search_package_hashtable(package_edge
->name
,
1029 package_edge
->version
,
1030 package_edge
->operator);
1032 if (package_hashtable
[package_num
] != NULL
) {
1033 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package_num
]->name
]);
1035 if (get_status(status_num
, 1) == search_name_hashtable("install")) {
1036 result
= test_version(package_hashtable
[deb_file
[i
]->package
]->version
,
1037 package_edge
->version
, package_edge
->operator);
1042 bb_error_msg_and_die("package %s conflicts with %s",
1043 name_hashtable
[package_node
->name
],
1044 name_hashtable
[package_edge
->name
]);
1052 /* Check dependendcies */
1053 for (i
= 0; i
< PACKAGE_HASH_PRIME
; i
++) {
1055 int number_of_alternatives
= 0;
1056 const edge_t
* root_of_alternatives
= NULL
;
1057 const common_node_t
*package_node
= package_hashtable
[i
];
1059 /* If the package node does not exist then this
1060 * package is a virtual one. In which case there are
1061 * no dependencies to check.
1063 if (package_node
== NULL
) continue;
1065 status_num
= search_status_hashtable(name_hashtable
[package_node
->name
]);
1067 /* If there is no status then this package is a
1068 * virtual one provided by something else. In which
1069 * case there are no dependencies to check.
1071 if (status_hashtable
[status_num
] == NULL
) continue;
1073 /* If we don't want this package installed then we may
1074 * as well ignore it's dependencies.
1076 if (get_status(status_num
, 1) != search_name_hashtable("install")) {
1080 /* This code is tested only for EDGE_DEPENDS, since I
1081 * have no suitable pre-depends available. There is no
1082 * reason that it shouldn't work though :-)
1084 for (j
= 0; j
< package_node
->num_of_edges
; j
++) {
1085 const edge_t
*package_edge
= package_node
->edge
[j
];
1086 unsigned package_num
;
1088 if (package_edge
->type
== EDGE_OR_PRE_DEPENDS
1089 || package_edge
->type
== EDGE_OR_DEPENDS
1091 /* start an EDGE_OR_ list */
1092 number_of_alternatives
= package_edge
->version
;
1093 root_of_alternatives
= package_edge
;
1096 if (number_of_alternatives
== 0) { /* not in the middle of an EDGE_OR_ list */
1097 number_of_alternatives
= 1;
1098 root_of_alternatives
= NULL
;
1101 package_num
= search_package_hashtable(package_edge
->name
, package_edge
->version
, package_edge
->operator);
1103 if (package_edge
->type
== EDGE_PRE_DEPENDS
1104 || package_edge
->type
== EDGE_DEPENDS
1109 /* If we are inside an alternative then check
1110 * this edge is the right type.
1112 * EDGE_DEPENDS == OR_DEPENDS -1
1113 * EDGE_PRE_DEPENDS == OR_PRE_DEPENDS -1
1115 if (root_of_alternatives
&& package_edge
->type
!= root_of_alternatives
->type
- 1)
1116 bb_error_msg_and_die("fatal error, package dependencies corrupt: %d != %d - 1",
1117 package_edge
->type
, root_of_alternatives
->type
);
1119 if (package_hashtable
[package_num
] != NULL
)
1120 result
= !package_satisfies_dependency(package_num
, package_edge
->type
);
1122 if (result
) { /* check for other package which provide what we are looking for */
1125 while ((provider
= search_for_provides(package_edge
->name
, provider
)) > -1) {
1126 if (package_hashtable
[provider
] == NULL
) {
1127 puts("Have a provider but no package information for it");
1130 result
= !package_satisfies_dependency(provider
, package_edge
->type
);
1137 /* It must be already installed, or to be installed */
1138 number_of_alternatives
--;
1139 if (result
&& number_of_alternatives
== 0) {
1140 if (root_of_alternatives
)
1141 bb_error_msg_and_die(
1142 "package %s %sdepends on %s, "
1143 "which cannot be satisfied",
1144 name_hashtable
[package_node
->name
],
1145 package_edge
->type
== EDGE_PRE_DEPENDS
? "pre-" : "",
1146 name_hashtable
[root_of_alternatives
->name
]);
1147 bb_error_msg_and_die(
1148 "package %s %sdepends on %s, which %s\n",
1149 name_hashtable
[package_node
->name
],
1150 package_edge
->type
== EDGE_PRE_DEPENDS
? "pre-" : "",
1151 name_hashtable
[package_edge
->name
],
1152 describe_status(status_num
));
1154 if (result
== 0 && number_of_alternatives
) {
1155 /* we've found a package which
1156 * satisfies the dependency,
1157 * so skip over the rest of
1160 j
+= number_of_alternatives
;
1161 number_of_alternatives
= 0;
1170 static char **create_list(const char *filename
)
1177 /* don't use [xw]fopen here, handle error ourself */
1178 list_stream
= fopen_for_read(filename
);
1179 if (list_stream
== NULL
) {
1185 while ((line
= xmalloc_fgetline(list_stream
)) != NULL
) {
1186 file_list
= xrealloc_vector(file_list
, 2, count
);
1187 file_list
[count
++] = line
;
1188 /*file_list[count] = NULL; - xrealloc_vector did it */
1190 fclose(list_stream
);
1195 /* maybe i should try and hook this into remove_file.c somehow */
1196 static int remove_file_array(char **remove_names
, char **exclude_names
)
1198 struct stat path_stat
;
1199 int remove_flag
= 1; /* not removed anything yet */
1202 if (remove_names
== NULL
) {
1205 for (i
= 0; remove_names
[i
] != NULL
; i
++) {
1206 if (exclude_names
!= NULL
) {
1207 for (j
= 0; exclude_names
[j
] != NULL
; j
++) {
1208 if (strcmp(remove_names
[i
], exclude_names
[j
]) == 0) {
1213 /* TODO: why we are checking lstat? we can just try rm/rmdir */
1214 if (lstat(remove_names
[i
], &path_stat
) < 0) {
1217 if (S_ISDIR(path_stat
.st_mode
)) {
1218 remove_flag
&= rmdir(remove_names
[i
]); /* 0 if no error */
1220 remove_flag
&= unlink(remove_names
[i
]); /* 0 if no error */
1225 return (remove_flag
== 0);
1228 static void run_package_script_or_die(const char *package_name
, const char *script_type
)
1233 script_path
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, script_type
);
1235 /* If the file doesnt exist is isnt fatal */
1236 result
= access(script_path
, F_OK
) ? EXIT_SUCCESS
: system(script_path
);
1239 bb_error_msg_and_die("%s failed, exit code %d", script_type
, result
);
1243 The policy manual defines what scripts get called when and with
1244 what arguments. I realize that busybox does not support all of
1245 these scenarios, but it does support some of them; it does not,
1246 however, run them with any parameters in run_package_script_or_die().
1247 Here are the scripts:
1250 preinst install <old_version>
1251 preinst upgrade <old_version>
1252 preinst abort_upgrade <new_version>
1253 postinst configure <most_recent_version>
1254 postinst abort-upgade <new_version>
1255 postinst abort-remove
1256 postinst abort-remove in-favour <package> <version>
1257 postinst abort-deconfigure in-favor <failed_install_package> removing <conflicting_package> <version>
1259 prerm upgrade <new_version>
1260 prerm failed-upgrade <old_version>
1261 prerm remove in-favor <package> <new_version>
1262 prerm deconfigure in-favour <package> <version> removing <package> <version>
1265 postrm upgrade <new_version>
1266 postrm failed-upgrade <old_version>
1267 postrm abort-install
1268 postrm abort-install <old_version>
1269 postrm abort-upgrade <old_version>
1270 postrm disappear <overwriter> <version>
1272 static const char *const all_control_files
[] = {
1273 "preinst", "postinst", "prerm", "postrm",
1274 "list", "md5sums", "shlibs", "conffiles",
1275 "config", "templates"
1278 static char **all_control_list(const char *package_name
)
1281 char **remove_files
;
1283 /* Create a list of all /var/lib/dpkg/info/<package> files */
1284 remove_files
= xzalloc(sizeof(all_control_files
) + sizeof(char*));
1285 while (i
< ARRAY_SIZE(all_control_files
)) {
1286 remove_files
[i
] = xasprintf("/var/lib/dpkg/info/%s.%s",
1287 package_name
, all_control_files
[i
]);
1291 return remove_files
;
1294 static void free_array(char **array
)
1306 /* This function lists information on the installed packages. It loops through
1307 * the status_hashtable to retrieve the info. This results in smaller code than
1308 * scanning the status file. The resulting list, however, is unsorted.
1310 static void list_packages(const char *pattern
)
1314 puts(" Name Version");
1315 puts("+++-==============-==============");
1317 /* go through status hash, dereference package hash and finally strings */
1318 for (i
= 0; i
< STATUS_HASH_PRIME
+1; i
++) {
1319 if (status_hashtable
[i
]) {
1320 const char *stat_str
; /* status string */
1321 const char *name_str
; /* package name */
1322 const char *vers_str
; /* version */
1323 char s1
, s2
; /* status abbreviations */
1324 int spccnt
; /* space count */
1327 stat_str
= name_hashtable
[status_hashtable
[i
]->status
];
1328 name_str
= name_hashtable
[package_hashtable
[status_hashtable
[i
]->package
]->name
];
1329 vers_str
= name_hashtable
[package_hashtable
[status_hashtable
[i
]->package
]->version
];
1331 if (pattern
&& fnmatch(pattern
, name_str
, 0) != 0)
1334 /* get abbreviation for status field 1 */
1335 s1
= stat_str
[0] == 'i' ? 'i' : 'r';
1337 /* get abbreviation for status field 2 */
1338 for (j
= 0, spccnt
= 0; stat_str
[j
] && spccnt
< 2; j
++) {
1339 if (stat_str
[j
] == ' ') spccnt
++;
1343 /* print out the line formatted like Debian dpkg */
1344 printf("%c%c %-14s %s\n", s1
, s2
, name_str
, vers_str
);
1349 static void remove_package(const unsigned package_num
, int noisy
)
1351 const char *package_name
= name_hashtable
[package_hashtable
[package_num
]->name
];
1352 const char *package_version
= name_hashtable
[package_hashtable
[package_num
]->version
];
1353 const unsigned status_num
= search_status_hashtable(package_name
);
1354 const int package_name_length
= strlen(package_name
);
1355 char **remove_files
;
1356 char **exclude_files
;
1357 char list_name
[package_name_length
+ 25];
1358 char conffile_name
[package_name_length
+ 30];
1361 printf("Removing %s (%s)...\n", package_name
, package_version
);
1363 /* Run prerm script */
1364 run_package_script_or_die(package_name
, "prerm");
1366 /* Create a list of files to remove, and a separate list of those to keep */
1367 sprintf(list_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "list");
1368 remove_files
= create_list(list_name
);
1370 sprintf(conffile_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "conffiles");
1371 exclude_files
= create_list(conffile_name
);
1373 /* Some directories can't be removed straight away, so do multiple passes */
1374 while (remove_file_array(remove_files
, exclude_files
))
1376 free_array(exclude_files
);
1377 free_array(remove_files
);
1379 /* Create a list of files in /var/lib/dpkg/info/<package>.* to keep */
1380 exclude_files
= xzalloc(sizeof(exclude_files
[0]) * 3);
1381 exclude_files
[0] = xstrdup(conffile_name
);
1382 exclude_files
[1] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "postrm");
1384 /* Create a list of all /var/lib/dpkg/info/<package> files */
1385 remove_files
= all_control_list(package_name
);
1387 remove_file_array(remove_files
, exclude_files
);
1388 free_array(remove_files
);
1389 free_array(exclude_files
);
1391 /* rename <package>.conffiles to <package>.list
1392 * The conffiles control file isn't required in Debian packages, so don't
1393 * error out if it's missing. */
1394 rename(conffile_name
, list_name
);
1396 /* Change package status */
1397 set_status(status_num
, "config-files", 3);
1400 static void purge_package(const unsigned package_num
)
1402 const char *package_name
= name_hashtable
[package_hashtable
[package_num
]->name
];
1403 const char *package_version
= name_hashtable
[package_hashtable
[package_num
]->version
];
1404 const unsigned status_num
= search_status_hashtable(package_name
);
1405 char **remove_files
;
1406 char **exclude_files
;
1407 char list_name
[strlen(package_name
) + 25];
1409 printf("Purging %s (%s)...\n", package_name
, package_version
);
1411 /* Run prerm script */
1412 run_package_script_or_die(package_name
, "prerm");
1414 /* Create a list of files to remove */
1415 sprintf(list_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "list");
1416 remove_files
= create_list(list_name
);
1418 /* Some directories cant be removed straight away, so do multiple passes */
1419 while (remove_file_array(remove_files
, NULL
))
1421 free_array(remove_files
);
1423 /* Create a list of all /var/lib/dpkg/info/<package> files */
1424 remove_files
= all_control_list(package_name
);
1426 /* Delete all of them except the postrm script */
1427 exclude_files
= xzalloc(sizeof(exclude_files
[0]) * 2);
1428 exclude_files
[0] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "postrm");
1429 remove_file_array(remove_files
, exclude_files
);
1430 free_array(exclude_files
);
1432 /* Run and remove postrm script */
1433 run_package_script_or_die(package_name
, "postrm");
1434 remove_file_array(remove_files
, NULL
);
1436 free_array(remove_files
);
1438 /* Change package status */
1439 set_status(status_num
, "not-installed", 3);
1442 static archive_handle_t
*init_archive_deb_ar(const char *filename
)
1444 archive_handle_t
*ar_handle
;
1446 /* Setup an ar archive handle that refers to the gzip sub archive */
1447 ar_handle
= init_handle();
1448 ar_handle
->filter
= filter_accept_list_reassign
;
1449 ar_handle
->src_fd
= xopen(filename
, O_RDONLY
);
1454 static void init_archive_deb_control(archive_handle_t
*ar_handle
)
1456 archive_handle_t
*tar_handle
;
1458 /* Setup the tar archive handle */
1459 tar_handle
= init_handle();
1460 tar_handle
->src_fd
= ar_handle
->src_fd
;
1462 /* We don't care about data.tar.* or debian-binary, just control.tar.* */
1463 #if ENABLE_FEATURE_SEAMLESS_GZ
1464 llist_add_to(&(ar_handle
->accept
), (char*)"control.tar.gz");
1466 #if ENABLE_FEATURE_SEAMLESS_BZ2
1467 llist_add_to(&(ar_handle
->accept
), (char*)"control.tar.bz2");
1470 /* Assign the tar handle as a subarchive of the ar handle */
1471 ar_handle
->dpkg__sub_archive
= tar_handle
;
1474 static void init_archive_deb_data(archive_handle_t
*ar_handle
)
1476 archive_handle_t
*tar_handle
;
1478 /* Setup the tar archive handle */
1479 tar_handle
= init_handle();
1480 tar_handle
->src_fd
= ar_handle
->src_fd
;
1482 /* We don't care about control.tar.* or debian-binary, just data.tar.* */
1483 #if ENABLE_FEATURE_SEAMLESS_GZ
1484 llist_add_to(&(ar_handle
->accept
), (char*)"data.tar.gz");
1486 #if ENABLE_FEATURE_SEAMLESS_BZ2
1487 llist_add_to(&(ar_handle
->accept
), (char*)"data.tar.bz2");
1490 /* Assign the tar handle as a subarchive of the ar handle */
1491 ar_handle
->dpkg__sub_archive
= tar_handle
;
1494 static void FAST_FUNC
data_extract_to_buffer(archive_handle_t
*archive_handle
)
1496 unsigned size
= archive_handle
->file_header
->size
;
1498 archive_handle
->dpkg__buffer
= xzalloc(size
+ 1);
1499 xread(archive_handle
->src_fd
, archive_handle
->dpkg__buffer
, size
);
1502 static char *deb_extract_control_file_to_buffer(archive_handle_t
*ar_handle
, llist_t
*myaccept
)
1504 ar_handle
->dpkg__sub_archive
->action_data
= data_extract_to_buffer
;
1505 ar_handle
->dpkg__sub_archive
->accept
= myaccept
;
1506 ar_handle
->dpkg__sub_archive
->filter
= filter_accept_list
;
1508 unpack_ar_archive(ar_handle
);
1509 close(ar_handle
->src_fd
);
1511 return ar_handle
->dpkg__sub_archive
->dpkg__buffer
;
1514 static void append_control_file_to_llist(const char *package_name
, const char *control_name
, llist_t
**ll
)
1517 char *filename
, *line
;
1519 filename
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, control_name
);
1520 fp
= fopen_for_read(filename
);
1523 while ((line
= xmalloc_fgetline(fp
)) != NULL
)
1524 llist_add_to(ll
, line
);
1529 static char FAST_FUNC
filter_rename_config(archive_handle_t
*archive_handle
)
1532 char *name_ptr
= archive_handle
->file_header
->name
+ 1;
1534 /* Is this file marked as config file? */
1535 if (!find_list_entry(archive_handle
->accept
, name_ptr
))
1536 return EXIT_SUCCESS
; /* no */
1538 fd
= open(name_ptr
, O_RDONLY
);
1541 char *md5line
, *buf
;
1544 /* Calculate MD5 of existing file */
1545 buf
= xmalloc(4096);
1547 while ((count
= safe_read(fd
, buf
, 4096)) > 0)
1548 md5_hash(&md5
, buf
, count
);
1549 md5_end(&md5
, buf
); /* using buf as result storage */
1552 md5line
= xmalloc(16 * 2 + 2 + strlen(name_ptr
) + 1);
1553 sprintf(bin2hex(md5line
, buf
, 16), " %s", name_ptr
);
1556 /* Is it changed after install? */
1557 if (find_list_entry(archive_handle
->accept
, md5line
) == NULL
) {
1558 printf("Warning: Creating %s as %s.dpkg-new\n", name_ptr
, name_ptr
);
1559 archive_handle
->file_header
->name
= xasprintf("%s.dpkg-new", archive_handle
->file_header
->name
);
1563 return EXIT_SUCCESS
;
1566 static void FAST_FUNC
data_extract_all_prefix(archive_handle_t
*archive_handle
)
1568 char *name_ptr
= archive_handle
->file_header
->name
;
1570 /* Skip all leading "/" */
1571 while (*name_ptr
== '/')
1573 /* Skip all leading "./" and "../" */
1574 while (name_ptr
[0] == '.') {
1575 if (name_ptr
[1] == '.')
1577 if (name_ptr
[1] != '/')
1582 if (name_ptr
[0] != '\0') {
1583 archive_handle
->file_header
->name
= xasprintf("%s%s", archive_handle
->dpkg__buffer
, name_ptr
);
1584 data_extract_all(archive_handle
);
1585 if (fnmatch("*.dpkg-new", archive_handle
->file_header
->name
, 0) == 0) {
1586 /* remove .dpkg-new suffix */
1587 archive_handle
->file_header
->name
[strlen(archive_handle
->file_header
->name
) - 9] = '\0';
1594 OPT_configure
= (1 << 0),
1595 OPT_install
= (1 << 1),
1596 OPT_list_installed
= (1 << 2),
1597 OPT_purge
= (1 << 3),
1598 OPT_remove
= (1 << 4),
1599 OPT_unpack
= (1 << 5),
1600 OPTMASK_cmd
= (1 << 6) - 1,
1602 OPT_force
= (1 << 6),
1603 OPT_force_ignore_depends
= (1 << 7),
1604 OPT_force_confnew
= (1 << 8),
1605 OPT_force_confold
= (1 << 9),
1608 static void unpack_package(deb_file_t
*deb_file
)
1610 const char *package_name
= name_hashtable
[package_hashtable
[deb_file
->package
]->name
];
1611 const unsigned status_num
= search_status_hashtable(package_name
);
1612 const unsigned status_package_num
= status_hashtable
[status_num
]->package
;
1614 char *list_filename
;
1615 archive_handle_t
*archive_handle
;
1617 llist_t
*accept_list
;
1618 llist_t
*conffile_list
;
1621 /* If existing version, remove it first */
1622 conffile_list
= NULL
;
1623 if (strcmp(name_hashtable
[get_status(status_num
, 3)], "installed") == 0) {
1624 /* Package is already installed, remove old version first */
1625 printf("Preparing to replace %s %s (using %s)...\n", package_name
,
1626 name_hashtable
[package_hashtable
[status_package_num
]->version
],
1627 deb_file
->filename
);
1629 /* Read md5sums from old package */
1630 if (!(option_mask32
& OPT_force_confold
))
1631 append_control_file_to_llist(package_name
, "md5sums", &conffile_list
);
1633 remove_package(status_package_num
, 0);
1635 printf("Unpacking %s (from %s)...\n", package_name
, deb_file
->filename
);
1638 /* Extract control.tar.gz to /var/lib/dpkg/info/<package>.filename */
1639 info_prefix
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "");
1640 archive_handle
= init_archive_deb_ar(deb_file
->filename
);
1641 init_archive_deb_control(archive_handle
);
1645 while (i
< ARRAY_SIZE(all_control_files
)) {
1646 char *c
= xasprintf("./%s", all_control_files
[i
]);
1647 llist_add_to(&accept_list
, c
);
1650 archive_handle
->dpkg__sub_archive
->accept
= accept_list
;
1651 archive_handle
->dpkg__sub_archive
->filter
= filter_accept_list
;
1652 archive_handle
->dpkg__sub_archive
->action_data
= data_extract_all_prefix
;
1653 archive_handle
->dpkg__sub_archive
->dpkg__buffer
= info_prefix
;
1654 archive_handle
->dpkg__sub_archive
->ah_flags
|= ARCHIVE_UNLINK_OLD
;
1655 unpack_ar_archive(archive_handle
);
1657 /* Run the preinst prior to extracting */
1658 run_package_script_or_die(package_name
, "preinst");
1660 /* Don't overwrite existing config files */
1661 if (!(option_mask32
& OPT_force_confnew
))
1662 append_control_file_to_llist(package_name
, "conffiles", &conffile_list
);
1664 /* Extract data.tar.gz to the root directory */
1665 archive_handle
= init_archive_deb_ar(deb_file
->filename
);
1666 init_archive_deb_data(archive_handle
);
1667 archive_handle
->dpkg__sub_archive
->accept
= conffile_list
;
1668 /* Why ARCHIVE_REMEMBER_NAMES?
1669 * We want names collected in ->passed list even if conffile_list
1670 * is NULL (otherwise get_header_tar may optimize name saving out):
1672 archive_handle
->dpkg__sub_archive
->ah_flags
|= ARCHIVE_REMEMBER_NAMES
| ARCHIVE_UNLINK_OLD
;
1673 archive_handle
->dpkg__sub_archive
->filter
= filter_rename_config
;
1674 archive_handle
->dpkg__sub_archive
->action_data
= data_extract_all_prefix
;
1675 archive_handle
->dpkg__sub_archive
->dpkg__buffer
= (char*)"/"; /* huh? */
1676 unpack_ar_archive(archive_handle
);
1678 /* Create the list file */
1679 list_filename
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "list");
1680 out_stream
= xfopen_for_write(list_filename
);
1681 archive_handle
->dpkg__sub_archive
->passed
= llist_rev(archive_handle
->dpkg__sub_archive
->passed
);
1682 while (archive_handle
->dpkg__sub_archive
->passed
) {
1683 char *filename
= llist_pop(&archive_handle
->dpkg__sub_archive
->passed
);
1684 /* the leading . has been stripped by data_extract_all_prefix already */
1685 fprintf(out_stream
, "%s\n", filename
);
1691 set_status(status_num
, "install", 1);
1692 set_status(status_num
, "unpacked", 3);
1695 free(list_filename
);
1698 static void configure_package(deb_file_t
*deb_file
)
1700 const char *package_name
= name_hashtable
[package_hashtable
[deb_file
->package
]->name
];
1701 const char *package_version
= name_hashtable
[package_hashtable
[deb_file
->package
]->version
];
1702 const int status_num
= search_status_hashtable(package_name
);
1704 printf("Setting up %s (%s)...\n", package_name
, package_version
);
1706 /* Run the postinst script */
1707 /* TODO: handle failure gracefully */
1708 run_package_script_or_die(package_name
, "postinst");
1710 /* Change status to reflect success */
1711 set_status(status_num
, "install", 1);
1712 set_status(status_num
, "installed", 3);
1715 int dpkg_main(int argc
, char **argv
) MAIN_EXTERNALLY_VISIBLE
;
1716 int dpkg_main(int argc UNUSED_PARAM
, char **argv
)
1718 deb_file_t
**deb_file
= NULL
;
1719 status_node_t
*status_node
;
1727 #if ENABLE_LONG_OPTS
1728 static const char dpkg_longopts
[] ALIGN1
=
1729 // FIXME: we use -C non-compatibly, should be:
1730 // "-C|--audit Check for broken package(s)"
1731 "configure\0" No_argument
"C"
1732 "force\0" Required_argument
"F"
1733 "install\0" No_argument
"i"
1734 "list\0" No_argument
"l"
1735 "purge\0" No_argument
"P"
1736 "remove\0" No_argument
"r"
1737 "unpack\0" No_argument
"u"
1738 "force-depends\0" No_argument
"\xff"
1739 "force-confnew\0" No_argument
"\xfe"
1740 "force-confold\0" No_argument
"\xfd"
1746 IF_LONG_OPTS(applet_long_options
= dpkg_longopts
);
1747 opt
= getopt32(argv
, "CilPruF:", &str_f
);
1749 //if (opt & OPT_configure) ... // -C
1750 if (opt
& OPT_force
) { // -F (--force in official dpkg)
1751 if (strcmp(str_f
, "depends") == 0)
1752 opt
|= OPT_force_ignore_depends
;
1753 else if (strcmp(str_f
, "confnew") == 0)
1754 opt
|= OPT_force_confnew
;
1755 else if (strcmp(str_f
, "confold") == 0)
1756 opt
|= OPT_force_confold
;
1759 option_mask32
= opt
;
1761 //if (opt & OPT_install) ... // -i
1762 //if (opt & OPT_list_installed) ... // -l
1763 //if (opt & OPT_purge) ... // -P
1764 //if (opt & OPT_remove) ... // -r
1765 //if (opt & OPT_unpack) ... // -u (--unpack in official dpkg)
1766 if (!(opt
& OPTMASK_cmd
) /* no cmd */
1767 || ((opt
& OPTMASK_cmd
) & ((opt
& OPTMASK_cmd
)-1)) /* more than one cmd */
1772 /* puts("(Reading database ... xxxxx files and directories installed.)"); */
1773 index_status_file("/var/lib/dpkg/status");
1775 /* if the list action was given print the installed packages and exit */
1776 if (opt
& OPT_list_installed
) {
1777 list_packages(argv
[0]); /* param can be NULL */
1778 return EXIT_SUCCESS
;
1781 /* Read arguments and store relevant info in structs */
1783 /* deb_count = nb_elem - 1 and we need nb_elem + 1 to allocate terminal node [NULL pointer] */
1784 deb_file
= xrealloc_vector(deb_file
, 2, deb_count
);
1785 deb_file
[deb_count
] = xzalloc(sizeof(deb_file
[0][0]));
1786 if (opt
& (OPT_install
| OPT_unpack
)) {
1787 /* -i/-u: require filename */
1788 archive_handle_t
*archive_handle
;
1789 llist_t
*control_list
= NULL
;
1791 /* Extract the control file */
1792 llist_add_to(&control_list
, (char*)"./control");
1793 archive_handle
= init_archive_deb_ar(argv
[0]);
1794 init_archive_deb_control(archive_handle
);
1795 deb_file
[deb_count
]->control_file
= deb_extract_control_file_to_buffer(archive_handle
, control_list
);
1796 if (deb_file
[deb_count
]->control_file
== NULL
) {
1797 bb_error_msg_and_die("can't extract control file");
1799 deb_file
[deb_count
]->filename
= xstrdup(argv
[0]);
1800 package_num
= fill_package_struct(deb_file
[deb_count
]->control_file
);
1802 if (package_num
== -1) {
1803 bb_error_msg("invalid control file in %s", argv
[0]);
1807 deb_file
[deb_count
]->package
= (unsigned) package_num
;
1809 /* Add the package to the status hashtable */
1810 if (opt
& (OPT_unpack
| OPT_install
)) {
1811 /* Try and find a currently installed version of this package */
1812 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[deb_file
[deb_count
]->package
]->name
]);
1813 /* If no previous entry was found initialise a new entry */
1814 if (status_hashtable
[status_num
] == NULL
1815 || status_hashtable
[status_num
]->status
== 0
1817 status_node
= xmalloc(sizeof(status_node_t
));
1818 status_node
->package
= deb_file
[deb_count
]->package
;
1819 /* reinstreq isnt changed to "ok" until the package control info
1820 * is written to the status file*/
1821 status_node
->status
= search_name_hashtable("install reinstreq not-installed");
1822 status_hashtable
[status_num
] = status_node
;
1824 set_status(status_num
, "install", 1);
1825 set_status(status_num
, "reinstreq", 2);
1828 } else if (opt
& (OPT_configure
| OPT_purge
| OPT_remove
)) {
1829 /* -C/-p/-r: require package name */
1830 deb_file
[deb_count
]->package
= search_package_hashtable(
1831 search_name_hashtable(argv
[0]),
1832 search_name_hashtable("ANY"), VER_ANY
);
1833 if (package_hashtable
[deb_file
[deb_count
]->package
] == NULL
) {
1834 bb_error_msg_and_die("package %s is uninstalled or unknown", argv
[0]);
1836 package_num
= deb_file
[deb_count
]->package
;
1837 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package_num
]->name
]);
1838 state_status
= get_status(status_num
, 3);
1840 /* check package status is "installed" */
1841 if (opt
& OPT_remove
) {
1842 if (strcmp(name_hashtable
[state_status
], "not-installed") == 0
1843 || strcmp(name_hashtable
[state_status
], "config-files") == 0
1845 bb_error_msg_and_die("%s is already removed", name_hashtable
[package_hashtable
[package_num
]->name
]);
1847 set_status(status_num
, "deinstall", 1);
1848 } else if (opt
& OPT_purge
) {
1849 /* if package status is "conf-files" then its ok */
1850 if (strcmp(name_hashtable
[state_status
], "not-installed") == 0) {
1851 bb_error_msg_and_die("%s is already purged", name_hashtable
[package_hashtable
[package_num
]->name
]);
1853 set_status(status_num
, "purge", 1);
1860 bb_error_msg_and_die("no package files specified");
1861 deb_file
[deb_count
] = NULL
;
1863 /* Check that the deb file arguments are installable */
1864 if (!(opt
& OPT_force_ignore_depends
)) {
1865 if (!check_deps(deb_file
, 0 /*, deb_count*/)) {
1866 bb_error_msg_and_die("dependency check failed");
1870 /* TODO: install or remove packages in the correct dependency order */
1871 for (i
= 0; i
< deb_count
; i
++) {
1872 /* Remove or purge packages */
1873 if (opt
& OPT_remove
) {
1874 remove_package(deb_file
[i
]->package
, 1);
1876 else if (opt
& OPT_purge
) {
1877 purge_package(deb_file
[i
]->package
);
1879 else if (opt
& OPT_unpack
) {
1880 unpack_package(deb_file
[i
]);
1882 else if (opt
& OPT_install
) {
1883 unpack_package(deb_file
[i
]);
1884 /* package is configured in second pass below */
1886 else if (opt
& OPT_configure
) {
1887 configure_package(deb_file
[i
]);
1890 /* configure installed packages */
1891 if (opt
& OPT_install
) {
1892 for (i
= 0; i
< deb_count
; i
++)
1893 configure_package(deb_file
[i
]);
1896 write_status_file(deb_file
);
1898 if (ENABLE_FEATURE_CLEAN_UP
) {
1899 for (i
= 0; i
< deb_count
; i
++) {
1900 free(deb_file
[i
]->control_file
);
1901 free(deb_file
[i
]->filename
);
1907 for (i
= 0; i
< NAME_HASH_PRIME
; i
++) {
1908 free(name_hashtable
[i
]);
1911 for (i
= 0; i
< PACKAGE_HASH_PRIME
; i
++) {
1912 free_package(package_hashtable
[i
]);
1915 for (i
= 0; i
< STATUS_HASH_PRIME
; i
++) {
1916 free(status_hashtable
[i
]);
1919 free(status_hashtable
);
1920 free(package_hashtable
);
1921 free(name_hashtable
);
1924 return EXIT_SUCCESS
;