which were otherwise cluttering the global namespace.
* I estimate it should be at least 50% bigger than PACKAGE_HASH_PRIME,
* as there a lot of duplicate version numbers */
#define NAME_HASH_PRIME 16381
-char *name_hashtable[NAME_HASH_PRIME + 1];
+static char *name_hashtable[NAME_HASH_PRIME + 1];
/* PACKAGE_HASH_PRIME, Maximum number of unique packages,
* It must not be smaller than STATUS_HASH_PRIME,
unsigned int num_of_edges:14;
edge_t **edge;
} common_node_t;
-common_node_t *package_hashtable[PACKAGE_HASH_PRIME + 1];
+static common_node_t *package_hashtable[PACKAGE_HASH_PRIME + 1];
/* Currently it doesnt store packages that have state-status of not-installed
* So it only really has to be the size of the maximum number of packages
unsigned int package:14; /* has to fit PACKAGE_HASH_PRIME */
unsigned int status:14; /* has to fit STATUS_HASH_PRIME */
} status_node_t;
-status_node_t *status_hashtable[STATUS_HASH_PRIME + 1];
+static status_node_t *status_hashtable[STATUS_HASH_PRIME + 1];
/* Even numbers are for 'extras', like ored dependencies or null */
enum edge_type_e {
} deb_file_t;
-void make_hash(const char *key, unsigned int *start, unsigned int *decrement, const int hash_prime)
+static void make_hash(const char *key, unsigned int *start, unsigned int *decrement, const int hash_prime)
{
unsigned long int hash_num = key[0];
int len = strlen(key);
}
/* this adds the key to the hash table */
-int search_name_hashtable(const char *key)
+static int search_name_hashtable(const char *key)
{
unsigned int probe_address = 0;
unsigned int probe_decrement = 0;
/* this DOESNT add the key to the hashtable
* TODO make it consistent with search_name_hashtable
*/
-unsigned int search_status_hashtable(const char *key)
+static unsigned int search_status_hashtable(const char *key)
{
unsigned int probe_address = 0;
unsigned int probe_decrement = 0;
}
/* Need to rethink version comparison, maybe the official dpkg has something i can use ? */
-int version_compare_part(const char *version1, const char *version2)
+static int version_compare_part(const char *version1, const char *version2)
{
int upstream_len1 = 0;
int upstream_len2 = 0;
* if ver1 = ver2 return 0,
* if ver1 > ver2 return 1,
*/
-int version_compare(const unsigned int ver1, const unsigned int ver2)
+static int version_compare(const unsigned int ver1, const unsigned int ver2)
{
char *ch_ver1 = name_hashtable[ver1];
char *ch_ver2 = name_hashtable[ver2];
return(version_compare_part(deb_ver1, deb_ver2));
}
-int test_version(const unsigned int version1, const unsigned int version2, const unsigned int operator)
+static int test_version(const unsigned int version1, const unsigned int version2, const unsigned int operator)
{
const int version_result = version_compare(version1, version2);
switch(operator) {
}
-int search_package_hashtable(const unsigned int name, const unsigned int version, const unsigned int operator)
+static int search_package_hashtable(const unsigned int name, const unsigned int version, const unsigned int operator)
{
unsigned int probe_address = 0;
unsigned int probe_decrement = 0;
* FIXME: I don't think this is very efficient, but I thought I'd keep
* it simple for now until it proves to be a problem.
*/
-int search_for_provides(int needle, int start_at) {
+static int search_for_provides(int needle, int start_at) {
int i, j;
common_node_t *p;
for (i = start_at + 1; i < PACKAGE_HASH_PRIME; i++) {
/*
* Add an edge to a node
*/
-void add_edge_to_node(common_node_t *node, edge_t *edge)
+static void add_edge_to_node(common_node_t *node, edge_t *edge)
{
node->num_of_edges++;
node->edge = xrealloc(node->edge, sizeof(edge_t) * (node->num_of_edges + 1));
* field contains the number of EDGE nodes which follow as part of
* this alternative.
*/
-void add_split_dependencies(common_node_t *parent_node, const char *whole_line, unsigned int edge_type)
+static void add_split_dependencies(common_node_t *parent_node, const char *whole_line, unsigned int edge_type)
{
char *line = bb_xstrdup(whole_line);
char *line2;
return;
}
-void free_package(common_node_t *node)
+static void free_package(common_node_t *node)
{
unsigned short i;
if (node) {
}
}
-unsigned int fill_package_struct(char *control_buffer)
+static unsigned int fill_package_struct(char *control_buffer)
{
common_node_t *new_node = (common_node_t *) xcalloc(1, sizeof(common_node_t));
const char *field_names[] = { "Package", "Version", "Pre-Depends", "Depends",
}
/* if num = 1, it returns the want status, 2 returns flag, 3 returns status */
-unsigned int get_status(const unsigned int status_node, const int num)
+static unsigned int get_status(const unsigned int status_node, const int num)
{
char *status_string = name_hashtable[status_hashtable[status_node]->status];
char *state_sub_string;
return(state_sub_num);
}
-void set_status(const unsigned int status_node_num, const char *new_value, const int position)
+static void set_status(const unsigned int status_node_num, const char *new_value, const int position)
{
const unsigned int new_value_len = strlen(new_value);
const unsigned int new_value_num = search_name_hashtable(new_value);
return;
}
-const char *describe_status(int status_num) {
+static const char *describe_status(int status_num) {
int status_want, status_state ;
if ( status_hashtable[status_num] == NULL || status_hashtable[status_num]->status == 0 )
return "is not installed or flagged to be installed\n";
}
-void index_status_file(const char *filename)
+static void index_status_file(const char *filename)
{
FILE *status_file;
char *control_buffer;
}
#endif
-void write_buffer_no_status(FILE *new_status_file, const char *control_buffer)
+static void write_buffer_no_status(FILE *new_status_file, const char *control_buffer)
{
char *name;
char *value;
}
/* This could do with a cleanup */
-void write_status_file(deb_file_t **deb_file)
+static void write_status_file(deb_file_t **deb_file)
{
FILE *old_status_file = bb_xfopen("/var/lib/dpkg/status", "r");
FILE *new_status_file = bb_xfopen("/var/lib/dpkg/status.udeb", "w");
* which a regular depends can be satisfied by a package which we want
* to install.
*/
-int package_satisfies_dependency(int package, int depend_type)
+static int package_satisfies_dependency(int package, int depend_type)
{
int status_num = search_status_hashtable(name_hashtable[package_hashtable[package]->name]);
return 0;
}
-int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
+static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
{
int *conflicts = NULL;
int conflicts_num = 0;
return(TRUE);
}
-char **create_list(const char *filename)
+static char **create_list(const char *filename)
{
FILE *list_stream;
char **file_list = NULL;
}
/* maybe i should try and hook this into remove_file.c somehow */
-int remove_file_array(char **remove_names, char **exclude_names)
+static int remove_file_array(char **remove_names, char **exclude_names)
{
struct stat path_stat;
int match_flag;
return(remove_flag);
}
-int run_package_script(const char *package_name, const char *script_type)
+static int run_package_script(const char *package_name, const char *script_type)
{
struct stat path_stat;
char *script_path;
return(result);
}
-const char *all_control_files[] = {"preinst", "postinst", "prerm", "postrm",
+static const char *all_control_files[] = {"preinst", "postinst", "prerm", "postrm",
"list", "md5sums", "shlibs", "conffiles", "config", "templates", NULL };
-char **all_control_list(const char *package_name)
+static char **all_control_list(const char *package_name)
{
unsigned short i = 0;
char **remove_files;
return(remove_files);
}
-void free_array(char **array)
+static void free_array(char **array)
{
if (array) {
}
}
-void remove_package(const unsigned int package_num, int noisy)
+static void remove_package(const unsigned int package_num, int noisy)
{
const char *package_name = name_hashtable[package_hashtable[package_num]->name];
const char *package_version = name_hashtable[package_hashtable[package_num]->version];
set_status(status_num, "config-files", 3);
}
-void purge_package(const unsigned int package_num)
+static void purge_package(const unsigned int package_num)
{
const char *package_name = name_hashtable[package_hashtable[package_num]->name];
const char *package_version = name_hashtable[package_hashtable[package_num]->version];
free(info_prefix);
}
-void configure_package(deb_file_t *deb_file)
+static void configure_package(deb_file_t *deb_file)
{
const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name];
const char *package_version = name_hashtable[package_hashtable[deb_file->package]->version];
#include <stdlib.h>
#include <unistd.h>
#include "libbb.h"
+#include "unarchive.h" /* for external decl of check_header_gzip */
extern void check_header_gzip(int src_fd)
{
#define MAXCODE(n) (1L << (n))
/* Block compress mode -C compatible with 2.0 */
-int block_mode = BLOCK_MODE;
+static int block_mode = BLOCK_MODE;
/* user settable max # bits/code */
-int maxbits = BITS;
+static int maxbits = BITS;
/* Exitcode of compress (-1 no file compressed) */
-int exit_code = -1;
+static int exit_code = -1;
/* Input buffer */
-unsigned char inbuf[IBUFSIZ + 64];
+static unsigned char inbuf[IBUFSIZ + 64];
/* Output buffer */
-unsigned char outbuf[OBUFSIZ + 2048];
+static unsigned char outbuf[OBUFSIZ + 2048];
-long int htab[HSIZE];
-unsigned short codetab[HSIZE];
+static long int htab[HSIZE];
+static unsigned short codetab[HSIZE];
#define htabof(i) htab[i]
#define codetabof(i) codetab[i]
uint32_t size; /* Size of store (4 bytes) */
};
-void skip_header(int rpm_fd)
+static void skip_header(int rpm_fd)
{
struct rpm_header header;
}
/* This could become a common function for md5 as well, by using md5_stream */
-extern int hash_files(int argc, char **argv, const uint8_t hash_algo)
+static int hash_files(int argc, char **argv, const uint8_t hash_algo)
{
int return_value = EXIT_SUCCESS;
uint8_t *hash_value;
#include <unistd.h>
#include "busybox.h"
-int global_flags;
+static int global_flags;
/*
sort [-m][-o output][-bdfinru][-t char][-k keydef]... [file...]
#ifdef CONFIG_SORT_BIG
-char key_separator;
+static char key_separator;
-struct sort_key
+static struct sort_key
{
struct sort_key *next_key; /* linked list */
unsigned short range[4]; /* start word, start char, end word, end char */
/* globals */
/* options */
static int be_quiet, in_place, regex_type;
-FILE *nonstdout;
-char *outname,*hold_space;
+static FILE *nonstdout;
+static char *outname,*hold_space;
/* List of input files */
-int input_file_count,current_input_file;
-FILE **input_file_list;
+static int input_file_count,current_input_file;
+static FILE **input_file_list;
static const char bad_format_in_subst[] =
"bad format in substitution expression";
-const char *const semicolon_whitespace = "; \n\r\t\v";
+static const char *const semicolon_whitespace = "; \n\r\t\v";
-regmatch_t regmatch[10];
+static regmatch_t regmatch[10];
static regex_t *previous_regex_ptr;
/* linked list of sed commands */
static sed_cmd_t *sed_cmd_tail = &sed_cmd_head;
/* Linked list of append lines */
-struct append_list {
+static struct append_list {
char *string;
struct append_list *next;
};
-struct append_list *append_head=NULL, *append_tail=NULL;
+static struct append_list *append_head=NULL, *append_tail=NULL;
#ifdef CONFIG_FEATURE_CLEAN_UP
static void free_and_close_stuff(void)
/* Parse address+command sets, skipping comment lines. */
-void add_cmd(char *cmdstr)
+static void add_cmd(char *cmdstr)
{
static char *add_cmd_line=NULL;
sed_cmd_t *sed_cmd;
/* Append to a string, reallocating memory as necessary. */
-struct pipeline {
+static struct pipeline {
char *buf; /* Space to hold string */
int idx; /* Space used */
int len; /* Space allocated */
#define PIPE_GROW 64
-void pipe_putc(char c)
+static void pipe_putc(char c)
{
if(pipeline.idx==pipeline.len) {
pipeline.buf = xrealloc(pipeline.buf, pipeline.len + PIPE_GROW);
append_head=append_tail=NULL;
}
-void add_input_file(FILE *file)
+static void add_input_file(FILE *file)
{
input_file_list=xrealloc(input_file_list,(input_file_count+1)*sizeof(FILE *));
input_file_list[input_file_count++]=file;
#endif
#ifdef CONFIG_FEATURE_FIND_NEWER
-time_t newer_mtime;
+static time_t newer_mtime;
#endif
#ifdef CONFIG_FEATURE_FIND_INUM
static uint32_t bits[4] = { 0x80000000, 0x00800000, 0x00008000, 0x00000080 };
# endif /* __BYTE_ORDER */
-void sha1_end(unsigned char hval[], struct sha1_ctx_t *ctx)
+static void sha1_end(unsigned char hval[], struct sha1_ctx_t *ctx)
{
uint32_t i, cnt = (uint32_t) (ctx->count[0] & SHA1_MASK);
return err;
}
-char *get_name(char *name, char *p)
+static char *get_name(char *name, char *p)
{
/* Extract <name>[:<alias>] from nul-terminated p where p matches
<name>[:<alias>]: after leading whitespace.
/* Storage for things detected while the login name was read. */
-struct chardata {
+static struct chardata {
int erase; /* erase character */
int kill; /* kill character */
int eol; /* end-of-line character */
/* Initial values for the above. */
-struct chardata init_chardata = {
+static struct chardata init_chardata = {
DEF_ERASE, /* default erase character */
DEF_KILL, /* default kill character */
13, /* default eol char */
static void checkutmp(int picky);
static void setutmp(const char *name, const char *line);
/* Stuff global to this file */
-struct utmp utent;
+static struct utmp utent;
#endif
// login defines
static void set_filesize_limit(int blocks);
-int get_algo(char *a)
+static int get_algo(char *a)
{
int x = 1; /* standard: MD5 */
}
-extern int update_passwd(const struct passwd *pw, char *crypt_pw)
+static int update_passwd(const struct passwd *pw, char *crypt_pw)
{
char filename[1024];
char buf[1025];
static struct spwd *spw;
/* getspuid - get a shadow entry by uid */
-struct spwd *getspuid(uid_t uid)
+static struct spwd *getspuid(uid_t uid)
{
struct spwd *sp;
struct passwd *mypw;
/* Busybox messages and functions */
-const char * const bb_msg_shared_mem ="could not %s sharedmem buf";
-const char * const bb_msg_op_not_supp =" operation not supported on %s disks";
+static const char * const bb_msg_shared_mem ="could not %s sharedmem buf";
+static const char * const bb_msg_op_not_supp =" operation not supported on %s disks";
static void bb_ioctl(int fd, int request, void *argp, const char *string)
{
static int autoclean, show_only, quiet, do_syslog, verbose;
static int k_version;
-int parse_tag_value ( char *buffer, char **ptag, char **pvalue )
+static int parse_tag_value ( char *buffer, char **ptag, char **pvalue )
{
char *tag, *value;
return err;
}
-void finish(void)
+static void finish(void)
{
if (!quiet) {
printf("Sent %d probes (%d broadcast(s))\n", sent, brd_sent);
exit(!received);
}
-void catcher(void)
+static void catcher(void)
{
struct timeval tv;
static struct timeval start;
alarm(1);
}
-int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)
+static int recv_pack(unsigned char *buf, int len, struct sockaddr_ll *FROM)
{
struct timeval tv;
struct arphdr *ah = (struct arphdr *) buf;
{ "loopback", loopback_up6, loopback_down6, },
};
-struct address_family_t addr_inet6 = {
+static struct address_family_t addr_inet6 = {
"inet6",
sizeof(methods6) / sizeof(struct method_t),
methods6
{ "loopback", loopback_up, loopback_down, },
};
-struct address_family_t addr_inet =
+static struct address_family_t addr_inet =
{
"inet",
sizeof(methods) / sizeof(struct method_t),
struct rtnl_handle *rth;
} filter;
-void print_link_flags(FILE *fp, unsigned flags, unsigned mdown)
+static void print_link_flags(FILE *fp, unsigned flags, unsigned mdown)
{
fprintf(fp, "<");
flags &= ~IFF_RUNNING;
return -1;
}
-int do_del(int argc, char **argv)
+static int do_del(int argc, char **argv)
{
struct ip_tunnel_parm p;
return -1;
}
-void print_tunnel(struct ip_tunnel_parm *p)
+static void print_tunnel(struct ip_tunnel_parm *p)
{
char s1[256];
char s2[256];
#undef __PF
-char * ll_proto_n2a(unsigned short id, char *buf, int len)
+const char * ll_proto_n2a(unsigned short id, char *buf, int len)
{
int i;
#include <linux/if_arp.h>
-char * ll_type_n2a(int type, char *buf, int len)
+const char * ll_type_n2a(int type, char *buf, int len)
{
#define __PF(f,n) { ARPHRD_##f, #n },
static struct {
rtnl_rtprot_tab, 256);
}
-char * rtnl_rtprot_n2a(int id, char *buf, int len)
+const char * rtnl_rtprot_n2a(int id, char *buf, int len)
{
if (id<0 || id>=256) {
snprintf(buf, len, "%d", id);
rtnl_rtscope_tab, 256);
}
-char * rtnl_rtscope_n2a(int id, char *buf, int len)
+const char * rtnl_rtscope_n2a(int id, char *buf, int len)
{
if (id<0 || id>=256) {
snprintf(buf, len, "%d", id);
rtnl_rtrealm_tab, 256);
}
-char * rtnl_rtrealm_n2a(int id, char *buf, int len)
+const char * rtnl_rtrealm_n2a(int id, char *buf, int len)
{
if (id<0 || id>=256) {
snprintf(buf, len, "%d", id);
rtnl_rttable_tab, 256);
}
-char * rtnl_rttable_n2a(int id, char *buf, int len)
+const char * rtnl_rttable_n2a(int id, char *buf, int len)
{
if (id<0 || id>=256) {
snprintf(buf, len, "%d", id);
rtnl_rtdsfield_tab, 256);
}
-char * rtnl_dsfield_n2a(int id, char *buf, int len)
+const char * rtnl_dsfield_n2a(int id, char *buf, int len)
{
if (id<0 || id>=256) {
snprintf(buf, len, "%d", id);
}
/* Check ascii str_macaddr, convert and copy to *mac */
-struct ether_addr *cc_macaddr(char *str_macaddr)
+static struct ether_addr *cc_macaddr(char *str_macaddr)
{
struct ether_addr *lmac, *mac;
static unsigned long tmin = ULONG_MAX, tmax, tsum;
static char rcvd_tbl[MAX_DUP_CHK / 8];
-struct hostent *hostent;
+#ifndef CONFIG_FEATURE_FANCY_PING6
+static
+#endif
+ struct hostent *hostent;
static void sendping(int);
static void pingstats(int);
}
}
+/* also used in netstat */
void displayroutes(int noresolve, int netstatfmt)
{
char devname[64], flags[16], sdest[16], sgw[16];
"No such user"
};
-const int tftp_cmd_get = 1;
-const int tftp_cmd_put = 2;
+static const int tftp_cmd_get = 1;
+static const int tftp_cmd_put = 2;
#ifdef CONFIG_FEATURE_TFTP_BLOCKSIZE
#ifndef _SCRIPT_H
#define _SCRIPT_H
-void run_script(struct dhcpMessage *packet, const char *name);
+extern void run_script(struct dhcpMessage *packet, const char *name);
#endif
/*
* Base64-encode character string
* oops... isn't something similar in uuencode.c?
- * It would be better to use already existing code
+ * XXX: It would be better to use already existing code
*/
-char *base64enc(unsigned char *p, char *buf, int len) {
+static char *base64enc(unsigned char *p, char *buf, int len) {
char al[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789+/";
return (int)((Q->stime + Q->utime) - (P->stime + P->utime));
}
-int mult_lvl_cmp(void* a, void* b) {
+static int mult_lvl_cmp(void* a, void* b) {
int i, cmp_val;
for(i = 0; i < sort_depth; i++) {