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 tarball for details.
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)
33 #include "unarchive.h"
35 /* note: if you vary hash_prime sizes be aware,
36 * 1) tweaking these will have a big effect on how much memory this program uses.
37 * 2) for computational efficiency these hash tables should be at least 20%
38 * larger than the maximum number of elements stored in it.
39 * 3) all _hash_prime's must be a prime number or chaos is assured, if your looking
40 * for a prime, try http://www.utm.edu/research/primes/lists/small/10000.txt
41 * 4) if you go bigger than 15 bits you may get into trouble (untested) as its
42 * sometimes cast to an unsigned, if you go to 16 bit you will overlap
43 * int's and chaos is assured, 16381 is the max prime for 14 bit field
46 /* NAME_HASH_PRIME, Stores package names and versions,
47 * I estimate it should be at least 50% bigger than PACKAGE_HASH_PRIME,
48 * as there a lot of duplicate version numbers */
49 #define NAME_HASH_PRIME 16381
51 /* PACKAGE_HASH_PRIME, Maximum number of unique packages,
52 * It must not be smaller than STATUS_HASH_PRIME,
53 * Currently only packages from status_hashtable are stored in here, but in
54 * future this may be used to store packages not only from a status file,
55 * but an available_hashtable, and even multiple packages files.
56 * Package can be stored more than once if they have different versions.
57 * e.g. The same package may have different versions in the status file
58 * and available file */
59 #define PACKAGE_HASH_PRIME 10007
60 typedef struct edge_s
{
61 unsigned operator:4; /* was:3 */
63 unsigned name
:16; /* was:14 */
64 unsigned version
:16; /* was:14 */
67 typedef struct common_node_s
{
68 unsigned name
:16; /* was:14 */
69 unsigned version
:16; /* was:14 */
70 unsigned num_of_edges
:16; /* was:14 */
74 /* Currently it doesnt store packages that have state-status of not-installed
75 * So it only really has to be the size of the maximum number of packages
76 * likely to be installed at any one time, so there is a bit of leeway here */
77 #define STATUS_HASH_PRIME 8191
78 typedef struct status_node_s
{
79 unsigned package
:16; /* was:14 */ /* has to fit PACKAGE_HASH_PRIME */
80 unsigned status
:16; /* was:14 */ /* has to fit STATUS_HASH_PRIME */
86 char *name_hashtable
[NAME_HASH_PRIME
+ 1];
87 common_node_t
*package_hashtable
[PACKAGE_HASH_PRIME
+ 1];
88 status_node_t
*status_hashtable
[STATUS_HASH_PRIME
+ 1];
90 #define G (*ptr_to_globals)
91 #define name_hashtable (G.name_hashtable )
92 #define package_hashtable (G.package_hashtable)
93 #define status_hashtable (G.status_hashtable )
94 #define INIT_G() do { \
95 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
99 /* Even numbers are for 'extras', like ored dependencies or null */
102 EDGE_PRE_DEPENDS
= 1,
103 EDGE_OR_PRE_DEPENDS
= 2,
110 EDGE_RECOMMENDS
= 13,
123 typedef struct deb_file_s
{
126 unsigned package
:16; /* was:14 */
130 static void make_hash(const char *key
, unsigned *start
, unsigned *decrement
, const int hash_prime
)
132 unsigned long hash_num
= key
[0];
133 int len
= strlen(key
);
136 /* Maybe i should have uses a "proper" hashing algorithm here instead
137 * of making one up myself, seems to be working ok though. */
138 for (i
= 1; i
< len
; i
++) {
139 /* shifts the ascii based value and adds it to previous value
140 * shift amount is mod 24 because long int is 32 bit and data
141 * to be shifted is 8, don't want to shift data to where it has
143 hash_num
+= (key
[i
] + key
[i
-1]) << ((key
[i
] * i
) % 24);
145 *start
= (unsigned) hash_num
% hash_prime
;
146 *decrement
= (unsigned) 1 + (hash_num
% (hash_prime
- 1));
149 /* this adds the key to the hash table */
150 static int search_name_hashtable(const char *key
)
152 unsigned probe_address
;
153 unsigned probe_decrement
;
155 make_hash(key
, &probe_address
, &probe_decrement
, NAME_HASH_PRIME
);
156 while (name_hashtable
[probe_address
] != NULL
) {
157 if (strcmp(name_hashtable
[probe_address
], key
) == 0) {
158 return probe_address
;
160 probe_address
-= probe_decrement
;
161 if ((int)probe_address
< 0) {
162 probe_address
+= NAME_HASH_PRIME
;
165 name_hashtable
[probe_address
] = xstrdup(key
);
166 return probe_address
;
169 /* this DOESNT add the key to the hashtable
170 * TODO make it consistent with search_name_hashtable
172 static unsigned search_status_hashtable(const char *key
)
174 unsigned probe_address
;
175 unsigned probe_decrement
;
177 make_hash(key
, &probe_address
, &probe_decrement
, STATUS_HASH_PRIME
);
178 while (status_hashtable
[probe_address
] != NULL
) {
179 if (strcmp(key
, name_hashtable
[package_hashtable
[status_hashtable
[probe_address
]->package
]->name
]) == 0) {
182 probe_address
-= probe_decrement
;
183 if ((int)probe_address
< 0) {
184 probe_address
+= STATUS_HASH_PRIME
;
187 return probe_address
;
190 static int order(char x
)
192 return (x
== '~' ? -1
196 : (unsigned char)x
+ 256
200 /* This code is taken from dpkg and modified slightly to work with busybox */
201 static int version_compare_part(const char *val
, const char *ref
)
206 while (*val
|| *ref
) {
209 while ((*val
&& !isdigit(*val
)) || (*ref
&& !isdigit(*ref
))) {
210 int vc
= order(*val
);
211 int rc
= order(*ref
);
224 while (isdigit(*val
) && isdigit(*ref
)) {
226 first_diff
= *val
- *ref
;
240 /* if ver1 < ver2 return -1,
241 * if ver1 = ver2 return 0,
242 * if ver1 > ver2 return 1,
244 static int version_compare(const unsigned ver1
, const unsigned ver2
)
246 char *ch_ver1
= name_hashtable
[ver1
];
247 char *ch_ver2
= name_hashtable
[ver2
];
248 unsigned long epoch1
= 0, epoch2
= 0;
250 char *deb_ver1
, *deb_ver2
;
256 colon
= strchr(ch_ver1
, ':');
258 epoch1
= atoi(ch_ver1
);
261 colon
= strchr(ch_ver2
, ':');
263 epoch2
= atoi(ch_ver2
);
266 if (epoch1
< epoch2
) {
269 if (epoch1
> epoch2
) {
273 /* Compare upstream version */
274 upstream_ver1
= xstrdup(ch_ver1
);
275 upstream_ver2
= xstrdup(ch_ver2
);
277 /* Chop off debian version, and store for later use */
278 deb_ver1
= strrchr(upstream_ver1
, '-');
279 deb_ver2
= strrchr(upstream_ver2
, '-');
288 result
= version_compare_part(upstream_ver1
, upstream_ver2
);
290 /* Compare debian versions */
291 result
= version_compare_part(deb_ver1
, deb_ver2
);
298 static int test_version(const unsigned version1
, const unsigned version2
, const unsigned operator)
300 const int version_result
= version_compare(version1
, version2
);
305 return (version_result
== 0);
307 return (version_result
< 0);
309 return (version_result
<= 0);
311 return (version_result
> 0);
313 return (version_result
>= 0);
318 static int search_package_hashtable(const unsigned name
, const unsigned version
, const unsigned operator)
320 unsigned probe_address
;
321 unsigned probe_decrement
;
323 make_hash(name_hashtable
[name
], &probe_address
, &probe_decrement
, PACKAGE_HASH_PRIME
);
324 while (package_hashtable
[probe_address
] != NULL
) {
325 if (package_hashtable
[probe_address
]->name
== name
) {
326 if (operator == VER_ANY
) {
327 return probe_address
;
329 if (test_version(package_hashtable
[probe_address
]->version
, version
, operator)) {
330 return probe_address
;
333 probe_address
-= probe_decrement
;
334 if ((int)probe_address
< 0) {
335 probe_address
+= PACKAGE_HASH_PRIME
;
338 return probe_address
;
342 * This function searches through the entire package_hashtable looking
343 * for a package which provides "needle". It returns the index into
344 * the package_hashtable for the providing package.
346 * needle is the index into name_hashtable of the package we are
349 * start_at is the index in the package_hashtable to start looking
350 * at. If start_at is -1 then start at the beginning. This is to allow
351 * for repeated searches since more than one package might provide
354 * FIXME: I don't think this is very efficient, but I thought I'd keep
355 * it simple for now until it proves to be a problem.
357 static int search_for_provides(int needle
, int start_at
)
361 for (i
= start_at
+ 1; i
< PACKAGE_HASH_PRIME
; i
++) {
362 p
= package_hashtable
[i
];
365 for (j
= 0; j
< p
->num_of_edges
; j
++)
366 if (p
->edge
[j
]->type
== EDGE_PROVIDES
&& p
->edge
[j
]->name
== needle
)
373 * Add an edge to a node
375 static void add_edge_to_node(common_node_t
*node
, edge_t
*edge
)
377 node
->edge
= xrealloc_vector(node
->edge
, 2, node
->num_of_edges
);
378 node
->edge
[node
->num_of_edges
++] = edge
;
382 * Create one new node and one new edge for every dependency.
384 * Dependencies which contain multiple alternatives are represented as
385 * an EDGE_OR_PRE_DEPENDS or EDGE_OR_DEPENDS node, followed by a
386 * number of EDGE_PRE_DEPENDS or EDGE_DEPENDS nodes. The name field of
387 * the OR edge contains the full dependency string while the version
388 * field contains the number of EDGE nodes which follow as part of
391 static void add_split_dependencies(common_node_t
*parent_node
, const char *whole_line
, unsigned edge_type
)
393 char *line
= xstrdup(whole_line
);
395 char *line_ptr1
= NULL
;
396 char *line_ptr2
= NULL
;
404 field
= strtok_r(line
, ",", &line_ptr1
);
406 /* skip leading spaces */
407 field
+= strspn(field
, " ");
408 line2
= xstrdup(field
);
409 field2
= strtok_r(line2
, "|", &line_ptr2
);
411 if ((edge_type
== EDGE_DEPENDS
|| edge_type
== EDGE_PRE_DEPENDS
)
412 && (strcmp(field
, field2
) != 0)
414 or_edge
= xzalloc(sizeof(edge_t
));
415 or_edge
->type
= edge_type
+ 1;
416 or_edge
->name
= search_name_hashtable(field
);
417 //or_edge->version = 0; // tracks the number of alternatives
418 add_edge_to_node(parent_node
, or_edge
);
422 edge
= xmalloc(sizeof(edge_t
));
423 edge
->type
= edge_type
;
425 /* Skip any extra leading spaces */
426 field2
+= strspn(field2
, " ");
428 /* Get dependency version info */
429 version
= strchr(field2
, '(');
430 if (version
== NULL
) {
431 edge
->operator = VER_ANY
;
432 /* Get the versions hash number, adding it if the number isnt already in there */
433 edge
->version
= search_name_hashtable("ANY");
435 /* Skip leading ' ' or '(' */
436 version
+= strspn(version
, " (");
437 /* Calculate length of any operator characters */
438 offset_ch
= strspn(version
, "<=>");
439 /* Determine operator */
441 if (strncmp(version
, "=", offset_ch
) == 0) {
442 edge
->operator = VER_EQUAL
;
443 } else if (strncmp(version
, "<<", offset_ch
) == 0) {
444 edge
->operator = VER_LESS
;
445 } else if (strncmp(version
, "<=", offset_ch
) == 0) {
446 edge
->operator = VER_LESS_EQUAL
;
447 } else if (strncmp(version
, ">>", offset_ch
) == 0) {
448 edge
->operator = VER_MORE
;
449 } else if (strncmp(version
, ">=", offset_ch
) == 0) {
450 edge
->operator = VER_MORE_EQUAL
;
452 bb_error_msg_and_die("illegal operator");
455 /* skip to start of version numbers */
456 version
+= offset_ch
;
457 version
+= strspn(version
, " ");
459 /* Truncate version at trailing ' ' or ')' */
460 version
[strcspn(version
, " )")] = '\0';
461 /* Get the versions hash number, adding it if the number isnt already in there */
462 edge
->version
= search_name_hashtable(version
);
465 /* Get the dependency name */
466 field2
[strcspn(field2
, " (")] = '\0';
467 edge
->name
= search_name_hashtable(field2
);
472 add_edge_to_node(parent_node
, edge
);
473 field2
= strtok_r(NULL
, "|", &line_ptr2
);
474 } while (field2
!= NULL
);
477 field
= strtok_r(NULL
, ",", &line_ptr1
);
478 } while (field
!= NULL
);
483 static void free_package(common_node_t
*node
)
487 for (i
= 0; i
< node
->num_of_edges
; i
++) {
496 * Gets the next package field from package_buffer, seperated into the field name
497 * and field value, it returns the int offset to the first character of the next field
499 static int read_package_field(const char *package_buffer
, char **field_name
, char **field_value
)
501 int offset_name_start
= 0;
502 int offset_name_end
= 0;
503 int offset_value_start
= 0;
504 int offset_value_end
= 0;
509 int exit_flag
= FALSE
;
511 if (package_buffer
== NULL
) {
517 next_offset
= offset
+ 1;
518 switch (package_buffer
[offset
]) {
523 if (offset_name_end
== 0) {
524 offset_name_end
= offset
;
525 offset_value_start
= next_offset
;
527 /* TODO: Name might still have trailing spaces if ':' isnt
528 * immediately after name */
531 /* TODO: The char next_offset may be out of bounds */
532 if (package_buffer
[next_offset
] != ' ') {
538 /* increment the value start point if its a just filler */
539 if (offset_name_start
== offset
) {
542 if (offset_value_start
== offset
) {
543 offset_value_start
++;
548 /* Check that the names are valid */
549 offset_value_end
= offset
;
550 name_length
= offset_name_end
- offset_name_start
;
551 value_length
= offset_value_end
- offset_value_start
;
552 if (name_length
== 0) {
555 if ((name_length
> 0) && (value_length
> 0)) {
559 /* If not valid, start fresh with next field */
561 offset_name_start
= offset
+ 1;
563 offset_value_start
= offset
+ 1;
564 offset_value_end
= offset
+ 1;
571 *field_name
= xstrndup(&package_buffer
[offset_name_start
], name_length
);
574 if (value_length
> 0) {
575 *field_value
= xstrndup(&package_buffer
[offset_value_start
], value_length
);
580 static unsigned fill_package_struct(char *control_buffer
)
582 static const char field_names
[] ALIGN1
=
583 "Package\0""Version\0"
584 "Pre-Depends\0""Depends\0""Replaces\0""Provides\0"
585 "Conflicts\0""Suggests\0""Recommends\0""Enhances\0";
587 common_node_t
*new_node
= xzalloc(sizeof(common_node_t
));
592 int buffer_length
= strlen(control_buffer
);
594 new_node
->version
= search_name_hashtable("unknown");
595 while (field_start
< buffer_length
) {
598 field_start
+= read_package_field(&control_buffer
[field_start
],
599 &field_name
, &field_value
);
601 if (field_name
== NULL
) {
602 goto fill_package_struct_cleanup
;
605 field_num
= index_in_strings(field_names
, field_name
);
607 case 0: /* Package */
608 new_node
->name
= search_name_hashtable(field_value
);
610 case 1: /* Version */
611 new_node
->version
= search_name_hashtable(field_value
);
613 case 2: /* Pre-Depends */
614 add_split_dependencies(new_node
, field_value
, EDGE_PRE_DEPENDS
);
616 case 3: /* Depends */
617 add_split_dependencies(new_node
, field_value
, EDGE_DEPENDS
);
619 case 4: /* Replaces */
620 add_split_dependencies(new_node
, field_value
, EDGE_REPLACES
);
622 case 5: /* Provides */
623 add_split_dependencies(new_node
, field_value
, EDGE_PROVIDES
);
625 case 6: /* Conflicts */
626 add_split_dependencies(new_node
, field_value
, EDGE_CONFLICTS
);
628 case 7: /* Suggests */
629 add_split_dependencies(new_node
, field_value
, EDGE_SUGGESTS
);
631 case 8: /* Recommends */
632 add_split_dependencies(new_node
, field_value
, EDGE_RECOMMENDS
);
634 case 9: /* Enhances */
635 add_split_dependencies(new_node
, field_value
, EDGE_ENHANCES
);
638 fill_package_struct_cleanup
:
643 if (new_node
->version
== search_name_hashtable("unknown")) {
644 free_package(new_node
);
647 num
= search_package_hashtable(new_node
->name
, new_node
->version
, VER_EQUAL
);
648 free_package(package_hashtable
[num
]);
649 package_hashtable
[num
] = new_node
;
653 /* if num = 1, it returns the want status, 2 returns flag, 3 returns status */
654 static unsigned get_status(const unsigned status_node
, const int num
)
656 char *status_string
= name_hashtable
[status_hashtable
[status_node
]->status
];
657 char *state_sub_string
;
658 unsigned state_sub_num
;
662 /* set tmp_string to point to the start of the word number */
663 for (i
= 1; i
< num
; i
++) {
664 /* skip past a word */
665 status_string
+= strcspn(status_string
, " ");
666 /* skip past the separating spaces */
667 status_string
+= strspn(status_string
, " ");
669 len
= strcspn(status_string
, " \n");
670 state_sub_string
= xstrndup(status_string
, len
);
671 state_sub_num
= search_name_hashtable(state_sub_string
);
672 free(state_sub_string
);
673 return state_sub_num
;
676 static void set_status(const unsigned status_node_num
, const char *new_value
, const int position
)
678 const unsigned new_value_len
= strlen(new_value
);
679 const unsigned new_value_num
= search_name_hashtable(new_value
);
680 unsigned want
= get_status(status_node_num
, 1);
681 unsigned flag
= get_status(status_node_num
, 2);
682 unsigned status
= get_status(status_node_num
, 3);
683 int want_len
= strlen(name_hashtable
[want
]);
684 int flag_len
= strlen(name_hashtable
[flag
]);
685 int status_len
= strlen(name_hashtable
[status
]);
690 want
= new_value_num
;
691 want_len
= new_value_len
;
694 flag
= new_value_num
;
695 flag_len
= new_value_len
;
698 status
= new_value_num
;
699 status_len
= new_value_len
;
702 bb_error_msg_and_die("DEBUG ONLY: this shouldnt happen");
705 new_status
= xasprintf("%s %s %s", name_hashtable
[want
], name_hashtable
[flag
], name_hashtable
[status
]);
706 status_hashtable
[status_node_num
]->status
= search_name_hashtable(new_status
);
710 static const char *describe_status(int status_num
)
712 int status_want
, status_state
;
713 if (status_hashtable
[status_num
] == NULL
|| status_hashtable
[status_num
]->status
== 0)
714 return "is not installed or flagged to be installed";
716 status_want
= get_status(status_num
, 1);
717 status_state
= get_status(status_num
, 3);
719 if (status_state
== search_name_hashtable("installed")) {
720 if (status_want
== search_name_hashtable("install"))
721 return "is installed";
722 if (status_want
== search_name_hashtable("deinstall"))
723 return "is marked to be removed";
724 if (status_want
== search_name_hashtable("purge"))
725 return "is marked to be purged";
727 if (status_want
== search_name_hashtable("unknown"))
728 return "is in an indeterminate state";
729 if (status_want
== search_name_hashtable("install"))
730 return "is marked to be installed";
732 return "is not installed or flagged to be installed";
735 static void index_status_file(const char *filename
)
738 char *control_buffer
;
740 status_node_t
*status_node
= NULL
;
743 status_file
= xfopen_for_read(filename
);
744 while ((control_buffer
= xmalloc_fgetline_str(status_file
, "\n\n")) != NULL
) {
745 const unsigned package_num
= fill_package_struct(control_buffer
);
746 if (package_num
!= -1) {
747 status_node
= xmalloc(sizeof(status_node_t
));
748 /* fill_package_struct doesnt handle the status field */
749 status_line
= strstr(control_buffer
, "Status:");
750 if (status_line
!= NULL
) {
752 status_line
+= strspn(status_line
, " \n\t");
753 status_line
= xstrndup(status_line
, strcspn(status_line
, "\n"));
754 status_node
->status
= search_name_hashtable(status_line
);
757 status_node
->package
= package_num
;
758 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[status_node
->package
]->name
]);
759 status_hashtable
[status_num
] = status_node
;
761 free(control_buffer
);
766 static void write_buffer_no_status(FILE *new_status_file
, const char *control_buffer
)
772 start
+= read_package_field(&control_buffer
[start
], &name
, &value
);
776 if (strcmp(name
, "Status") != 0) {
777 fprintf(new_status_file
, "%s: %s\n", name
, value
);
782 /* This could do with a cleanup */
783 static void write_status_file(deb_file_t
**deb_file
)
785 FILE *old_status_file
= xfopen_for_read("/var/lib/dpkg/status");
786 FILE *new_status_file
= xfopen_for_write("/var/lib/dpkg/status.udeb");
788 char *status_from_file
;
789 char *control_buffer
= NULL
;
796 /* Update previously known packages */
797 while ((control_buffer
= xmalloc_fgetline_str(old_status_file
, "\n\n")) != NULL
) {
798 tmp_string
= strstr(control_buffer
, "Package:");
799 if (tmp_string
== NULL
) {
804 tmp_string
+= strspn(tmp_string
, " \n\t");
805 package_name
= xstrndup(tmp_string
, strcspn(tmp_string
, "\n"));
807 tmp_string
= strstr(control_buffer
, "Status:");
808 if (tmp_string
!= NULL
) {
809 /* Seperate the status value from the control buffer */
811 tmp_string
+= strspn(tmp_string
, " \n\t");
812 status_from_file
= xstrndup(tmp_string
, strcspn(tmp_string
, "\n"));
814 status_from_file
= NULL
;
817 /* Find this package in the status hashtable */
818 status_num
= search_status_hashtable(package_name
);
819 if (status_hashtable
[status_num
] != NULL
) {
820 const char *status_from_hashtable
= name_hashtable
[status_hashtable
[status_num
]->status
];
821 if (strcmp(status_from_file
, status_from_hashtable
) != 0) {
822 /* New status isnt exactly the same as old status */
823 const int state_status
= get_status(status_num
, 3);
824 if ((strcmp("installed", name_hashtable
[state_status
]) == 0)
825 || (strcmp("unpacked", name_hashtable
[state_status
]) == 0)
827 /* We need to add the control file from the package */
829 while (deb_file
[i
] != NULL
) {
830 if (strcmp(package_name
, name_hashtable
[package_hashtable
[deb_file
[i
]->package
]->name
]) == 0) {
831 /* Write a status file entry with a modified status */
832 /* remove trailing \n's */
833 write_buffer_no_status(new_status_file
, deb_file
[i
]->control_file
);
834 set_status(status_num
, "ok", 2);
835 fprintf(new_status_file
, "Status: %s\n\n",
836 name_hashtable
[status_hashtable
[status_num
]->status
]);
842 /* This is temperary, debugging only */
843 if (deb_file
[i
] == NULL
) {
844 bb_error_msg_and_die("ALERT: cannot find a control file, "
845 "your status file may be broken, status may be "
846 "incorrect for %s", package_name
);
849 else if (strcmp("not-installed", name_hashtable
[state_status
]) == 0) {
850 /* Only write the Package, Status, Priority and Section lines */
851 fprintf(new_status_file
, "Package: %s\n", package_name
);
852 fprintf(new_status_file
, "Status: %s\n", status_from_hashtable
);
857 field_start
+= read_package_field(&control_buffer
[field_start
], &field_name
, &field_value
);
858 if (field_name
== NULL
) {
861 if ((strcmp(field_name
, "Priority") == 0) ||
862 (strcmp(field_name
, "Section") == 0)) {
863 fprintf(new_status_file
, "%s: %s\n", field_name
, field_value
);
867 fputs("\n", new_status_file
);
869 else if (strcmp("config-files", name_hashtable
[state_status
]) == 0) {
870 /* only change the status line */
874 field_start
+= read_package_field(&control_buffer
[field_start
], &field_name
, &field_value
);
875 if (field_name
== NULL
) {
878 /* Setup start point for next field */
879 if (strcmp(field_name
, "Status") == 0) {
880 fprintf(new_status_file
, "Status: %s\n", status_from_hashtable
);
882 fprintf(new_status_file
, "%s: %s\n", field_name
, field_value
);
886 fputs("\n", new_status_file
);
890 /* If the package from the status file wasnt handle above, do it now*/
892 fprintf(new_status_file
, "%s\n\n", control_buffer
);
895 free(status_from_file
);
897 free(control_buffer
);
900 /* Write any new packages */
901 for (i
= 0; deb_file
[i
] != NULL
; i
++) {
902 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[deb_file
[i
]->package
]->name
]);
903 if (strcmp("reinstreq", name_hashtable
[get_status(status_num
, 2)]) == 0) {
904 write_buffer_no_status(new_status_file
, deb_file
[i
]->control_file
);
905 set_status(status_num
, "ok", 2);
906 fprintf(new_status_file
, "Status: %s\n\n", name_hashtable
[status_hashtable
[status_num
]->status
]);
909 fclose(old_status_file
);
910 fclose(new_status_file
);
912 /* Create a separate backfile to dpkg */
913 if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
915 bb_error_msg_and_die("cannot create backup status file");
916 /* Its ok if renaming the status file fails because status
917 * file doesnt exist, maybe we are starting from scratch */
918 bb_error_msg("no status file found, creating new one");
921 xrename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status");
924 /* This function returns TRUE if the given package can satisfy a
925 * dependency of type depend_type.
927 * A pre-depends is satisfied only if a package is already installed,
928 * which a regular depends can be satisfied by a package which we want
931 static int package_satisfies_dependency(int package
, int depend_type
)
933 int status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package
]->name
]);
935 /* status could be unknown if package is a pure virtual
936 * provides which cannot satisfy any dependency by itself.
938 if (status_hashtable
[status_num
] == NULL
)
941 switch (depend_type
) {
942 case EDGE_PRE_DEPENDS
: return get_status(status_num
, 3) == search_name_hashtable("installed");
943 case EDGE_DEPENDS
: return get_status(status_num
, 1) == search_name_hashtable("install");
948 static int check_deps(deb_file_t
**deb_file
, int deb_start
/*, int dep_max_count - ?? */)
950 int *conflicts
= NULL
;
951 int conflicts_num
= 0;
955 /* Check for conflicts
956 * TODO: TEST if conflicts with other packages to be installed
958 * Add install packages and the packages they provide
959 * to the list of files to check conflicts for
962 /* Create array of package numbers to check against
963 * installed package for conflicts*/
964 while (deb_file
[i
] != NULL
) {
965 const unsigned package_num
= deb_file
[i
]->package
;
966 conflicts
= xrealloc_vector(conflicts
, 2, conflicts_num
);
967 conflicts
[conflicts_num
] = package_num
;
969 /* add provides to conflicts list */
970 for (j
= 0; j
< package_hashtable
[package_num
]->num_of_edges
; j
++) {
971 if (package_hashtable
[package_num
]->edge
[j
]->type
== EDGE_PROVIDES
) {
972 const int conflicts_package_num
= search_package_hashtable(
973 package_hashtable
[package_num
]->edge
[j
]->name
,
974 package_hashtable
[package_num
]->edge
[j
]->version
,
975 package_hashtable
[package_num
]->edge
[j
]->operator);
976 if (package_hashtable
[conflicts_package_num
] == NULL
) {
977 /* create a new package */
978 common_node_t
*new_node
= xzalloc(sizeof(common_node_t
));
979 new_node
->name
= package_hashtable
[package_num
]->edge
[j
]->name
;
980 new_node
->version
= package_hashtable
[package_num
]->edge
[j
]->version
;
981 package_hashtable
[conflicts_package_num
] = new_node
;
983 conflicts
= xrealloc_vector(conflicts
, 2, conflicts_num
);
984 conflicts
[conflicts_num
] = conflicts_package_num
;
991 /* Check conflicts */
993 while (deb_file
[i
] != NULL
) {
994 const common_node_t
*package_node
= package_hashtable
[deb_file
[i
]->package
];
996 status_num
= search_status_hashtable(name_hashtable
[package_node
->name
]);
998 if (get_status(status_num
, 3) == search_name_hashtable("installed")) {
1003 for (j
= 0; j
< package_node
->num_of_edges
; j
++) {
1004 const edge_t
*package_edge
= package_node
->edge
[j
];
1006 if (package_edge
->type
== EDGE_CONFLICTS
) {
1007 const unsigned package_num
=
1008 search_package_hashtable(package_edge
->name
,
1009 package_edge
->version
,
1010 package_edge
->operator);
1012 if (package_hashtable
[package_num
] != NULL
) {
1013 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package_num
]->name
]);
1015 if (get_status(status_num
, 1) == search_name_hashtable("install")) {
1016 result
= test_version(package_hashtable
[deb_file
[i
]->package
]->version
,
1017 package_edge
->version
, package_edge
->operator);
1022 bb_error_msg_and_die("package %s conflicts with %s",
1023 name_hashtable
[package_node
->name
],
1024 name_hashtable
[package_edge
->name
]);
1032 /* Check dependendcies */
1033 for (i
= 0; i
< PACKAGE_HASH_PRIME
; i
++) {
1035 int number_of_alternatives
= 0;
1036 const edge_t
* root_of_alternatives
= NULL
;
1037 const common_node_t
*package_node
= package_hashtable
[i
];
1039 /* If the package node does not exist then this
1040 * package is a virtual one. In which case there are
1041 * no dependencies to check.
1043 if (package_node
== NULL
) continue;
1045 status_num
= search_status_hashtable(name_hashtable
[package_node
->name
]);
1047 /* If there is no status then this package is a
1048 * virtual one provided by something else. In which
1049 * case there are no dependencies to check.
1051 if (status_hashtable
[status_num
] == NULL
) continue;
1053 /* If we don't want this package installed then we may
1054 * as well ignore it's dependencies.
1056 if (get_status(status_num
, 1) != search_name_hashtable("install")) {
1060 /* This code is tested only for EDGE_DEPENDS, since I
1061 * have no suitable pre-depends available. There is no
1062 * reason that it shouldn't work though :-)
1064 for (j
= 0; j
< package_node
->num_of_edges
; j
++) {
1065 const edge_t
*package_edge
= package_node
->edge
[j
];
1066 unsigned package_num
;
1068 if (package_edge
->type
== EDGE_OR_PRE_DEPENDS
1069 || package_edge
->type
== EDGE_OR_DEPENDS
1070 ) { /* start an EDGE_OR_ list */
1071 number_of_alternatives
= package_edge
->version
;
1072 root_of_alternatives
= package_edge
;
1075 if (number_of_alternatives
== 0) { /* not in the middle of an EDGE_OR_ list */
1076 number_of_alternatives
= 1;
1077 root_of_alternatives
= NULL
;
1080 package_num
= search_package_hashtable(package_edge
->name
, package_edge
->version
, package_edge
->operator);
1082 if (package_edge
->type
== EDGE_PRE_DEPENDS
||
1083 package_edge
->type
== EDGE_DEPENDS
) {
1087 /* If we are inside an alternative then check
1088 * this edge is the right type.
1090 * EDGE_DEPENDS == OR_DEPENDS -1
1091 * EDGE_PRE_DEPENDS == OR_PRE_DEPENDS -1
1093 if (root_of_alternatives
&& package_edge
->type
!= root_of_alternatives
->type
- 1)
1094 bb_error_msg_and_die("fatal error, package dependencies corrupt: %d != %d - 1",
1095 package_edge
->type
, root_of_alternatives
->type
);
1097 if (package_hashtable
[package_num
] != NULL
)
1098 result
= !package_satisfies_dependency(package_num
, package_edge
->type
);
1100 if (result
) { /* check for other package which provide what we are looking for */
1103 while ((provider
= search_for_provides(package_edge
->name
, provider
)) > -1) {
1104 if (package_hashtable
[provider
] == NULL
) {
1105 puts("Have a provider but no package information for it");
1108 result
= !package_satisfies_dependency(provider
, package_edge
->type
);
1115 /* It must be already installed, or to be installed */
1116 number_of_alternatives
--;
1117 if (result
&& number_of_alternatives
== 0) {
1118 if (root_of_alternatives
)
1119 bb_error_msg_and_die(
1120 "package %s %sdepends on %s, "
1121 "which cannot be satisfied",
1122 name_hashtable
[package_node
->name
],
1123 package_edge
->type
== EDGE_PRE_DEPENDS
? "pre-" : "",
1124 name_hashtable
[root_of_alternatives
->name
]);
1125 bb_error_msg_and_die(
1126 "package %s %sdepends on %s, which %s\n",
1127 name_hashtable
[package_node
->name
],
1128 package_edge
->type
== EDGE_PRE_DEPENDS
? "pre-" : "",
1129 name_hashtable
[package_edge
->name
],
1130 describe_status(status_num
));
1132 if (result
== 0 && number_of_alternatives
) {
1133 /* we've found a package which
1134 * satisfies the dependency,
1135 * so skip over the rest of
1138 j
+= number_of_alternatives
;
1139 number_of_alternatives
= 0;
1148 static char **create_list(const char *filename
)
1155 /* don't use [xw]fopen here, handle error ourself */
1156 list_stream
= fopen_for_read(filename
);
1157 if (list_stream
== NULL
) {
1163 while ((line
= xmalloc_fgetline(list_stream
)) != NULL
) {
1164 file_list
= xrealloc_vector(file_list
, 2, count
);
1165 file_list
[count
++] = line
;
1166 /*file_list[count] = NULL; - xrealloc_vector did it */
1168 fclose(list_stream
);
1173 /* maybe i should try and hook this into remove_file.c somehow */
1174 static int remove_file_array(char **remove_names
, char **exclude_names
)
1176 struct stat path_stat
;
1177 int remove_flag
= 1; /* not removed anything yet */
1180 if (remove_names
== NULL
) {
1183 for (i
= 0; remove_names
[i
] != NULL
; i
++) {
1184 if (exclude_names
!= NULL
) {
1185 for (j
= 0; exclude_names
[j
] != NULL
; j
++) {
1186 if (strcmp(remove_names
[i
], exclude_names
[j
]) == 0) {
1191 /* TODO: why we are checking lstat? we can just try rm/rmdir */
1192 if (lstat(remove_names
[i
], &path_stat
) < 0) {
1195 if (S_ISDIR(path_stat
.st_mode
)) {
1196 remove_flag
&= rmdir(remove_names
[i
]); /* 0 if no error */
1198 remove_flag
&= unlink(remove_names
[i
]); /* 0 if no error */
1203 return (remove_flag
== 0);
1206 static void run_package_script_or_die(const char *package_name
, const char *script_type
)
1211 script_path
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, script_type
);
1213 /* If the file doesnt exist is isnt fatal */
1214 result
= access(script_path
, F_OK
) ? EXIT_SUCCESS
: system(script_path
);
1217 bb_error_msg_and_die("%s failed, exit code %d", script_type
, result
);
1221 The policy manual defines what scripts get called when and with
1222 what arguments. I realize that busybox does not support all of
1223 these scenarios, but it does support some of them; it does not,
1224 however, run them with any parameters in run_package_script_or_die().
1225 Here are the scripts:
1228 preinst install <old_version>
1229 preinst upgrade <old_version>
1230 preinst abort_upgrade <new_version>
1231 postinst configure <most_recent_version>
1232 postinst abort-upgade <new_version>
1233 postinst abort-remove
1234 postinst abort-remove in-favour <package> <version>
1235 postinst abort-deconfigure in-favor <failed_install_package> removing <conflicting_package> <version>
1237 prerm upgrade <new_version>
1238 prerm failed-upgrade <old_version>
1239 prerm remove in-favor <package> <new_version>
1240 prerm deconfigure in-favour <package> <version> removing <package> <version>
1243 postrm upgrade <new_version>
1244 postrm failed-upgrade <old_version>
1245 postrm abort-install
1246 postrm abort-install <old_version>
1247 postrm abort-upgrade <old_version>
1248 postrm disappear <overwriter> <version>
1250 static const char *const all_control_files
[] = {
1251 "preinst", "postinst", "prerm", "postrm",
1252 "list", "md5sums", "shlibs", "conffiles",
1253 "config", "templates"
1256 static char **all_control_list(const char *package_name
)
1259 char **remove_files
;
1261 /* Create a list of all /var/lib/dpkg/info/<package> files */
1262 remove_files
= xzalloc(sizeof(all_control_files
) + sizeof(char*));
1263 while (i
< ARRAY_SIZE(all_control_files
)) {
1264 remove_files
[i
] = xasprintf("/var/lib/dpkg/info/%s.%s",
1265 package_name
, all_control_files
[i
]);
1269 return remove_files
;
1272 static void free_array(char **array
)
1284 /* This function lists information on the installed packages. It loops through
1285 * the status_hashtable to retrieve the info. This results in smaller code than
1286 * scanning the status file. The resulting list, however, is unsorted.
1288 static void list_packages(const char *pattern
)
1292 puts(" Name Version");
1293 puts("+++-==============-==============");
1295 /* go through status hash, dereference package hash and finally strings */
1296 for (i
= 0; i
< STATUS_HASH_PRIME
+1; i
++) {
1297 if (status_hashtable
[i
]) {
1298 const char *stat_str
; /* status string */
1299 const char *name_str
; /* package name */
1300 const char *vers_str
; /* version */
1301 char s1
, s2
; /* status abbreviations */
1302 int spccnt
; /* space count */
1305 stat_str
= name_hashtable
[status_hashtable
[i
]->status
];
1306 name_str
= name_hashtable
[package_hashtable
[status_hashtable
[i
]->package
]->name
];
1307 vers_str
= name_hashtable
[package_hashtable
[status_hashtable
[i
]->package
]->version
];
1309 if (pattern
&& fnmatch(pattern
, name_str
, 0))
1312 /* get abbreviation for status field 1 */
1313 s1
= stat_str
[0] == 'i' ? 'i' : 'r';
1315 /* get abbreviation for status field 2 */
1316 for (j
= 0, spccnt
= 0; stat_str
[j
] && spccnt
< 2; j
++) {
1317 if (stat_str
[j
] == ' ') spccnt
++;
1321 /* print out the line formatted like Debian dpkg */
1322 printf("%c%c %-14s %s\n", s1
, s2
, name_str
, vers_str
);
1327 static void remove_package(const unsigned package_num
, int noisy
)
1329 const char *package_name
= name_hashtable
[package_hashtable
[package_num
]->name
];
1330 const char *package_version
= name_hashtable
[package_hashtable
[package_num
]->version
];
1331 const unsigned status_num
= search_status_hashtable(package_name
);
1332 const int package_name_length
= strlen(package_name
);
1333 char **remove_files
;
1334 char **exclude_files
;
1335 char list_name
[package_name_length
+ 25];
1336 char conffile_name
[package_name_length
+ 30];
1339 printf("Removing %s (%s)...\n", package_name
, package_version
);
1341 /* Run prerm script */
1342 run_package_script_or_die(package_name
, "prerm");
1344 /* Create a list of files to remove, and a separate list of those to keep */
1345 sprintf(list_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "list");
1346 remove_files
= create_list(list_name
);
1348 sprintf(conffile_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "conffiles");
1349 exclude_files
= create_list(conffile_name
);
1351 /* Some directories can't be removed straight away, so do multiple passes */
1352 while (remove_file_array(remove_files
, exclude_files
))
1354 free_array(exclude_files
);
1355 free_array(remove_files
);
1357 /* Create a list of files in /var/lib/dpkg/info/<package>.* to keep */
1358 exclude_files
= xzalloc(sizeof(char*) * 3);
1359 exclude_files
[0] = xstrdup(conffile_name
);
1360 exclude_files
[1] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "postrm");
1362 /* Create a list of all /var/lib/dpkg/info/<package> files */
1363 remove_files
= all_control_list(package_name
);
1365 remove_file_array(remove_files
, exclude_files
);
1366 free_array(remove_files
);
1367 free_array(exclude_files
);
1369 /* rename <package>.conffiles to <package>.list
1370 * The conffiles control file isn't required in Debian packages, so don't
1371 * error out if it's missing. */
1372 rename(conffile_name
, list_name
);
1374 /* Change package status */
1375 set_status(status_num
, "config-files", 3);
1378 static void purge_package(const unsigned package_num
)
1380 const char *package_name
= name_hashtable
[package_hashtable
[package_num
]->name
];
1381 const char *package_version
= name_hashtable
[package_hashtable
[package_num
]->version
];
1382 const unsigned status_num
= search_status_hashtable(package_name
);
1383 char **remove_files
;
1384 char **exclude_files
;
1385 char list_name
[strlen(package_name
) + 25];
1387 printf("Purging %s (%s)...\n", package_name
, package_version
);
1389 /* Run prerm script */
1390 run_package_script_or_die(package_name
, "prerm");
1392 /* Create a list of files to remove */
1393 sprintf(list_name
, "/var/lib/dpkg/info/%s.%s", package_name
, "list");
1394 remove_files
= create_list(list_name
);
1396 exclude_files
= xzalloc(sizeof(char*));
1398 /* Some directories cant be removed straight away, so do multiple passes */
1399 while (remove_file_array(remove_files
, exclude_files
)) /* repeat */;
1400 free_array(remove_files
);
1402 /* Create a list of all /var/lib/dpkg/info/<package> files */
1403 remove_files
= all_control_list(package_name
);
1404 remove_file_array(remove_files
, exclude_files
);
1405 free_array(remove_files
);
1406 free(exclude_files
);
1408 /* Run postrm script */
1409 run_package_script_or_die(package_name
, "postrm");
1411 /* Change package status */
1412 set_status(status_num
, "not-installed", 3);
1415 static archive_handle_t
*init_archive_deb_ar(const char *filename
)
1417 archive_handle_t
*ar_handle
;
1419 /* Setup an ar archive handle that refers to the gzip sub archive */
1420 ar_handle
= init_handle();
1421 ar_handle
->filter
= filter_accept_list_reassign
;
1422 ar_handle
->src_fd
= xopen(filename
, O_RDONLY
);
1427 static void init_archive_deb_control(archive_handle_t
*ar_handle
)
1429 archive_handle_t
*tar_handle
;
1431 /* Setup the tar archive handle */
1432 tar_handle
= init_handle();
1433 tar_handle
->src_fd
= ar_handle
->src_fd
;
1435 /* We don't care about data.tar.* or debian-binary, just control.tar.* */
1436 #if ENABLE_FEATURE_SEAMLESS_GZ
1437 llist_add_to(&(ar_handle
->accept
), (char*)"control.tar.gz");
1439 #if ENABLE_FEATURE_SEAMLESS_BZ2
1440 llist_add_to(&(ar_handle
->accept
), (char*)"control.tar.bz2");
1443 /* Assign the tar handle as a subarchive of the ar handle */
1444 ar_handle
->sub_archive
= tar_handle
;
1447 static void init_archive_deb_data(archive_handle_t
*ar_handle
)
1449 archive_handle_t
*tar_handle
;
1451 /* Setup the tar archive handle */
1452 tar_handle
= init_handle();
1453 tar_handle
->src_fd
= ar_handle
->src_fd
;
1455 /* We don't care about control.tar.* or debian-binary, just data.tar.* */
1456 #if ENABLE_FEATURE_SEAMLESS_GZ
1457 llist_add_to(&(ar_handle
->accept
), (char*)"data.tar.gz");
1459 #if ENABLE_FEATURE_SEAMLESS_BZ2
1460 llist_add_to(&(ar_handle
->accept
), (char*)"data.tar.bz2");
1463 /* Assign the tar handle as a subarchive of the ar handle */
1464 ar_handle
->sub_archive
= tar_handle
;
1467 static char *deb_extract_control_file_to_buffer(archive_handle_t
*ar_handle
, llist_t
*myaccept
)
1469 ar_handle
->sub_archive
->action_data
= data_extract_to_buffer
;
1470 ar_handle
->sub_archive
->accept
= myaccept
;
1471 ar_handle
->sub_archive
->filter
= filter_accept_list
;
1473 unpack_ar_archive(ar_handle
);
1474 close(ar_handle
->src_fd
);
1476 return ar_handle
->sub_archive
->buffer
;
1479 static void FAST_FUNC
data_extract_all_prefix(archive_handle_t
*archive_handle
)
1481 char *name_ptr
= archive_handle
->file_header
->name
;
1483 name_ptr
+= strspn(name_ptr
, "./");
1484 if (name_ptr
[0] != '\0') {
1485 archive_handle
->file_header
->name
= xasprintf("%s%s", archive_handle
->buffer
, name_ptr
);
1486 data_extract_all(archive_handle
);
1490 static void unpack_package(deb_file_t
*deb_file
)
1492 const char *package_name
= name_hashtable
[package_hashtable
[deb_file
->package
]->name
];
1493 const unsigned status_num
= search_status_hashtable(package_name
);
1494 const unsigned status_package_num
= status_hashtable
[status_num
]->package
;
1496 char *list_filename
;
1497 archive_handle_t
*archive_handle
;
1499 llist_t
*accept_list
;
1502 /* If existing version, remove it first */
1503 if (strcmp(name_hashtable
[get_status(status_num
, 3)], "installed") == 0) {
1504 /* Package is already installed, remove old version first */
1505 printf("Preparing to replace %s %s (using %s)...\n", package_name
,
1506 name_hashtable
[package_hashtable
[status_package_num
]->version
],
1507 deb_file
->filename
);
1508 remove_package(status_package_num
, 0);
1510 printf("Unpacking %s (from %s)...\n", package_name
, deb_file
->filename
);
1513 /* Extract control.tar.gz to /var/lib/dpkg/info/<package>.filename */
1514 info_prefix
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "");
1515 archive_handle
= init_archive_deb_ar(deb_file
->filename
);
1516 init_archive_deb_control(archive_handle
);
1520 while (i
< ARRAY_SIZE(all_control_files
)) {
1521 char *c
= xasprintf("./%s", all_control_files
[i
]);
1522 llist_add_to(&accept_list
, c
);
1525 archive_handle
->sub_archive
->accept
= accept_list
;
1526 archive_handle
->sub_archive
->filter
= filter_accept_list
;
1527 archive_handle
->sub_archive
->action_data
= data_extract_all_prefix
;
1528 archive_handle
->sub_archive
->buffer
= info_prefix
;
1529 archive_handle
->sub_archive
->ah_flags
|= ARCHIVE_EXTRACT_UNCONDITIONAL
;
1530 unpack_ar_archive(archive_handle
);
1532 /* Run the preinst prior to extracting */
1533 run_package_script_or_die(package_name
, "preinst");
1535 /* Extract data.tar.gz to the root directory */
1536 archive_handle
= init_archive_deb_ar(deb_file
->filename
);
1537 init_archive_deb_data(archive_handle
);
1538 archive_handle
->sub_archive
->action_data
= data_extract_all_prefix
;
1539 archive_handle
->sub_archive
->buffer
= (char*)"/"; /* huh? */
1540 archive_handle
->sub_archive
->ah_flags
|= ARCHIVE_EXTRACT_UNCONDITIONAL
;
1541 unpack_ar_archive(archive_handle
);
1543 /* Create the list file */
1544 list_filename
= xasprintf("/var/lib/dpkg/info/%s.%s", package_name
, "list");
1545 out_stream
= xfopen_for_write(list_filename
);
1546 while (archive_handle
->sub_archive
->passed
) {
1547 /* the leading . has been stripped by data_extract_all_prefix already */
1548 fputs(archive_handle
->sub_archive
->passed
->data
, out_stream
);
1549 fputc('\n', out_stream
);
1550 archive_handle
->sub_archive
->passed
= archive_handle
->sub_archive
->passed
->link
;
1555 set_status(status_num
, "install", 1);
1556 set_status(status_num
, "unpacked", 3);
1559 free(list_filename
);
1562 static void configure_package(deb_file_t
*deb_file
)
1564 const char *package_name
= name_hashtable
[package_hashtable
[deb_file
->package
]->name
];
1565 const char *package_version
= name_hashtable
[package_hashtable
[deb_file
->package
]->version
];
1566 const int status_num
= search_status_hashtable(package_name
);
1568 printf("Setting up %s (%s)...\n", package_name
, package_version
);
1570 /* Run the postinst script */
1571 /* TODO: handle failure gracefully */
1572 run_package_script_or_die(package_name
, "postinst");
1574 /* Change status to reflect success */
1575 set_status(status_num
, "install", 1);
1576 set_status(status_num
, "installed", 3);
1579 int dpkg_main(int argc
, char **argv
) MAIN_EXTERNALLY_VISIBLE
;
1580 int dpkg_main(int argc UNUSED_PARAM
, char **argv
)
1582 deb_file_t
**deb_file
= NULL
;
1583 status_node_t
*status_node
;
1592 OPT_configure
= 0x1,
1593 OPT_force_ignore_depends
= 0x2,
1595 OPT_list_installed
= 0x8,
1603 opt
= getopt32(argv
, "CF:ilPru", &str_f
);
1604 //if (opt & OPT_configure) ... // -C
1605 if (opt
& OPT_force_ignore_depends
) { // -F (--force in official dpkg)
1606 if (strcmp(str_f
, "depends"))
1607 opt
&= ~OPT_force_ignore_depends
;
1609 //if (opt & OPT_install) ... // -i
1610 //if (opt & OPT_list_installed) ... // -l
1611 //if (opt & OPT_purge) ... // -P
1612 //if (opt & OPT_remove) ... // -r
1613 //if (opt & OPT_unpack) ... // -u (--unpack in official dpkg)
1615 /* check for non-option argument if expected */
1616 if (!opt
|| (!argv
[0] && !(opt
&& OPT_list_installed
)))
1619 /* puts("(Reading database ... xxxxx files and directories installed.)"); */
1620 index_status_file("/var/lib/dpkg/status");
1622 /* if the list action was given print the installed packages and exit */
1623 if (opt
& OPT_list_installed
) {
1624 list_packages(argv
[0]);
1625 return EXIT_SUCCESS
;
1628 /* Read arguments and store relevant info in structs */
1630 /* deb_count = nb_elem - 1 and we need nb_elem + 1 to allocate terminal node [NULL pointer] */
1631 deb_file
= xrealloc_vector(deb_file
, 2, deb_count
);
1632 deb_file
[deb_count
] = xzalloc(sizeof(deb_file
[0][0]));
1633 if (opt
& (OPT_install
| OPT_unpack
)) {
1634 /* -i/-u: require filename */
1635 archive_handle_t
*archive_handle
;
1636 llist_t
*control_list
= NULL
;
1638 /* Extract the control file */
1639 llist_add_to(&control_list
, (char*)"./control");
1640 archive_handle
= init_archive_deb_ar(argv
[0]);
1641 init_archive_deb_control(archive_handle
);
1642 deb_file
[deb_count
]->control_file
= deb_extract_control_file_to_buffer(archive_handle
, control_list
);
1643 if (deb_file
[deb_count
]->control_file
== NULL
) {
1644 bb_error_msg_and_die("cannot extract control file");
1646 deb_file
[deb_count
]->filename
= xstrdup(argv
[0]);
1647 package_num
= fill_package_struct(deb_file
[deb_count
]->control_file
);
1649 if (package_num
== -1) {
1650 bb_error_msg("invalid control file in %s", argv
[0]);
1654 deb_file
[deb_count
]->package
= (unsigned) package_num
;
1656 /* Add the package to the status hashtable */
1657 if (opt
& (OPT_unpack
| OPT_install
)) {
1658 /* Try and find a currently installed version of this package */
1659 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[deb_file
[deb_count
]->package
]->name
]);
1660 /* If no previous entry was found initialise a new entry */
1661 if (status_hashtable
[status_num
] == NULL
1662 || status_hashtable
[status_num
]->status
== 0
1664 status_node
= xmalloc(sizeof(status_node_t
));
1665 status_node
->package
= deb_file
[deb_count
]->package
;
1666 /* reinstreq isnt changed to "ok" until the package control info
1667 * is written to the status file*/
1668 status_node
->status
= search_name_hashtable("install reinstreq not-installed");
1669 status_hashtable
[status_num
] = status_node
;
1671 set_status(status_num
, "install", 1);
1672 set_status(status_num
, "reinstreq", 2);
1675 } else if (opt
& (OPT_configure
| OPT_purge
| OPT_remove
)) {
1676 /* -C/-p/-r: require package name */
1677 deb_file
[deb_count
]->package
= search_package_hashtable(
1678 search_name_hashtable(argv
[0]),
1679 search_name_hashtable("ANY"), VER_ANY
);
1680 if (package_hashtable
[deb_file
[deb_count
]->package
] == NULL
) {
1681 bb_error_msg_and_die("package %s is uninstalled or unknown", argv
[0]);
1683 package_num
= deb_file
[deb_count
]->package
;
1684 status_num
= search_status_hashtable(name_hashtable
[package_hashtable
[package_num
]->name
]);
1685 state_status
= get_status(status_num
, 3);
1687 /* check package status is "installed" */
1688 if (opt
& OPT_remove
) {
1689 if (strcmp(name_hashtable
[state_status
], "not-installed") == 0
1690 || strcmp(name_hashtable
[state_status
], "config-files") == 0
1692 bb_error_msg_and_die("%s is already removed", name_hashtable
[package_hashtable
[package_num
]->name
]);
1694 set_status(status_num
, "deinstall", 1);
1695 } else if (opt
& OPT_purge
) {
1696 /* if package status is "conf-files" then its ok */
1697 if (strcmp(name_hashtable
[state_status
], "not-installed") == 0) {
1698 bb_error_msg_and_die("%s is already purged", name_hashtable
[package_hashtable
[package_num
]->name
]);
1700 set_status(status_num
, "purge", 1);
1707 bb_error_msg_and_die("no package files specified");
1708 deb_file
[deb_count
] = NULL
;
1710 /* Check that the deb file arguments are installable */
1711 if (!(opt
& OPT_force_ignore_depends
)) {
1712 if (!check_deps(deb_file
, 0 /*, deb_count*/)) {
1713 bb_error_msg_and_die("dependency check failed");
1717 /* TODO: install or remove packages in the correct dependency order */
1718 for (i
= 0; i
< deb_count
; i
++) {
1719 /* Remove or purge packages */
1720 if (opt
& OPT_remove
) {
1721 remove_package(deb_file
[i
]->package
, 1);
1723 else if (opt
& OPT_purge
) {
1724 purge_package(deb_file
[i
]->package
);
1726 else if (opt
& OPT_unpack
) {
1727 unpack_package(deb_file
[i
]);
1729 else if (opt
& OPT_install
) {
1730 unpack_package(deb_file
[i
]);
1731 /* package is configured in second pass below */
1733 else if (opt
& OPT_configure
) {
1734 configure_package(deb_file
[i
]);
1737 /* configure installed packages */
1738 if (opt
& OPT_install
) {
1739 for (i
= 0; i
< deb_count
; i
++)
1740 configure_package(deb_file
[i
]);
1743 write_status_file(deb_file
);
1745 if (ENABLE_FEATURE_CLEAN_UP
) {
1746 for (i
= 0; i
< deb_count
; i
++) {
1747 free(deb_file
[i
]->control_file
);
1748 free(deb_file
[i
]->filename
);
1754 for (i
= 0; i
< NAME_HASH_PRIME
; i
++) {
1755 free(name_hashtable
[i
]);
1758 for (i
= 0; i
< PACKAGE_HASH_PRIME
; i
++) {
1759 free_package(package_hashtable
[i
]);
1762 for (i
= 0; i
< STATUS_HASH_PRIME
; i
++) {
1763 free(status_hashtable
[i
]);
1766 free(status_hashtable
);
1767 free(package_hashtable
);
1768 free(name_hashtable
);
1771 return EXIT_SUCCESS
;