treewrite: use Lindent to reformat to kernel coding style
authorJo-Philipp Wich <jo@mein.io>
Fri, 10 Feb 2017 10:20:23 +0000 (11:20 +0100)
committerJo-Philipp Wich <jo@mein.io>
Fri, 10 Feb 2017 10:20:23 +0000 (11:20 +0100)
Use the kernels "Lindent" script to reformat files using kernel coding style.
This should make subsequent refactoring much easier.

Signed-off-by: Jo-Philipp Wich <jo@mein.io>
96 files changed:
libbb/all_read.c
libbb/concat_path_file.c
libbb/copy_file.c
libbb/copy_file_chunk.c
libbb/gz_open.c
libbb/gzip.c
libbb/gzip.h
libbb/last_char_is.c
libbb/libbb.h
libbb/make_directory.c
libbb/mode_string.c
libbb/parse_mode.c
libbb/safe_strncpy.c
libbb/time_string.c
libbb/unarchive.c
libbb/unzip.c
libbb/wfopen.c
libbb/xfuncs.c
libbb/xreadlink.c
libopkg/active_list.c
libopkg/active_list.h
libopkg/conffile.c
libopkg/conffile.h
libopkg/conffile_list.c
libopkg/conffile_list.h
libopkg/file_util.c
libopkg/file_util.h
libopkg/hash_table.c
libopkg/hash_table.h
libopkg/list.h
libopkg/md5.c
libopkg/md5.h
libopkg/nv_pair.c
libopkg/nv_pair.h
libopkg/nv_pair_list.c
libopkg/nv_pair_list.h
libopkg/opkg.c
libopkg/opkg.h
libopkg/opkg_cmd.c
libopkg/opkg_cmd.h
libopkg/opkg_conf.c
libopkg/opkg_conf.h
libopkg/opkg_configure.c
libopkg/opkg_configure.h
libopkg/opkg_download.c
libopkg/opkg_download.h
libopkg/opkg_install.c
libopkg/opkg_install.h
libopkg/opkg_message.c
libopkg/opkg_message.h
libopkg/opkg_pathfinder.c
libopkg/opkg_pathfinder.h
libopkg/opkg_remove.c
libopkg/opkg_remove.h
libopkg/opkg_upgrade.c
libopkg/opkg_upgrade.h
libopkg/opkg_utils.c
libopkg/opkg_utils.h
libopkg/parse_util.c
libopkg/parse_util.h
libopkg/pkg.c
libopkg/pkg.h
libopkg/pkg_depends.c
libopkg/pkg_depends.h
libopkg/pkg_dest.c
libopkg/pkg_dest.h
libopkg/pkg_dest_list.c
libopkg/pkg_dest_list.h
libopkg/pkg_extract.c
libopkg/pkg_extract.h
libopkg/pkg_hash.c
libopkg/pkg_hash.h
libopkg/pkg_parse.c
libopkg/pkg_parse.h
libopkg/pkg_src.c
libopkg/pkg_src.h
libopkg/pkg_src_list.c
libopkg/pkg_src_list.h
libopkg/pkg_vec.c
libopkg/pkg_vec.h
libopkg/sha256.c
libopkg/sha256.h
libopkg/sprintf_alloc.c
libopkg/str_list.c
libopkg/str_list.h
libopkg/void_list.c
libopkg/void_list.h
libopkg/xregex.c
libopkg/xregex.h
libopkg/xsystem.c
libopkg/xsystem.h
src/opkg-cl.c
tests/libopkg_test.c
tests/opkg_active_list_test.c
tests/opkg_extract_test.c
tests/opkg_hash_test.c

index 6ec731a..371dcaf 100644 (file)
 #include <errno.h>
 #include "libbb.h"
 
-extern void archive_xread_all(int fd , char *buf, size_t count)
+extern void archive_xread_all(int fd, char *buf, size_t count)
 {
-        ssize_t size;
+       ssize_t size;
 
-        size = full_read(fd, buf, count);
-        if (size != count) {
-                perror_msg_and_die("Short read");
-        }
-        return;
+       size = full_read(fd, buf, count);
+       if (size != count) {
+               perror_msg_and_die("Short read");
+       }
+       return;
 }
 
 /*
@@ -43,41 +43,37 @@ extern void archive_xread_all(int fd , char *buf, size_t count)
  */
 ssize_t full_read(int fd, char *buf, int len)
 {
-        ssize_t cc;
-        ssize_t total;
+       ssize_t cc;
+       ssize_t total;
 
-        total = 0;
+       total = 0;
 
-        while (len > 0) {
-                cc = safe_read(fd, buf, len);
+       while (len > 0) {
+               cc = safe_read(fd, buf, len);
 
-                if (cc < 0)
-                        return cc;      /* read() returns -1 on failure. */
+               if (cc < 0)
+                       return cc;      /* read() returns -1 on failure. */
 
-                if (cc == 0)
-                        break;
+               if (cc == 0)
+                       break;
 
-                buf = ((char *)buf) + cc;
-                total += cc;
-                len -= cc;
-        }
+               buf = ((char *)buf) + cc;
+               total += cc;
+               len -= cc;
+       }
 
-        return total;
+       return total;
 }
 
-
 ssize_t safe_read(int fd, void *buf, size_t count)
 {
-        ssize_t n;
+       ssize_t n;
 
-        do {
-                n = read(fd, buf, count);
-        } while (n < 0 && errno == EINTR);
+       do {
+               n = read(fd, buf, count);
+       } while (n < 0 && errno == EINTR);
 
-        return n;
+       return n;
 }
 
-
-
 /* END CODE */
-
index e62b99e..f0cb552 100644 (file)
@@ -34,12 +34,12 @@ extern char *concat_path_file(const char *path, const char *filename)
        char *lc;
 
        if (!path)
-           path="";
+               path = "";
        lc = last_char_is(path, '/');
        while (*filename == '/')
                filename++;
-       outbuf = xmalloc(strlen(path)+strlen(filename)+1+(lc==NULL));
-       sprintf(outbuf, "%s%s%s", path, (lc==NULL)? "/" : "", filename);
+       outbuf = xmalloc(strlen(path) + strlen(filename) + 1 + (lc == NULL));
+       sprintf(outbuf, "%s%s%s", path, (lc == NULL) ? "/" : "", filename);
 
        return outbuf;
 }
index fb76669..849e6d8 100644 (file)
@@ -41,9 +41,9 @@ int copy_file(const char *source, const char *dest, int flags)
        int status = 0;
 
        if (((flags & FILEUTILS_PRESERVE_SYMLINKS) &&
-                       lstat(source, &source_stat) < 0) ||
-                       (!(flags & FILEUTILS_PRESERVE_SYMLINKS) &&
-                        stat(source, &source_stat) < 0)) {
+            lstat(source, &source_stat) < 0) ||
+           (!(flags & FILEUTILS_PRESERVE_SYMLINKS) &&
+            stat(source, &source_stat) < 0)) {
                perror_msg("%s", source);
                return -1;
        }
@@ -57,7 +57,7 @@ int copy_file(const char *source, const char *dest, int flags)
        }
 
        if (dest_exists && source_stat.st_rdev == dest_stat.st_rdev &&
-                       source_stat.st_ino == dest_stat.st_ino) {
+           source_stat.st_ino == dest_stat.st_ino) {
                error_msg("`%s' and `%s' are the same file", source, dest);
                return -1;
        }
@@ -89,7 +89,8 @@ int copy_file(const char *source, const char *dest, int flags)
 
                        if (mkdir(dest, mode) < 0) {
                                umask(saved_umask);
-                               perror_msg("cannot create directory `%s'", dest);
+                               perror_msg("cannot create directory `%s'",
+                                          dest);
                                return -1;
                        }
 
@@ -107,7 +108,7 @@ int copy_file(const char *source, const char *dest, int flags)
                        char *new_source, *new_dest;
 
                        if (strcmp(d->d_name, ".") == 0 ||
-                                       strcmp(d->d_name, "..") == 0)
+                           strcmp(d->d_name, "..") == 0)
                                continue;
 
                        new_source = concat_path_file(source, d->d_name);
@@ -126,8 +127,9 @@ int copy_file(const char *source, const char *dest, int flags)
                }
 
                if (!dest_exists &&
-                               chmod(dest, source_stat.st_mode & ~saved_umask) < 0) {
-                       perror_msg("unable to change permissions of `%s'", dest);
+                   chmod(dest, source_stat.st_mode & ~saved_umask) < 0) {
+                       perror_msg("unable to change permissions of `%s'",
+                                  dest);
                        status = -1;
                }
        } else if (S_ISREG(source_stat.st_mode)) {
@@ -141,7 +143,8 @@ int copy_file(const char *source, const char *dest, int flags)
                                }
 
                                if (unlink(dest) < 0) {
-                                       perror_msg("unable to remove `%s'", dest);
+                                       perror_msg("unable to remove `%s'",
+                                                  dest);
                                        return -1;
                                }
 
@@ -152,8 +155,10 @@ int copy_file(const char *source, const char *dest, int flags)
                if (!dest_exists) {
                        int fd;
 
-                       if ((fd = open(dest, O_WRONLY|O_CREAT, source_stat.st_mode)) < 0 ||
-                                       (dfp = fdopen(fd, "w")) == NULL) {
+                       if ((fd =
+                            open(dest, O_WRONLY | O_CREAT,
+                                 source_stat.st_mode)) < 0
+                           || (dfp = fdopen(fd, "w")) == NULL) {
                                if (fd >= 0)
                                        close(fd);
                                perror_msg("unable to open `%s'", dest);
@@ -180,8 +185,8 @@ int copy_file(const char *source, const char *dest, int flags)
                        perror_msg("unable to close `%s'", source);
                        status = -1;
                }
-       } else if (S_ISBLK(source_stat.st_mode) || S_ISCHR(source_stat.st_mode) ||
-                       S_ISSOCK(source_stat.st_mode)) {
+       } else if (S_ISBLK(source_stat.st_mode) || S_ISCHR(source_stat.st_mode)
+                  || S_ISSOCK(source_stat.st_mode)) {
                if (mknod(dest, source_stat.st_mode, source_stat.st_rdev) < 0) {
                        perror_msg("unable to create `%s'", dest);
                        return -1;
@@ -201,8 +206,11 @@ int copy_file(const char *source, const char *dest, int flags)
 
 #if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
                if (flags & FILEUTILS_PRESERVE_STATUS)
-                       if (lchown(dest, source_stat.st_uid, source_stat.st_gid) < 0)
-                               perror_msg("unable to preserve ownership of `%s'", dest);
+                       if (lchown(dest, source_stat.st_uid, source_stat.st_gid)
+                           < 0)
+                               perror_msg
+                                   ("unable to preserve ownership of `%s'",
+                                    dest);
 #endif
                return 0;
        } else {
@@ -221,10 +229,12 @@ end:
                        perror_msg("unable to preserve times of `%s'", dest);
                if (chown(dest, source_stat.st_uid, source_stat.st_gid) < 0) {
                        source_stat.st_mode &= ~(S_ISUID | S_ISGID);
-                       perror_msg("unable to preserve ownership of `%s'", dest);
+                       perror_msg("unable to preserve ownership of `%s'",
+                                  dest);
                }
                if (chmod(dest, source_stat.st_mode) < 0)
-                       perror_msg("unable to preserve permissions of `%s'", dest);
+                       perror_msg("unable to preserve permissions of `%s'",
+                                  dest);
        }
 
        return status;
index 63d2ab1..16edfe3 100644 (file)
@@ -27,7 +27,8 @@
 
 /* Copy CHUNKSIZE bytes (or until EOF if CHUNKSIZE equals -1) from SRC_FILE
  * to DST_FILE.  */
-extern int copy_file_chunk(FILE *src_file, FILE *dst_file, unsigned long long chunksize)
+extern int copy_file_chunk(FILE * src_file, FILE * dst_file,
+                          unsigned long long chunksize)
 {
        size_t nread, nwritten, size;
        char buffer[BUFSIZ];
@@ -38,27 +39,27 @@ extern int copy_file_chunk(FILE *src_file, FILE *dst_file, unsigned long long ch
                else
                        size = chunksize;
 
-               nread = fread (buffer, 1, size, src_file);
+               nread = fread(buffer, 1, size, src_file);
 
-               if (nread != size && ferror (src_file)) {
-                       perror_msg ("read");
+               if (nread != size && ferror(src_file)) {
+                       perror_msg("read");
                        return -1;
                } else if (nread == 0) {
                        if (chunksize != -1) {
-                               error_msg ("Unable to read all data");
+                               error_msg("Unable to read all data");
                                return -1;
                        }
 
                        return 0;
                }
 
-               nwritten = fwrite (buffer, 1, nread, dst_file);
+               nwritten = fwrite(buffer, 1, nread, dst_file);
 
                if (nwritten != nread) {
-                       if (ferror (dst_file))
-                               perror_msg ("write");
+                       if (ferror(dst_file))
+                               perror_msg("write");
                        else
-                               error_msg ("Unable to write all data");
+                               error_msg("Unable to write all data");
                        return -1;
                }
 
index bdc7564..bf5efca 100644 (file)
@@ -31,8 +31,7 @@
 
 static int gz_use_vfork;
 
-FILE *
-gz_open(FILE *compressed_file, int *pid)
+FILE *gz_open(FILE * compressed_file, int *pid)
 {
        int unzip_pipe[2];
        off_t floc;
@@ -51,9 +50,9 @@ gz_open(FILE *compressed_file, int *pid)
                setenv("GZIP", "--quiet", 0);
        }
 
-       if (pipe(unzip_pipe)!=0) {
+       if (pipe(unzip_pipe) != 0) {
                perror_msg("pipe");
-               return(NULL);
+               return (NULL);
        }
 
        /* If we don't flush, we end up with two copies of anything pending,
@@ -67,18 +66,18 @@ gz_open(FILE *compressed_file, int *pid)
                *pid = fork();
        }
 
-       if (*pid<0) {
+       if (*pid < 0) {
                perror_msg("fork");
-               return(NULL);
+               return (NULL);
        }
 
-       if (*pid==0) {
+       if (*pid == 0) {
                /* child process */
                close(unzip_pipe[0]);
                if (gz_use_vfork) {
                        dup2(unzip_pipe[1], 1);
                        dup2(cfile, 0);
-                       execlp("gunzip","gunzip",NULL);
+                       execlp("gunzip", "gunzip", NULL);
                        /* If we get here, we had a failure */
                        _exit(EXIT_FAILURE);
                } else {
@@ -94,11 +93,10 @@ gz_open(FILE *compressed_file, int *pid)
                close(cfile);
        }
        close(unzip_pipe[1]);
-       return(fdopen(unzip_pipe[0], "r"));
+       return (fdopen(unzip_pipe[0], "r"));
 }
 
-int
-gz_close(int gunzip_pid)
+int gz_close(int gunzip_pid)
 {
        int status;
        int ret;
@@ -115,7 +113,6 @@ gz_close(int gunzip_pid)
                }
        }
 
-
        if (waitpid(gunzip_pid, &status, 0) == -1) {
                perror_msg("waitpid");
                return -1;
@@ -128,20 +125,20 @@ gz_close(int gunzip_pid)
 
        if (WIFSIGNALED(status)) {
                error_msg("Unzip process killed by signal %d.\n",
-                       WTERMSIG(status));
+                         WTERMSIG(status));
                return -1;
        }
 
        if (!WIFEXITED(status)) {
                /* shouldn't happen */
-               error_msg("Your system is broken: got status %d from waitpid.\n",
-                               status);
+               error_msg
+                   ("Your system is broken: got status %d from waitpid.\n",
+                    status);
                return -1;
        }
 
        if ((ret = WEXITSTATUS(status))) {
-               error_msg("Unzip process failed with return code %d.\n",
-                               ret);
+               error_msg("Unzip process failed with return code %d.\n", ret);
                return -1;
        }
 
index ecdb5cb..db22523 100644 (file)
@@ -30,8 +30,7 @@
 
 #include "gzip.h"
 
-static void
-to_devnull(int fd)
+static void to_devnull(int fd)
 {
        int devnull = open("/dev/null", fd ? O_WRONLY : O_RDONLY);
 
@@ -42,8 +41,7 @@ to_devnull(int fd)
                close(devnull);
 }
 
-void *
-gzip_thread(void *ptr)
+void *gzip_thread(void *ptr)
 {
        struct gzip_handle *zh = ptr;
        char buf[4096];
@@ -67,11 +65,11 @@ gzip_thread(void *ptr)
        zh->wfd = -1;
 }
 
-int
-gzip_exec(struct gzip_handle *zh, const char *filename)
+int gzip_exec(struct gzip_handle *zh, const char *filename)
 {
-       int rpipe[2] = { -1, -1 }, wpipe[2] = { -1, -1 };
-       struct sigaction pipe_sa = { .sa_handler = SIG_IGN };
+       int rpipe[2] = { -1, -1 }, wpipe[2] = {
+       -1, -1};
+       struct sigaction pipe_sa = {.sa_handler = SIG_IGN };
 
        zh->rfd = -1;
        zh->wfd = -1;
@@ -91,47 +89,46 @@ gzip_exec(struct gzip_handle *zh, const char *filename)
        zh->pid = vfork();
 
        switch (zh->pid) {
-               case -1:
-                       return -1;
-
-               case 0:
-                       to_devnull(STDERR_FILENO);
-
-                       if (filename) {
-                               to_devnull(STDIN_FILENO);
-                       }
-                       else {
-                               dup2(wpipe[0], STDIN_FILENO);
-                               close(wpipe[0]);
-                               close(wpipe[1]);
-                       }
-
-                       dup2(rpipe[1], STDOUT_FILENO);
-                       close(rpipe[0]);
-                       close(rpipe[1]);
-
-                       execlp("gzip", "gzip", "-d",  "-c", filename, NULL);
-                       exit(-1);
-
-               default:
-                       zh->rfd = rpipe[0];
-                       zh->wfd = wpipe[1];
-
-                       fcntl(zh->rfd, F_SETFD, fcntl(zh->rfd, F_GETFD) | FD_CLOEXEC);
-                       close(rpipe[1]);
-
-                       if (zh->wfd >= 0) {
-                               fcntl(zh->wfd, F_SETFD, fcntl(zh->wfd, F_GETFD) | FD_CLOEXEC);
-                               close(wpipe[0]);
-                               pthread_create(&zh->thread, NULL, gzip_thread, zh);
-                       }
+       case -1:
+               return -1;
+
+       case 0:
+               to_devnull(STDERR_FILENO);
+
+               if (filename) {
+                       to_devnull(STDIN_FILENO);
+               } else {
+                       dup2(wpipe[0], STDIN_FILENO);
+                       close(wpipe[0]);
+                       close(wpipe[1]);
+               }
+
+               dup2(rpipe[1], STDOUT_FILENO);
+               close(rpipe[0]);
+               close(rpipe[1]);
+
+               execlp("gzip", "gzip", "-d", "-c", filename, NULL);
+               exit(-1);
+
+       default:
+               zh->rfd = rpipe[0];
+               zh->wfd = wpipe[1];
+
+               fcntl(zh->rfd, F_SETFD, fcntl(zh->rfd, F_GETFD) | FD_CLOEXEC);
+               close(rpipe[1]);
+
+               if (zh->wfd >= 0) {
+                       fcntl(zh->wfd, F_SETFD,
+                             fcntl(zh->wfd, F_GETFD) | FD_CLOEXEC);
+                       close(wpipe[0]);
+                       pthread_create(&zh->thread, NULL, gzip_thread, zh);
+               }
        }
 
        return 0;
 }
 
-ssize_t
-gzip_read(struct gzip_handle *zh, char *buf, ssize_t len)
+ssize_t gzip_read(struct gzip_handle * zh, char *buf, ssize_t len)
 {
        ssize_t ret;
 
@@ -142,15 +139,14 @@ gzip_read(struct gzip_handle *zh, char *buf, ssize_t len)
        return ret;
 }
 
-ssize_t
-gzip_copy(struct gzip_handle *zh, FILE *out, ssize_t len)
+ssize_t gzip_copy(struct gzip_handle * zh, FILE * out, ssize_t len)
 {
        char buf[4096];
        ssize_t rlen, total = 0;
 
        while (len > 0) {
                rlen = gzip_read(zh, buf,
-                                   (len > sizeof(buf)) ? sizeof(buf) : len);
+                                (len > sizeof(buf)) ? sizeof(buf) : len);
 
                if (rlen <= 0)
                        break;
@@ -167,8 +163,7 @@ gzip_copy(struct gzip_handle *zh, FILE *out, ssize_t len)
        return total;
 }
 
-FILE *
-gzip_fdopen(struct gzip_handle *zh, const char *filename)
+FILE *gzip_fdopen(struct gzip_handle * zh, const char *filename)
 {
        memset(zh, 0, sizeof(*zh));
 
@@ -180,8 +175,7 @@ gzip_fdopen(struct gzip_handle *zh, const char *filename)
        return fdopen(zh->rfd, "r");
 }
 
-int
-gzip_close(struct gzip_handle *zh)
+int gzip_close(struct gzip_handle *zh)
 {
        int code = -1;
 
index 07e8e7a..13398d4 100644 (file)
@@ -34,7 +34,7 @@ struct gzip_handle {
 
 int gzip_exec(struct gzip_handle *zh, const char *filename);
 ssize_t gzip_read(struct gzip_handle *zh, char *buf, ssize_t len);
-ssize_t gzip_copy(struct gzip_handle *zh, FILE *out, ssize_t len);
+ssize_t gzip_copy(struct gzip_handle *zh, FILE * out, ssize_t len);
 int gzip_close(struct gzip_handle *zh);
 FILE *gzip_fdopen(struct gzip_handle *zh, const char *filename);
 
index 26c2423..8c6dd6f 100644 (file)
  * underrun the buffer if the string length is 0.  Also avoids a possible
  * space-hogging inline of strlen() per usage.
  */
-char * last_char_is(const char *s, int c)
+char *last_char_is(const char *s, int c)
 {
        char *sret;
        if (!s)
-           return NULL;
-       sret  = (char *)s+strlen(s)-1;
-       if (sret>=s && *sret == c) {
+               return NULL;
+       sret = (char *)s + strlen(s) - 1;
+       if (sret >= s && *sret == c) {
                return sret;
        } else {
                return NULL;
index 4e1fafc..bc1ae21 100644 (file)
@@ -56,20 +56,21 @@ const char *mode_string(int mode);
 const char *time_string(time_t timeVal);
 
 int copy_file(const char *source, const char *dest, int flags);
-int copy_file_chunk(FILE *src_file, FILE *dst_file, unsigned long long chunksize);
+int copy_file_chunk(FILE * src_file, FILE * dst_file,
+                   unsigned long long chunksize);
 ssize_t safe_read(int fd, void *buf, size_t count);
 ssize_t full_read(int fd, char *buf, int len);
 
-extern int parse_mode( const char* s, mode_t* theMode);
+extern int parse_mode(const char *s, mode_t * theMode);
 
 extern FILE *wfopen(const char *path, const char *mode);
 extern FILE *xfopen(const char *path, const char *mode);
 
-extern void *xmalloc (size_t size);
+extern void *xmalloc(size_t size);
 extern void *xrealloc(void *old, size_t size);
 extern void *xcalloc(size_t nmemb, size_t size);
-extern char *xstrdup (const char *s);
-extern char *xstrndup (const char *s, int n);
+extern char *xstrdup(const char *s);
+extern char *xstrndup(const char *s, int n);
 extern char *safe_strncpy(char *dst, const char *src, size_t size);
 
 char *xreadlink(const char *path);
@@ -103,15 +104,15 @@ enum extract_functions_e {
        extract_exclude_list = 4096
 };
 
-char *deb_extract(const char *package_filename, FILE *out_stream,
-               const int extract_function, const char *prefix,
-               const char *filename, int *err);
+char *deb_extract(const char *package_filename, FILE * out_stream,
+                 const int extract_function, const char *prefix,
+                 const char *filename, int *err);
 
-extern int unzip(FILE *l_in_file, FILE *l_out_file);
+extern int unzip(FILE * l_in_file, FILE * l_out_file);
 extern int gz_close(int gunzip_pid);
-extern FILE *gz_open(FILE *compressed_file, int *pid);
+extern FILE *gz_open(FILE * compressed_file, int *pid);
 
-int make_directory (const char *path, long mode, int flags);
+int make_directory(const char *path, long mode, int flags);
 
 enum {
        FILEUTILS_PRESERVE_STATUS = 1,
index 86ab554..3dfef7b 100644 (file)
  * Also create parent directories as necessary if flags contains
  * FILEUTILS_RECUR.  */
 
-int make_directory (const char *path, long mode, int flags)
+int make_directory(const char *path, long mode, int flags)
 {
        if (!(flags & FILEUTILS_RECUR)) {
-               if (mkdir (path, 0777) < 0) {
-                       perror_msg ("Cannot create directory `%s'", path);
+               if (mkdir(path, 0777) < 0) {
+                       perror_msg("Cannot create directory `%s'", path);
                        return -1;
                }
 
-               if (mode != -1 && chmod (path, mode) < 0) {
-                       perror_msg ("Cannot set permissions of directory `%s'", path);
+               if (mode != -1 && chmod(path, mode) < 0) {
+                       perror_msg("Cannot set permissions of directory `%s'",
+                                  path);
                        return -1;
                }
        } else {
                struct stat st;
 
-               if (stat (path, &st) < 0 && errno == ENOENT) {
+               if (stat(path, &st) < 0 && errno == ENOENT) {
                        int status;
                        char *pathcopy, *parent, *parentcopy;
                        mode_t mask;
 
-                       mask = umask (0);
-                       umask (mask);
+                       mask = umask(0);
+                       umask(mask);
 
                        /* dirname is unsafe, it may both modify the
                           memory of the path argument and may return
                           a pointer to static memory, which can then
                           be modified by consequtive calls to dirname */
 
-                       pathcopy = xstrdup (path);
-                       parent = dirname (pathcopy);
-                       parentcopy = xstrdup (parent);
-                       status = make_directory (parentcopy, (0777 & ~mask)
-                                                                        | 0300, FILEUTILS_RECUR);
-                       free (pathcopy);
-                       free (parentcopy);
+                       pathcopy = xstrdup(path);
+                       parent = dirname(pathcopy);
+                       parentcopy = xstrdup(parent);
+                       status = make_directory(parentcopy, (0777 & ~mask)
+                                               | 0300, FILEUTILS_RECUR);
+                       free(pathcopy);
+                       free(parentcopy);
 
-
-                       if (status < 0 || make_directory (path, mode, 0) < 0)
+                       if (status < 0 || make_directory(path, mode, 0) < 0)
                                return -1;
                }
        }
index 12dc179..f1a6933 100644 (file)
@@ -24,8 +24,6 @@
 #include <stdio.h>
 #include "libbb.h"
 
-
-
 #define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
 #define TYPECHAR(mode)  ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)])
 
@@ -43,8 +41,8 @@ static const mode_t MBIT[] = {
        S_IROTH, S_IWOTH, S_IXOTH
 };
 
-static const char MODE1[]  = "rwxrwxrwx";
-static const char MODE0[]  = "---------";
+static const char MODE1[] = "rwxrwxrwx";
+static const char MODE0[] = "---------";
 static const char SMODE1[] = "..s..s..t";
 static const char SMODE0[] = "..S..S..T";
 
index 02668c7..b43b0ea 100644 (file)
 #include <stdlib.h>
 #include "libbb.h"
 
-
 /* This function parses the sort of string you might pass
  * to chmod (i.e., [ugoa]{+|-|=}[rwxst] ) and returns the
  * correct mode described by the string. */
 extern int parse_mode(const char *s, mode_t * theMode)
 {
        static const mode_t group_set[] = {
-               S_ISUID | S_IRWXU,              /* u */
-               S_ISGID | S_IRWXG,              /* g */
-               S_IRWXO,                                /* o */
-               S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO /* a */
+               S_ISUID | S_IRWXU,      /* u */
+               S_ISGID | S_IRWXG,      /* g */
+               S_IRWXO,        /* o */
+               S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO       /* a */
        };
 
        static const mode_t mode_set[] = {
-               S_IRUSR | S_IRGRP | S_IROTH, /* r */
-               S_IWUSR | S_IWGRP | S_IWOTH, /* w */
-               S_IXUSR | S_IXGRP | S_IXOTH, /* x */
-               S_ISUID | S_ISGID,              /* s */
-               S_ISVTX                                 /* t */
+               S_IRUSR | S_IRGRP | S_IROTH,    /* r */
+               S_IWUSR | S_IWGRP | S_IWOTH,    /* w */
+               S_IXUSR | S_IXGRP | S_IXOTH,    /* x */
+               S_ISUID | S_ISGID,      /* s */
+               S_ISVTX         /* t */
        };
 
        static const char group_chars[] = "ugoa";
@@ -52,69 +51,69 @@ extern int parse_mode(const char *s, mode_t * theMode)
        const char *p;
 
        mode_t andMode =
-               S_ISVTX | S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
+           S_ISVTX | S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
        mode_t orMode = 0;
        mode_t mode;
        mode_t groups;
        char type;
        char c;
 
-       if (s==NULL) {
+       if (s == NULL) {
                return (FALSE);
        }
 
        do {
                mode = 0;
                groups = 0;
-       NEXT_GROUP:
+NEXT_GROUP:
                if ((c = *s++) == '\0') {
                        return -1;
                }
-               for (p=group_chars ; *p ; p++) {
+               for (p = group_chars; *p; p++) {
                        if (*p == c) {
-                               groups |= group_set[(int)(p-group_chars)];
+                               groups |= group_set[(int)(p - group_chars)];
                                goto NEXT_GROUP;
                        }
                }
                switch (c) {
-                       case '=':
-                       case '+':
-                       case '-':
-                               type = c;
-                               if (groups == 0) { /* The default is "all" */
-                                       groups |= S_ISUID | S_ISGID | S_ISVTX
-                                                       | S_IRWXU | S_IRWXG | S_IRWXO;
-                               }
-                               break;
-                       default:
-                               if ((c < '0') || (c > '7') || (mode | groups)) {
-                                       return (FALSE);
-                               } else {
-                                       *theMode = strtol(--s, NULL, 8);
-                                       return (TRUE);
-                               }
+               case '=':
+               case '+':
+               case '-':
+                       type = c;
+                       if (groups == 0) {      /* The default is "all" */
+                               groups |= S_ISUID | S_ISGID | S_ISVTX
+                                   | S_IRWXU | S_IRWXG | S_IRWXO;
+                       }
+                       break;
+               default:
+                       if ((c < '0') || (c > '7') || (mode | groups)) {
+                               return (FALSE);
+                       } else {
+                               *theMode = strtol(--s, NULL, 8);
+                               return (TRUE);
+                       }
                }
 
-       NEXT_MODE:
+NEXT_MODE:
                if (((c = *s++) != '\0') && (c != ',')) {
-                       for (p=mode_chars ; *p ; p++) {
+                       for (p = mode_chars; *p; p++) {
                                if (*p == c) {
-                                       mode |= mode_set[(int)(p-mode_chars)];
+                                       mode |= mode_set[(int)(p - mode_chars)];
                                        goto NEXT_MODE;
                                }
                        }
-                       break;                          /* We're done so break out of loop.*/
+                       break;  /* We're done so break out of loop. */
                }
                switch (type) {
-                       case '=':
-                               andMode &= ~(groups); /* Now fall through. */
-                       case '+':
-                               orMode |= mode & groups;
-                               break;
-                       case '-':
-                               andMode &= ~(mode & groups);
-                               orMode &= ~(mode & groups);
-                               break;
+               case '=':
+                       andMode &= ~(groups);   /* Now fall through. */
+               case '+':
+                       orMode |= mode & groups;
+                       break;
+               case '-':
+                       andMode &= ~(mode & groups);
+                       orMode &= ~(mode & groups);
+                       break;
                }
        } while (c == ',');
 
index eb2dbab..a81381f 100644 (file)
 #include <string.h>
 #include "libbb.h"
 
-
-
 /* Like strncpy but make sure the resulting string is always 0 terminated. */
-extern char * safe_strncpy(char *dst, const char *src, size_t size)
+extern char *safe_strncpy(char *dst, const char *src, size_t size)
 {
-       dst[size-1] = '\0';
-       return strncpy(dst, src, size-1);
+       dst[size - 1] = '\0';
+       return strncpy(dst, src, size - 1);
 }
 
-
 /* END CODE */
 /*
 Local Variables:
index d103a02..af90a1e 100644 (file)
@@ -25,7 +25,6 @@
 #include <utime.h>
 #include "libbb.h"
 
-
 /*
  * Return the standard ls-like time string from a time_t
  * This is static and so is overwritten on each call.
@@ -51,7 +50,6 @@ const char *time_string(time_t timeVal)
        return buf;
 }
 
-
 /* END CODE */
 /*
 Local Variables:
index 6ee473b..08f50bf 100644 (file)
@@ -40,8 +40,7 @@ static char *linkname = NULL;
 
 off_t archive_offset;
 
-static ssize_t
-seek_forward(struct gzip_handle *zh, ssize_t len)
+static ssize_t seek_forward(struct gzip_handle *zh, ssize_t len)
 {
        ssize_t slen = gzip_seek(zh, len);
 
@@ -51,7 +50,6 @@ seek_forward(struct gzip_handle *zh, ssize_t len)
        return slen;
 }
 
-
 /* Extract the data postioned at src_stream to either filesystem, stdout or
  * buffer depending on the value of 'function' which is defined in libbb.h
  *
@@ -64,11 +62,9 @@ seek_forward(struct gzip_handle *zh, ssize_t len)
  * For this reason if prefix does point to a dir then it must end with a
  * trailing '/' or else the last dir will be assumed to be the file prefix
  */
-static char *
-extract_archive(struct gzip_handle *src_stream, FILE *out_stream,
-               const file_header_t *file_entry, const int function,
-               const char *prefix,
-               int *err)
+static char *extract_archive(struct gzip_handle *src_stream, FILE * out_stream,
+                            const file_header_t * file_entry,
+                            const int function, const char *prefix, int *err)
 {
        FILE *dst_stream = NULL;
        char *full_name = NULL;
@@ -93,118 +89,137 @@ extract_archive(struct gzip_handle *src_stream, FILE *out_stream,
                full_name = xmalloc(strlen(prefix) + strlen(path) + 1);
                strcpy(full_name, prefix);
                strcat(full_name, path);
-                if ( file_entry->link_name ){
-                  full_link_name = xmalloc(strlen(prefix) + strlen(file_entry->link_name) + 1);
-                  strcpy(full_link_name, prefix);
-                  strcat(full_link_name, file_entry->link_name);
-                }
+               if (file_entry->link_name) {
+                       full_link_name =
+                           xmalloc(strlen(prefix) +
+                                   strlen(file_entry->link_name) + 1);
+                       strcpy(full_link_name, prefix);
+                       strcat(full_link_name, file_entry->link_name);
+               }
        } else {
                full_name = xstrdup(file_entry->name);
-                if ( file_entry->link_name )
-                  full_link_name = xstrdup(file_entry->link_name);
+               if (file_entry->link_name)
+                       full_link_name = xstrdup(file_entry->link_name);
        }
 
-
        if (function & extract_to_stream) {
                if (S_ISREG(file_entry->mode)) {
-                       *err = gzip_copy(src_stream, out_stream, file_entry->size);
+                       *err =
+                           gzip_copy(src_stream, out_stream, file_entry->size);
                        archive_offset += file_entry->size;
                }
-       }
-       else if (function & extract_one_to_buffer) {
+       } else if (function & extract_one_to_buffer) {
                if (S_ISREG(file_entry->mode)) {
-                       buffer = (char *) xmalloc(file_entry->size + 1);
+                       buffer = (char *)xmalloc(file_entry->size + 1);
                        gzip_read(src_stream, buffer, file_entry->size);
                        buffer[file_entry->size] = '\0';
                        archive_offset += file_entry->size;
                        goto cleanup;
                }
-       }
-       else if (function & extract_all_to_fs) {
+       } else if (function & extract_all_to_fs) {
                struct stat oldfile;
                int stat_res;
-               stat_res = lstat (full_name, &oldfile);
-               if (stat_res == 0) { /* The file already exists */
-                       if ((function & extract_unconditional) || (oldfile.st_mtime < file_entry->mtime)) {
+               stat_res = lstat(full_name, &oldfile);
+               if (stat_res == 0) {    /* The file already exists */
+                       if ((function & extract_unconditional)
+                           || (oldfile.st_mtime < file_entry->mtime)) {
                                if (!S_ISDIR(oldfile.st_mode)) {
-                                       unlink(full_name); /* Directories might not be empty etc */
+                                       unlink(full_name);      /* Directories might not be empty etc */
                                }
                        } else {
                                if ((function & extract_quiet) != extract_quiet) {
                                        *err = -1;
-                                       error_msg("%s not created: newer or same age file exists", file_entry->name);
+                                       error_msg
+                                           ("%s not created: newer or same age file exists",
+                                            file_entry->name);
                                }
                                seek_forward(src_stream, file_entry->size);
                                goto cleanup;
                        }
                }
-               if (function & extract_create_leading_dirs) { /* Create leading directories with default umask */
+               if (function & extract_create_leading_dirs) {   /* Create leading directories with default umask */
                        char *buf, *parent;
                        buf = xstrdup(full_name);
                        parent = dirname(buf);
-                       if (make_directory (parent, -1, FILEUTILS_RECUR) != 0) {
+                       if (make_directory(parent, -1, FILEUTILS_RECUR) != 0) {
                                if ((function & extract_quiet) != extract_quiet) {
                                        *err = -1;
-                                       error_msg("couldn't create leading directories");
+                                       error_msg
+                                           ("couldn't create leading directories");
                                }
                        }
-                       free (buf);
+                       free(buf);
                }
-               switch(file_entry->mode & S_IFMT) {
-                       case S_IFREG:
-                               if (file_entry->link_name) { /* Found a cpio hard link */
-                                       if (link(full_link_name, full_name) != 0) {
-                                               if ((function & extract_quiet) != extract_quiet) {
-                                                       *err = -1;
-                                                       perror_msg("Cannot link from %s to '%s'",
-                                                               file_entry->name, file_entry->link_name);
-                                               }
-                                       }
-                               } else {
-                                       if ((dst_stream = wfopen(full_name, "w")) == NULL) {
+               switch (file_entry->mode & S_IFMT) {
+               case S_IFREG:
+                       if (file_entry->link_name) {    /* Found a cpio hard link */
+                               if (link(full_link_name, full_name) != 0) {
+                                       if ((function & extract_quiet) !=
+                                           extract_quiet) {
                                                *err = -1;
-                                               seek_forward(src_stream, file_entry->size);
-                                               goto cleanup;
-                                       }
-                                       archive_offset += file_entry->size;
-                                       *err = gzip_copy(src_stream, dst_stream, file_entry->size);
-                                       fclose(dst_stream);
-                               }
-                               break;
-                       case S_IFDIR:
-                               if (stat_res != 0) {
-                                       if (mkdir(full_name, file_entry->mode) < 0) {
-                                               if ((function & extract_quiet) != extract_quiet) {
-                                                       *err = -1;
-                                                       perror_msg("Cannot make dir %s", full_name);
-                                               }
+                                               perror_msg
+                                                   ("Cannot link from %s to '%s'",
+                                                    file_entry->name,
+                                                    file_entry->link_name);
                                        }
                                }
-                               break;
-                       case S_IFLNK:
-                               if (symlink(file_entry->link_name, full_name) < 0) {
-                                       if ((function & extract_quiet) != extract_quiet) {
-                                               *err = -1;
-                                               perror_msg("Cannot create symlink from %s to '%s'", file_entry->name, file_entry->link_name);
-                                       }
+                       } else {
+                               if ((dst_stream =
+                                    wfopen(full_name, "w")) == NULL) {
+                                       *err = -1;
+                                       seek_forward(src_stream,
+                                                    file_entry->size);
                                        goto cleanup;
                                }
-                               break;
-                       case S_IFSOCK:
-                       case S_IFBLK:
-                       case S_IFCHR:
-                       case S_IFIFO:
-                               if (mknod(full_name, file_entry->mode, file_entry->device) == -1) {
-                                       if ((function & extract_quiet) != extract_quiet) {
+                               archive_offset += file_entry->size;
+                               *err =
+                                   gzip_copy(src_stream, dst_stream,
+                                             file_entry->size);
+                               fclose(dst_stream);
+                       }
+                       break;
+               case S_IFDIR:
+                       if (stat_res != 0) {
+                               if (mkdir(full_name, file_entry->mode) < 0) {
+                                       if ((function & extract_quiet) !=
+                                           extract_quiet) {
                                                *err = -1;
-                                               perror_msg("Cannot create node %s", file_entry->name);
+                                               perror_msg("Cannot make dir %s",
+                                                          full_name);
                                        }
-                                       goto cleanup;
                                }
-                               break;
-                         default:
-                               *err = -1;
-                               perror_msg("Don't know how to handle %s", full_name);
+                       }
+                       break;
+               case S_IFLNK:
+                       if (symlink(file_entry->link_name, full_name) < 0) {
+                               if ((function & extract_quiet) != extract_quiet) {
+                                       *err = -1;
+                                       perror_msg
+                                           ("Cannot create symlink from %s to '%s'",
+                                            file_entry->name,
+                                            file_entry->link_name);
+                               }
+                               goto cleanup;
+                       }
+                       break;
+               case S_IFSOCK:
+               case S_IFBLK:
+               case S_IFCHR:
+               case S_IFIFO:
+                       if (mknod
+                           (full_name, file_entry->mode,
+                            file_entry->device) == -1) {
+                               if ((function & extract_quiet) != extract_quiet) {
+                                       *err = -1;
+                                       perror_msg("Cannot create node %s",
+                                                  file_entry->name);
+                               }
+                               goto cleanup;
+                       }
+                       break;
+               default:
+                       *err = -1;
+                       perror_msg("Don't know how to handle %s", full_name);
 
                }
 
@@ -234,31 +249,29 @@ extract_archive(struct gzip_handle *src_stream, FILE *out_stream,
        /* extract_list and extract_verbose_list can be used in conjunction
         * with one of the above four extraction functions, so do this seperately */
        if (function & extract_verbose_list) {
-               fprintf(out_stream, "%s %d/%d %8d %s ", mode_string(file_entry->mode),
-                       file_entry->uid, file_entry->gid,
-                       (int) file_entry->size, time_string(file_entry->mtime));
+               fprintf(out_stream, "%s %d/%d %8d %s ",
+                       mode_string(file_entry->mode), file_entry->uid,
+                       file_entry->gid, (int)file_entry->size,
+                       time_string(file_entry->mtime));
        }
-       if ((function & extract_list) || (function & extract_verbose_list)){
+       if ((function & extract_list) || (function & extract_verbose_list)) {
                /* fputs doesnt add a trailing \n, so use fprintf */
                fprintf(out_stream, "%s\n", file_entry->name);
        }
 
 cleanup:
        free(full_name);
-        if ( full_link_name )
-           free(full_link_name);
+       if (full_link_name)
+               free(full_link_name);
 
        return buffer;
 }
 
-static char *
-unarchive(struct gzip_handle *src_stream, FILE *out_stream,
-               file_header_t *(*get_headers)(struct gzip_handle *),
-               void (*free_headers)(file_header_t *),
-               const int extract_function,
-               const char *prefix,
-               const char **extract_names,
-               int *err)
+static char *unarchive(struct gzip_handle *src_stream, FILE * out_stream,
+                      file_header_t * (*get_headers) (struct gzip_handle *),
+                      void (*free_headers) (file_header_t *),
+                      const int extract_function,
+                      const char *prefix, const char **extract_names, int *err)
 {
        file_header_t *file_entry;
        int extract_flag;
@@ -278,7 +291,7 @@ unarchive(struct gzip_handle *src_stream, FILE *out_stream,
                        if (p[0] == '.' && p[1] == '/')
                                p += 2;
 
-                       for(i = 0; extract_names[i] != 0; i++) {
+                       for (i = 0; extract_names[i] != 0; i++) {
                                if (strcmp(extract_names[i], p) == 0) {
                                        found_flag = TRUE;
                                        break;
@@ -298,9 +311,9 @@ unarchive(struct gzip_handle *src_stream, FILE *out_stream,
 
                if (extract_flag == TRUE) {
                        buffer = extract_archive(src_stream, out_stream,
-                                       file_entry, extract_function,
-                                       prefix, err);
-                       *err = 0; /* XXX: ignore extraction errors */
+                                                file_entry, extract_function,
+                                                prefix, err);
+                       *err = 0;       /* XXX: ignore extraction errors */
                        if (*err) {
                                free_headers(file_entry);
                                break;
@@ -315,26 +328,24 @@ unarchive(struct gzip_handle *src_stream, FILE *out_stream,
        return buffer;
 }
 
-
-static file_header_t *
-get_header_tar(struct gzip_handle *tar_stream)
+static file_header_t *get_header_tar(struct gzip_handle *tar_stream)
 {
        union {
                unsigned char raw[512];
                struct {
-                       char name[100];         /*   0-99 */
-                       char mode[8];           /* 100-107 */
-                       char uid[8];            /* 108-115 */
-                       char gid[8];            /* 116-123 */
-                       char size[12];          /* 124-135 */
-                       char mtime[12];         /* 136-147 */
-                       char chksum[8];         /* 148-155 */
-                       char typeflag;          /* 156-156 */
+                       char name[100]; /*   0-99 */
+                       char mode[8];   /* 100-107 */
+                       char uid[8];    /* 108-115 */
+                       char gid[8];    /* 116-123 */
+                       char size[12];  /* 124-135 */
+                       char mtime[12]; /* 136-147 */
+                       char chksum[8]; /* 148-155 */
+                       char typeflag;  /* 156-156 */
                        char linkname[100];     /* 157-256 */
-                       char magic[6];          /* 257-262 */
+                       char magic[6];  /* 257-262 */
                        char version[2];        /* 263-264 */
-                       char uname[32];         /* 265-296 */
-                       char gname[32];         /* 297-328 */
+                       char uname[32]; /* 265-296 */
+                       char gname[32]; /* 297-328 */
                        char devmajor[8];       /* 329-336 */
                        char devminor[8];       /* 337-344 */
                        char prefix[155];       /* 345-499 */
@@ -352,8 +363,8 @@ get_header_tar(struct gzip_handle *tar_stream)
        if (gzip_read(tar_stream, tar.raw, 512) != 512) {
                /* Unfortunately its common for tar files to have all sorts of
                 * trailing garbage, fail silently */
-//             error_msg("Couldnt read header");
-               return(NULL);
+//              error_msg("Couldnt read header");
+               return (NULL);
        }
        archive_offset += 512;
 
@@ -365,57 +376,55 @@ get_header_tar(struct gzip_handle *tar_stream)
 #ifdef CONFIG_FEATURE_TAR_OLDGNU_COMPATABILITY
                if (strncmp(tar.formated.magic, "\0\0\0\0\0", 5) != 0)
 #endif
-               return(NULL);
+                       return (NULL);
        }
 
        /* Do checksum on headers */
-       for (i =  0; i < 148 ; i++) {
+       for (i = 0; i < 148; i++) {
                sum += tar.raw[i];
        }
        sum += ' ' * 8;
-       for (i =  156; i < 512 ; i++) {
+       for (i = 156; i < 512; i++) {
                sum += tar.raw[i];
        }
        if (sum != strtol(tar.formated.chksum, NULL, 8)) {
-               if ( strtol(tar.formated.chksum,NULL,8) != 0 )
+               if (strtol(tar.formated.chksum, NULL, 8) != 0)
                        error_msg("Invalid tar header checksum");
-                return(NULL);
-        }
+               return (NULL);
+       }
 
        /* convert to type'ed variables */
        tar_entry = xcalloc(1, sizeof(file_header_t));
 
-
-
        // tar_entry->name = xstrdup(tar.formated.name);
 
 /*
        parse_mode(tar.formated.mode, &tar_entry->mode);
 */
-        tar_entry->mode = 07777 & strtol(tar.formated.mode, NULL, 8);
+       tar_entry->mode = 07777 & strtol(tar.formated.mode, NULL, 8);
 
-       tar_entry->uid   = strtol(tar.formated.uid, NULL, 8);
-       tar_entry->gid   = strtol(tar.formated.gid, NULL, 8);
-       tar_entry->size  = strtol(tar.formated.size, NULL, 8);
+       tar_entry->uid = strtol(tar.formated.uid, NULL, 8);
+       tar_entry->gid = strtol(tar.formated.gid, NULL, 8);
+       tar_entry->size = strtol(tar.formated.size, NULL, 8);
        tar_entry->mtime = strtol(tar.formated.mtime, NULL, 8);
 
        tar_entry->device = (strtol(tar.formated.devmajor, NULL, 8) << 8) +
-               strtol(tar.formated.devminor, NULL, 8);
+           strtol(tar.formated.devminor, NULL, 8);
 
        /* Fix mode, used by the old format */
        switch (tar.formated.typeflag) {
-       /* hard links are detected as regular files with 0 size and a link name */
+               /* hard links are detected as regular files with 0 size and a link name */
        case '1':
-               tar_entry->mode |= S_IFREG ;
+               tar_entry->mode |= S_IFREG;
                break;
-        case 0:
-        case '0':
+       case 0:
+       case '0':
 
-# ifdef CONFIG_FEATURE_TAR_OLDGNU_COMPATABILITY
+#ifdef CONFIG_FEATURE_TAR_OLDGNU_COMPATABILITY
                if (last_char_is(tar_entry->name, '/')) {
                        tar_entry->mode |= S_IFDIR;
                } else
-# endif
+#endif
                        tar_entry->mode |= S_IFREG;
                break;
        case '2':
@@ -433,71 +442,71 @@ get_header_tar(struct gzip_handle *tar_stream)
        case '6':
                tar_entry->mode |= S_IFIFO;
                break;
-# ifdef CONFIG_FEATURE_TAR_GNU_EXTENSIONS
-       case 'L': {
+#ifdef CONFIG_FEATURE_TAR_GNU_EXTENSIONS
+       case 'L':{
                        longname = xmalloc(tar_entry->size + 1);
-                        if(gzip_read(tar_stream, longname, tar_entry->size) != tar_entry->size)
-                                return NULL;
+                       if (gzip_read(tar_stream, longname, tar_entry->size) !=
+                           tar_entry->size)
+                               return NULL;
                        longname[tar_entry->size] = '\0';
                        archive_offset += tar_entry->size;
 
-                       return(get_header_tar(tar_stream));
+                       return (get_header_tar(tar_stream));
                }
-       case 'K': {
+       case 'K':{
                        linkname = xmalloc(tar_entry->size + 1);
-                        if(gzip_read(tar_stream, linkname, tar_entry->size) != tar_entry->size)
-                                return NULL;
+                       if (gzip_read(tar_stream, linkname, tar_entry->size) !=
+                           tar_entry->size)
+                               return NULL;
                        linkname[tar_entry->size] = '\0';
                        archive_offset += tar_entry->size;
 
-                       return(get_header_tar(tar_stream));
+                       return (get_header_tar(tar_stream));
                }
        case 'D':
        case 'M':
        case 'N':
        case 'S':
        case 'V':
-               perror_msg("Ignoring GNU extension type %c", tar.formated.typeflag);
-# endif
-        default:
-                perror_msg("Unknown typeflag: 0x%x", tar.formated.typeflag);
-                break;
+               perror_msg("Ignoring GNU extension type %c",
+                          tar.formated.typeflag);
+#endif
+       default:
+               perror_msg("Unknown typeflag: 0x%x", tar.formated.typeflag);
+               break;
 
        }
 
-
 #ifdef CONFIG_FEATURE_TAR_GNU_EXTENSIONS
-        if (longname) {
-                tar_entry->name = longname;
-                longname = NULL;
-        } else
+       if (longname) {
+               tar_entry->name = longname;
+               longname = NULL;
+       } else
 #endif
-        {
-                tar_entry->name = xstrndup(tar.formated.name, 100);
-
-                if (tar.formated.prefix[0]) {
-                        char *temp = tar_entry->name;
-                        char *prefixTemp = xstrndup(tar.formated.prefix, 155);
-                        tar_entry->name = concat_path_file(prefixTemp, temp);
-                        free(temp);
-                        free(prefixTemp);
-                }
-        }
+       {
+               tar_entry->name = xstrndup(tar.formated.name, 100);
+
+               if (tar.formated.prefix[0]) {
+                       char *temp = tar_entry->name;
+                       char *prefixTemp = xstrndup(tar.formated.prefix, 155);
+                       tar_entry->name = concat_path_file(prefixTemp, temp);
+                       free(temp);
+                       free(prefixTemp);
+               }
+       }
 
        if (linkname) {
                tar_entry->link_name = linkname;
                linkname = NULL;
-       } else
-       {
+       } else {
                tar_entry->link_name = *tar.formated.linkname != '\0' ?
-                       xstrndup(tar.formated.linkname, 100) : NULL;
+                   xstrndup(tar.formated.linkname, 100) : NULL;
        }
 
-       return(tar_entry);
+       return (tar_entry);
 }
 
-static void
-free_header_tar(file_header_t *tar_entry)
+static void free_header_tar(file_header_t * tar_entry)
 {
        if (tar_entry == NULL)
                return;
@@ -509,10 +518,9 @@ free_header_tar(file_header_t *tar_entry)
        free(tar_entry);
 }
 
-char *
-deb_extract(const char *package_filename, FILE *out_stream,
-       const int extract_function, const char *prefix,
-       const char *filename, int *err)
+char *deb_extract(const char *package_filename, FILE * out_stream,
+                 const int extract_function, const char *prefix,
+                 const char *filename, int *err)
 {
        FILE *deb_stream = NULL;
        file_header_t *ar_header = NULL;
@@ -535,15 +543,14 @@ deb_extract(const char *package_filename, FILE *out_stream,
 
        if (extract_function & extract_control_tar_gz) {
                ared_file = "control.tar.gz";
-       }
-       else if (extract_function & extract_data_tar_gz) {
+       } else if (extract_function & extract_data_tar_gz) {
                ared_file = "data.tar.gz";
        } else {
-                opkg_msg(ERROR, "Internal error: extract_function=%x\n",
-                               extract_function);
+               opkg_msg(ERROR, "Internal error: extract_function=%x\n",
+                        extract_function);
                *err = -1;
                goto cleanup;
-        }
+       }
 
        /* open the debian package to be worked on */
        deb_stream = wfopen(package_filename, "r");
@@ -560,11 +567,11 @@ deb_extract(const char *package_filename, FILE *out_stream,
 
        /* walk through outer tar file to find ared_file */
        while ((tar_header = get_header_tar(&tar_outer)) != NULL) {
-                    int name_offset = 0;
-                    if (strncmp(tar_header->name, "./", 2) == 0)
-                            name_offset = 2;
+               int name_offset = 0;
+               if (strncmp(tar_header->name, "./", 2) == 0)
+                       name_offset = 2;
 
-               if (strcmp(ared_file, tar_header->name+name_offset) == 0) {
+               if (strcmp(ared_file, tar_header->name + name_offset) == 0) {
                        memset(&tar_inner, 0, sizeof(tar_inner));
                        tar_inner.gzip = &tar_outer;
                        gzip_exec(&tar_inner, NULL);
@@ -576,9 +583,7 @@ deb_extract(const char *package_filename, FILE *out_stream,
                                                  get_header_tar,
                                                  free_header_tar,
                                                  extract_function,
-                                                 prefix,
-                                                 file_list,
-                                                 err);
+                                                 prefix, file_list, err);
 
                        free_header_tar(tar_header);
                        gzip_close(&tar_inner);
index 435effb..f09f032 100644 (file)
@@ -54,7 +54,7 @@ static FILE *in_file, *out_file;
 static unsigned char *window;
 static unsigned long *crc_table = NULL;
 
-static unsigned long crc; /* shift register contents */
+static unsigned long crc;      /* shift register contents */
 
 /*
  * window size--must be a power of two, and
@@ -63,21 +63,21 @@ static unsigned long crc; /* shift register contents */
 static const int WSIZE = 0x8000;
 
 /* If BMAX needs to be larger than 16, then h and x[] should be ulg. */
-static const int BMAX = 16;            /* maximum bit length of any code (16 for explode) */
-static const int N_MAX = 288;          /* maximum number of codes in any set */
+static const int BMAX = 16;    /* maximum bit length of any code (16 for explode) */
+static const int N_MAX = 288;  /* maximum number of codes in any set */
 
 static long bytes_out;         /* number of output bytes */
 static unsigned long outcnt;   /* bytes in output buffer */
 
 static unsigned hufts;         /* track memory usage */
-static unsigned long bb;                       /* bit buffer */
+static unsigned long bb;       /* bit buffer */
 static unsigned bk;            /* bits in bit buffer */
 
 typedef struct huft_s {
-       unsigned char e;                /* number of extra bits or operation */
-       unsigned char b;                /* number of bits in this code or subcode */
+       unsigned char e;        /* number of extra bits or operation */
+       unsigned char b;        /* number of bits in this code or subcode */
        union {
-               unsigned short n;               /* literal, length base, or distance base */
+               unsigned short n;       /* literal, length base, or distance base */
                struct huft_s *t;       /* pointer to next level of table */
        } v;
 } huft_t;
@@ -101,32 +101,34 @@ static void abort_gzip()
 
 static void make_crc_table()
 {
-       unsigned long table_entry;      /* crc shift register */
-       unsigned long poly = 0;      /* polynomial exclusive-or pattern */
-       int i;                /* counter for all possible eight bit values */
-       int k;                /* byte being shifted into crc apparatus */
+       unsigned long table_entry;      /* crc shift register */
+       unsigned long poly = 0; /* polynomial exclusive-or pattern */
+       int i;                  /* counter for all possible eight bit values */
+       int k;                  /* byte being shifted into crc apparatus */
 
        /* terms of polynomial defining this crc (except x^32): */
-       static int p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+       static int p[] = { 0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26 };
 
        /* initial shift register value */
        crc = 0xffffffffL;
-       crc_table = (unsigned long *) xmalloc(256 * sizeof(unsigned long));
+       crc_table = (unsigned long *)xmalloc(256 * sizeof(unsigned long));
 
        /* Make exclusive-or pattern from polynomial (0xedb88320) */
-       for (i = 0; i < sizeof(p)/sizeof(int); i++)
+       for (i = 0; i < sizeof(p) / sizeof(int); i++)
                poly |= 1L << (31 - p[i]);
 
        /* Compute and print table of CRC's, five per line */
        for (i = 0; i < 256; i++) {
                table_entry = i;
-          /* The idea to initialize the register with the byte instead of
-            * zero was stolen from Haruhiko Okumura's ar002
-            */
+               /* The idea to initialize the register with the byte instead of
+                * zero was stolen from Haruhiko Okumura's ar002
+                */
                for (k = 8; k; k--) {
-                       table_entry = table_entry & 1 ? (table_entry >> 1) ^ poly : table_entry >> 1;
+                       table_entry =
+                           table_entry & 1 ? (table_entry >> 1) ^ poly :
+                           table_entry >> 1;
                }
-               crc_table[i]=table_entry;
+               crc_table[i] = table_entry;
        }
 }
 
@@ -142,7 +144,7 @@ static void flush_window(void)
                return;
 
        for (n = 0; n < outcnt; n++) {
-               crc = crc_table[((int) crc ^ (window[n])) & 0xff] ^ (crc >> 8);
+               crc = crc_table[((int)crc ^ (window[n])) & 0xff] ^ (crc >> 8);
        }
 
        if (fwrite(window, 1, outcnt, out_file) != outcnt) {
@@ -157,7 +159,7 @@ static void flush_window(void)
                error_msg("Couldnt write");
                _exit(EXIT_FAILURE);
        }
-       bytes_out += (unsigned long) outcnt;
+       bytes_out += (unsigned long)outcnt;
        outcnt = 0;
 }
 
@@ -167,7 +169,7 @@ static void flush_window(void)
  * each table.
  * t: table to free
  */
-static int huft_free(huft_t *t)
+static int huft_free(huft_t * t)
 {
        huft_t *p, *q;
 
@@ -175,7 +177,7 @@ static int huft_free(huft_t *t)
        p = t;
        while (p != (huft_t *) NULL) {
                q = (--p)->v.t;
-               free((char *) p);
+               free((char *)p);
                p = q;
        }
        return 0;
@@ -195,31 +197,32 @@ static int huft_free(huft_t *t)
  * t:  result: starting table
  * m:  maximum lookup bits, returns actual
  */
-static int huft_build(unsigned int *b, const unsigned int n, const unsigned int s,
-       const unsigned short *d, const unsigned short *e, huft_t **t, int *m)
+static int huft_build(unsigned int *b, const unsigned int n,
+                     const unsigned int s, const unsigned short *d,
+                     const unsigned short *e, huft_t ** t, int *m)
 {
        unsigned a;             /* counter for codes of length k */
        unsigned c[BMAX + 1];   /* bit length count table */
        unsigned f;             /* i repeats in table every f entries */
        int g;                  /* maximum code length */
        int h;                  /* table level */
-       unsigned i;     /* counter, current code */
-       unsigned j;     /* counter */
-       int k;          /* number of bits in current code */
+       unsigned i;             /* counter, current code */
+       unsigned j;             /* counter */
+       int k;                  /* number of bits in current code */
        int l;                  /* bits per table (returned in m) */
        unsigned *p;            /* pointer into c[], b[], or v[] */
-       huft_t *q;      /* points to current table */
+       huft_t *q;              /* points to current table */
        huft_t r;               /* table entry for structure assignment */
        huft_t *u[BMAX];        /* table stack */
        unsigned v[N_MAX];      /* values in order of bit length */
-       int w;          /* bits before this table == (l * h) */
+       int w;                  /* bits before this table == (l * h) */
        unsigned x[BMAX + 1];   /* bit offsets, then code stack */
        unsigned *xp;           /* pointer into x */
        int y;                  /* number of dummy codes added */
        unsigned z;             /* number of entries in current table */
 
        /* Generate counts for each bit length */
-       memset ((void *)(c), 0, sizeof(c));
+       memset((void *)(c), 0, sizeof(c));
        p = b;
        i = n;
        do {
@@ -237,14 +240,14 @@ static int huft_build(unsigned int *b, const unsigned int n, const unsigned int
        for (j = 1; j <= BMAX; j++)
                if (c[j])
                        break;
-       k = j;                          /* minimum code length */
-       if ((unsigned) l < j)
+       k = j;                  /* minimum code length */
+       if ((unsigned)l < j)
                l = j;
        for (i = BMAX; i; i--)
                if (c[i])
                        break;
-       g = i;                          /* maximum code length */
-       if ((unsigned) l > i)
+       g = i;                  /* maximum code length */
+       if ((unsigned)l > i)
                l = i;
        *m = l;
 
@@ -260,7 +263,7 @@ static int huft_build(unsigned int *b, const unsigned int n, const unsigned int
        x[1] = j = 0;
        p = c + 1;
        xp = x + 2;
-       while (--i) {                   /* note that i == g from above */
+       while (--i) {           /* note that i == g from above */
                *xp++ = (j += *p++);
        }
 
@@ -273,13 +276,13 @@ static int huft_build(unsigned int *b, const unsigned int n, const unsigned int
        } while (++i < n);
 
        /* Generate the Huffman codes and for each, make the table entries */
-       x[0] = i = 0;                   /* first Huffman code is zero */
-       p = v;                          /* grab values in bit order */
-       h = -1;                         /* no tables yet--level -1 */
-       w = -l;                         /* bits decoded == (l * h) */
+       x[0] = i = 0;           /* first Huffman code is zero */
+       p = v;                  /* grab values in bit order */
+       h = -1;                 /* no tables yet--level -1 */
+       w = -l;                 /* bits decoded == (l * h) */
        u[0] = (huft_t *) NULL; /* just to keep compilers happy */
        q = (huft_t *) NULL;    /* ditto */
-       z = 0;                          /* ditto */
+       z = 0;                  /* ditto */
 
        /* go through the bit lengths (k already is bits in shortest code) */
        for (; k <= g; k++) {
@@ -289,10 +292,10 @@ static int huft_build(unsigned int *b, const unsigned int n, const unsigned int
                        /* make tables up to required level */
                        while (k > w + l) {
                                h++;
-                               w += l;         /* previous table always l bits */
+                               w += l; /* previous table always l bits */
 
                                /* compute minimum size table less than or equal to l bits */
-                               z = (z = g - w) > (unsigned) l ? l : z; /* upper limit on table size */
+                               z = (z = g - w) > (unsigned)l ? l : z;  /* upper limit on table size */
                                if ((f = 1 << (j = k - w)) > a + 1) {   /* try a k-w bit table *//* too few codes for k-w bit table */
                                        f -= a + 1;     /* deduct codes from patterns left */
                                        xp = c + k;
@@ -302,25 +305,28 @@ static int huft_build(unsigned int *b, const unsigned int n, const unsigned int
                                                f -= *xp;       /* else deduct codes from patterns */
                                        }
                                }
-                               z = 1 << j;             /* table entries for j-bit table */
+                               z = 1 << j;     /* table entries for j-bit table */
 
                                /* allocate and link in new table */
-                               if ((q = (huft_t *) xmalloc((z + 1) * sizeof(huft_t))) == NULL) {
+                               if ((q =
+                                    (huft_t *) xmalloc((z + 1) *
+                                                       sizeof(huft_t))) ==
+                                   NULL) {
                                        if (h) {
                                                huft_free(u[0]);
                                        }
                                        return 3;       /* not enough memory */
                                }
                                hufts += z + 1; /* track memory usage */
-                               *t = q + 1;             /* link to list for huft_free() */
+                               *t = q + 1;     /* link to list for huft_free() */
                                *(t = &(q->v.t)) = NULL;
-                               u[h] = ++q;             /* table starts after link */
+                               u[h] = ++q;     /* table starts after link */
 
                                /* connect to last table, if there is one */
                                if (h) {
                                        x[h] = i;       /* save pattern for backing up */
-                                       r.b = (unsigned char) l;        /* bits to dump before this table */
-                                       r.e = (unsigned char) (16 + j); /* bits in this table */
+                                       r.b = (unsigned char)l; /* bits to dump before this table */
+                                       r.e = (unsigned char)(16 + j);  /* bits in this table */
                                        r.v.t = q;      /* pointer to this table */
                                        j = i >> (w - l);       /* (get around Turbo C bug) */
                                        u[h - 1][j] = r;        /* connect to last table */
@@ -328,15 +334,15 @@ static int huft_build(unsigned int *b, const unsigned int n, const unsigned int
                        }
 
                        /* set up table entry in r */
-                       r.b = (unsigned char) (k - w);
+                       r.b = (unsigned char)(k - w);
                        if (p >= v + n)
-                               r.e = 99;               /* out of values--invalid code */
+                               r.e = 99;       /* out of values--invalid code */
                        else if (*p < s) {
-                               r.e = (unsigned char) (*p < 256 ? 16 : 15);     /* 256 is end-of-block code */
-                               r.v.n = (unsigned short) (*p);  /* simple code is just the value */
-                               p++;                    /* one compiler does not like *p++ */
+                               r.e = (unsigned char)(*p < 256 ? 16 : 15);      /* 256 is end-of-block code */
+                               r.v.n = (unsigned short)(*p);   /* simple code is just the value */
+                               p++;    /* one compiler does not like *p++ */
                        } else {
-                               r.e = (unsigned char) e[*p - s];        /* non-simple--look up in lists */
+                               r.e = (unsigned char)e[*p - s]; /* non-simple--look up in lists */
                                r.v.n = d[*p++ - s];
                        }
 
@@ -352,7 +358,7 @@ static int huft_build(unsigned int *b, const unsigned int n, const unsigned int
 
                        /* backup over finished tables */
                        while ((i & ((1 << w) - 1)) != x[h]) {
-                               h--;                    /* don't need to update q */
+                               h--;    /* don't need to update q */
                                w -= l;
                        }
                }
@@ -368,52 +374,55 @@ static int huft_build(unsigned int *b, const unsigned int n, const unsigned int
  * tl, td: literal/length and distance decoder tables
  * bl, bd: number of bits decoded by tl[] and td[]
  */
-static int inflate_codes(huft_t *tl, huft_t *td, int bl, int bd)
+static int inflate_codes(huft_t * tl, huft_t * td, int bl, int bd)
 {
-       unsigned long e;                /* table entry flag/number of extra bits */
-       unsigned long n, d;                             /* length and index for copy */
-       unsigned long w;                                /* current window position */
-       huft_t *t;                              /* pointer to table entry */
-       unsigned ml, md;                        /* masks for bl and bd bits */
-       unsigned long b;                                /* bit buffer */
+       unsigned long e;        /* table entry flag/number of extra bits */
+       unsigned long n, d;     /* length and index for copy */
+       unsigned long w;        /* current window position */
+       huft_t *t;              /* pointer to table entry */
+       unsigned ml, md;        /* masks for bl and bd bits */
+       unsigned long b;        /* bit buffer */
        unsigned k;             /* number of bits in bit buffer */
 
        /* make local copies of globals */
-       b = bb;                                 /* initialize bit buffer */
+       b = bb;                 /* initialize bit buffer */
        k = bk;
-       w = outcnt;                             /* initialize window position */
+       w = outcnt;             /* initialize window position */
 
        /* inflate the coded data */
-       ml = mask_bits[bl];                     /* precompute masks for speed */
+       ml = mask_bits[bl];     /* precompute masks for speed */
        md = mask_bits[bd];
-       for (;;) {                              /* do until end of block */
-               while (k < (unsigned) bl) {
+       for (;;) {              /* do until end of block */
+               while (k < (unsigned)bl) {
                        b |= ((unsigned long)fgetc(in_file)) << k;
                        k += 8;
                }
-               if ((e = (t = tl + ((unsigned) b & ml))->e) > 16)
-               do {
-                       if (e == 99) {
-                               return 1;
-                       }
-                       b >>= t->b;
-                       k -= t->b;
-                       e -= 16;
-                       while (k < e) {
-                               b |= ((unsigned long)fgetc(in_file)) << k;
-                               k += 8;
-                       }
-               } while ((e = (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
+               if ((e = (t = tl + ((unsigned)b & ml))->e) > 16)
+                       do {
+                               if (e == 99) {
+                                       return 1;
+                               }
+                               b >>= t->b;
+                               k -= t->b;
+                               e -= 16;
+                               while (k < e) {
+                                       b |= ((unsigned long)fgetc(in_file)) <<
+                                           k;
+                                       k += 8;
+                               }
+                       } while ((e =
+                                 (t =
+                                  t->v.t + ((unsigned)b & mask_bits[e]))->e) >
+                                16);
                b >>= t->b;
                k -= t->b;
-               if (e == 16) {          /* then it's a literal */
-                       window[w++] = (unsigned char) t->v.n;
+               if (e == 16) {  /* then it's a literal */
+                       window[w++] = (unsigned char)t->v.n;
                        if (w == WSIZE) {
-                               outcnt=(w),
-                               flush_window();
+                               outcnt = (w), flush_window();
                                w = 0;
                        }
-               } else {                                /* it's an EOB or a length */
+               } else {        /* it's an EOB or a length */
 
                        /* exit if end of block */
                        if (e == 15) {
@@ -425,17 +434,17 @@ static int inflate_codes(huft_t *tl, huft_t *td, int bl, int bd)
                                b |= ((unsigned long)fgetc(in_file)) << k;
                                k += 8;
                        }
-                       n = t->v.n + ((unsigned) b & mask_bits[e]);
+                       n = t->v.n + ((unsigned)b & mask_bits[e]);
                        b >>= e;
                        k -= e;
 
                        /* decode distance of block to copy */
-                       while (k < (unsigned) bd) {
+                       while (k < (unsigned)bd) {
                                b |= ((unsigned long)fgetc(in_file)) << k;
                                k += 8;
                        }
 
-                       if ((e = (t = td + ((unsigned) b & md))->e) > 16)
+                       if ((e = (t = td + ((unsigned)b & md))->e) > 16)
                                do {
                                        if (e == 99)
                                                return 1;
@@ -443,36 +452,43 @@ static int inflate_codes(huft_t *tl, huft_t *td, int bl, int bd)
                                        k -= t->b;
                                        e -= 16;
                                        while (k < e) {
-                                               b |= ((unsigned long)fgetc(in_file)) << k;
+                                               b |= ((unsigned long)
+                                                     fgetc(in_file)) << k;
                                                k += 8;
                                        }
-                               } while ((e = (t = t->v.t + ((unsigned) b & mask_bits[e]))->e) > 16);
+                               } while ((e =
+                                         (t =
+                                          t->v.t +
+                                          ((unsigned)b & mask_bits[e]))->e) >
+                                        16);
                        b >>= t->b;
                        k -= t->b;
                        while (k < e) {
                                b |= ((unsigned long)fgetc(in_file)) << k;
                                k += 8;
                        }
-                       d = w - t->v.n - ((unsigned) b & mask_bits[e]);
+                       d = w - t->v.n - ((unsigned)b & mask_bits[e]);
                        b >>= e;
                        k -= e;
 
                        /* do the copy */
                        do {
-                               n -= (e = (e = WSIZE - ((d &= WSIZE - 1) > w ? d : w)) > n ? n : e);
+                               n -= (e =
+                                     (e =
+                                      WSIZE - ((d &= WSIZE - 1) > w ? d : w)) >
+                                     n ? n : e);
 #if !defined(NOMEMCPY) && !defined(DEBUG)
                                if (w - d >= e) {       /* (this test assumes unsigned comparison) */
                                        memcpy(window + w, window + d, e);
                                        w += e;
                                        d += e;
-                               } else                  /* do it slow to avoid memcpy() overlap */
-#endif                                                 /* !NOMEMCPY */
+                               } else  /* do it slow to avoid memcpy() overlap */
+#endif /* !NOMEMCPY */
                                        do {
                                                window[w++] = window[d++];
                                        } while (--e);
                                if (w == WSIZE) {
-                                       outcnt=(w),
-                                       flush_window();
+                                       outcnt = (w), flush_window();
                                        w = 0;
                                }
                        } while (n);
@@ -480,8 +496,8 @@ static int inflate_codes(huft_t *tl, huft_t *td, int bl, int bd)
        }
 
        /* restore the globals from the locals */
-       outcnt = w;                     /* restore global window pointer */
-       bb = b;                         /* restore global bit buffer */
+       outcnt = w;             /* restore global window pointer */
+       bb = b;                 /* restore global bit buffer */
        bk = k;
 
        /* done */
@@ -496,24 +512,24 @@ static int inflate_codes(huft_t *tl, huft_t *td, int bl, int bd)
  */
 static int inflate_block(int *e)
 {
-       unsigned t;                     /* block type */
-       unsigned long b;                        /* bit buffer */
+       unsigned t;             /* block type */
+       unsigned long b;        /* bit buffer */
        unsigned k;             /* number of bits in bit buffer */
-       static unsigned short cplens[] = {              /* Copy lengths for literal codes 257..285 */
+       static unsigned short cplens[] = {      /* Copy lengths for literal codes 257..285 */
                3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
                35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
        };
        /* note: see note #13 above about the 258 in this list. */
-       static unsigned short cplext[] = {              /* Extra bits for literal codes 257..285 */
+       static unsigned short cplext[] = {      /* Extra bits for literal codes 257..285 */
                0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
                3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99
-       };                              /* 99==invalid */
-       static unsigned short cpdist[] = {              /* Copy offsets for distance codes 0..29 */
+       };                      /* 99==invalid */
+       static unsigned short cpdist[] = {      /* Copy offsets for distance codes 0..29 */
                1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
                257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
                8193, 12289, 16385, 24577
        };
-       static unsigned short cpdext[] = {              /* Extra bits for distance codes */
+       static unsigned short cpdext[] = {      /* Extra bits for distance codes */
                0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
                7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
                12, 12, 13, 13
@@ -528,7 +544,7 @@ static int inflate_block(int *e)
                b |= ((unsigned long)fgetc(in_file)) << k;
                k += 8;
        }
-       *e = (int) b & 1;
+       *e = (int)b & 1;
        b >>= 1;
        k -= 1;
 
@@ -537,7 +553,7 @@ static int inflate_block(int *e)
                b |= ((unsigned long)fgetc(in_file)) << k;
                k += 8;
        }
-       t = (unsigned) b & 3;
+       t = (unsigned)b & 3;
        b >>= 2;
        k -= 2;
 
@@ -547,17 +563,17 @@ static int inflate_block(int *e)
 
        /* inflate that block type */
        switch (t) {
-       case 0: /* Inflate stored */
+       case 0:         /* Inflate stored */
                {
-                       unsigned long n;                        /* number of bytes in block */
-                       unsigned long w;                        /* current window position */
-                       unsigned long b_stored;                 /* bit buffer */
-                       unsigned long k_stored;         /* number of bits in bit buffer */
+                       unsigned long n;        /* number of bytes in block */
+                       unsigned long w;        /* current window position */
+                       unsigned long b_stored; /* bit buffer */
+                       unsigned long k_stored; /* number of bits in bit buffer */
 
                        /* make local copies of globals */
-                       b_stored = bb;                          /* initialize bit buffer */
+                       b_stored = bb;  /* initialize bit buffer */
                        k_stored = bk;
-                       w = outcnt;                     /* initialize window position */
+                       w = outcnt;     /* initialize window position */
 
                        /* go to byte boundary */
                        n = k_stored & 7;
@@ -566,18 +582,20 @@ static int inflate_block(int *e)
 
                        /* get the length and its complement */
                        while (k_stored < 16) {
-                               b_stored |= ((unsigned long)fgetc(in_file)) << k_stored;
+                               b_stored |=
+                                   ((unsigned long)fgetc(in_file)) << k_stored;
                                k_stored += 8;
                        }
-                       n = ((unsigned) b_stored & 0xffff);
+                       n = ((unsigned)b_stored & 0xffff);
                        b_stored >>= 16;
                        k_stored -= 16;
                        while (k_stored < 16) {
-                               b_stored |= ((unsigned long)fgetc(in_file)) << k_stored;
+                               b_stored |=
+                                   ((unsigned long)fgetc(in_file)) << k_stored;
                                k_stored += 8;
                        }
-                       if (n != (unsigned) ((~b_stored) & 0xffff)) {
-                               return 1;               /* error in compressed data */
+                       if (n != (unsigned)((~b_stored) & 0xffff)) {
+                               return 1;       /* error in compressed data */
                        }
                        b_stored >>= 16;
                        k_stored -= 16;
@@ -585,13 +603,14 @@ static int inflate_block(int *e)
                        /* read and output the compressed data */
                        while (n--) {
                                while (k_stored < 8) {
-                                       b_stored |= ((unsigned long)fgetc(in_file)) << k_stored;
+                                       b_stored |=
+                                           ((unsigned long)fgetc(in_file)) <<
+                                           k_stored;
                                        k_stored += 8;
                                }
-                               window[w++] = (unsigned char) b_stored;
+                               window[w++] = (unsigned char)b_stored;
                                if (w == (unsigned long)WSIZE) {
-                                       outcnt=(w),
-                                       flush_window();
+                                       outcnt = (w), flush_window();
                                        w = 0;
                                }
                                b_stored >>= 8;
@@ -599,22 +618,22 @@ static int inflate_block(int *e)
                        }
 
                        /* restore the globals from the locals */
-                       outcnt = w;                     /* restore global window pointer */
-                       bb = b_stored;                          /* restore global bit buffer */
+                       outcnt = w;     /* restore global window pointer */
+                       bb = b_stored;  /* restore global bit buffer */
                        bk = k_stored;
                        return 0;
                }
-       case 1: /* Inflate fixed
-                        * decompress an inflated type 1 (fixed Huffman codes) block.  We should
-                        * either replace this with a custom decoder, or at least precompute the
-                        * Huffman tables.
-                        */
+       case 1:         /* Inflate fixed
+                                * decompress an inflated type 1 (fixed Huffman codes) block.  We should
+                                * either replace this with a custom decoder, or at least precompute the
+                                * Huffman tables.
+                                */
                {
-                       int i;                                  /* temporary variable */
-                       huft_t *tl;                             /* literal/length code table */
-                       huft_t *td;                             /* distance code table */
-                       int bl;                                 /* lookup bits for tl */
-                       int bd;                                 /* lookup bits for td */
+                       int i;  /* temporary variable */
+                       huft_t *tl;     /* literal/length code table */
+                       huft_t *td;     /* distance code table */
+                       int bl; /* lookup bits for tl */
+                       int bd; /* lookup bits for td */
                        unsigned int l[288];    /* length list for huft_build */
 
                        /* set up literal table */
@@ -631,7 +650,9 @@ static int inflate_block(int *e)
                                l[i] = 8;
                        }
                        bl = 7;
-                       if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) {
+                       if ((i =
+                            huft_build(l, 288, 257, cplens, cplext, &tl,
+                                       &bl)) != 0) {
                                return i;
                        }
 
@@ -640,7 +661,9 @@ static int inflate_block(int *e)
                                l[i] = 5;
                        }
                        bd = 5;
-                       if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) {
+                       if ((i =
+                            huft_build(l, 30, 0, cpdist, cpdext, &td,
+                                       &bd)) > 1) {
                                huft_free(tl);
                                return i;
                        }
@@ -657,31 +680,32 @@ static int inflate_block(int *e)
                        huft_free(td);
                        return 0;
                }
-       case 2: /* Inflate dynamic */
+       case 2:         /* Inflate dynamic */
                {
                        /* Tables for deflate from PKZIP's appnote.txt. */
                        static unsigned border[] = {    /* Order of the bit length code lengths */
-                               16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+                               16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3,
+                                   13, 2, 14, 1, 15
                        };
-                       int dbits = 6;                                  /* bits in base distance lookup table */
-                       int lbits = 9;                                  /* bits in base literal/length lookup table */
+                       int dbits = 6;  /* bits in base distance lookup table */
+                       int lbits = 9;  /* bits in base literal/length lookup table */
 
-                       int i;                                          /* temporary variables */
+                       int i;  /* temporary variables */
                        unsigned j;
-                       unsigned l;                                     /* last length */
-                       unsigned m;                                     /* mask for bit lengths table */
-                       unsigned n;                                     /* number of lengths to get */
-                       huft_t *tl;                     /* literal/length code table */
-                       huft_t *td;                     /* distance code table */
-                       int bl;                                         /* lookup bits for tl */
-                       int bd;                                         /* lookup bits for td */
-                       unsigned nb;                            /* number of bit length codes */
-                       unsigned nl;                            /* number of literal/length codes */
-                       unsigned nd;                            /* number of distance codes */
-
-                       unsigned ll[286 + 30];          /* literal/length and distance code lengths */
+                       unsigned l;     /* last length */
+                       unsigned m;     /* mask for bit lengths table */
+                       unsigned n;     /* number of lengths to get */
+                       huft_t *tl;     /* literal/length code table */
+                       huft_t *td;     /* distance code table */
+                       int bl; /* lookup bits for tl */
+                       int bd; /* lookup bits for td */
+                       unsigned nb;    /* number of bit length codes */
+                       unsigned nl;    /* number of literal/length codes */
+                       unsigned nd;    /* number of distance codes */
+
+                       unsigned ll[286 + 30];  /* literal/length and distance code lengths */
                        unsigned long b_dynamic;        /* bit buffer */
-                       unsigned k_dynamic;             /* number of bits in bit buffer */
+                       unsigned k_dynamic;     /* number of bits in bit buffer */
 
                        /* make local bit buffer */
                        b_dynamic = bb;
@@ -689,24 +713,30 @@ static int inflate_block(int *e)
 
                        /* read in table lengths */
                        while (k_dynamic < 5) {
-                               b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
+                               b_dynamic |=
+                                   ((unsigned long)fgetc(in_file)) <<
+                                   k_dynamic;
                                k_dynamic += 8;
                        }
-                       nl = 257 + ((unsigned) b_dynamic & 0x1f);       /* number of literal/length codes */
+                       nl = 257 + ((unsigned)b_dynamic & 0x1f);        /* number of literal/length codes */
                        b_dynamic >>= 5;
                        k_dynamic -= 5;
                        while (k_dynamic < 5) {
-                               b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
+                               b_dynamic |=
+                                   ((unsigned long)fgetc(in_file)) <<
+                                   k_dynamic;
                                k_dynamic += 8;
                        }
-                       nd = 1 + ((unsigned) b_dynamic & 0x1f); /* number of distance codes */
+                       nd = 1 + ((unsigned)b_dynamic & 0x1f);  /* number of distance codes */
                        b_dynamic >>= 5;
                        k_dynamic -= 5;
                        while (k_dynamic < 4) {
-                               b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
+                               b_dynamic |=
+                                   ((unsigned long)fgetc(in_file)) <<
+                                   k_dynamic;
                                k_dynamic += 8;
                        }
-                       nb = 4 + ((unsigned) b_dynamic & 0xf);  /* number of bit length codes */
+                       nb = 4 + ((unsigned)b_dynamic & 0xf);   /* number of bit length codes */
                        b_dynamic >>= 4;
                        k_dynamic -= 4;
                        if (nl > 286 || nd > 30) {
@@ -716,10 +746,12 @@ static int inflate_block(int *e)
                        /* read in bit-length-code lengths */
                        for (j = 0; j < nb; j++) {
                                while (k_dynamic < 3) {
-                                       b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
+                                       b_dynamic |=
+                                           ((unsigned long)fgetc(in_file)) <<
+                                           k_dynamic;
                                        k_dynamic += 8;
                                }
-                               ll[border[j]] = (unsigned) b_dynamic & 7;
+                               ll[border[j]] = (unsigned)b_dynamic & 7;
                                b_dynamic >>= 3;
                                k_dynamic -= 3;
                        }
@@ -729,38 +761,44 @@ static int inflate_block(int *e)
 
                        /* build decoding table for trees--single level, 7 bit lookup */
                        bl = 7;
-                       if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0) {
+                       if ((i =
+                            huft_build(ll, 19, 19, NULL, NULL, &tl,
+                                       &bl)) != 0) {
                                if (i == 1) {
                                        huft_free(tl);
                                }
-                               return i;                       /* incomplete code set */
+                               return i;       /* incomplete code set */
                        }
 
                        /* read in literal and distance code lengths */
                        n = nl + nd;
                        m = mask_bits[bl];
                        i = l = 0;
-                       while ((unsigned) i < n) {
-                               while (k_dynamic < (unsigned) bl) {
-                                       b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
+                       while ((unsigned)i < n) {
+                               while (k_dynamic < (unsigned)bl) {
+                                       b_dynamic |=
+                                           ((unsigned long)fgetc(in_file)) <<
+                                           k_dynamic;
                                        k_dynamic += 8;
                                }
-                               j = (td = tl + ((unsigned) b_dynamic & m))->b;
+                               j = (td = tl + ((unsigned)b_dynamic & m))->b;
                                b_dynamic >>= j;
                                k_dynamic -= j;
                                j = td->v.n;
-                               if (j < 16) {                   /* length of code in bits (0..15) */
+                               if (j < 16) {   /* length of code in bits (0..15) */
                                        ll[i++] = l = j;        /* save last length in l */
-                               }
-                               else if (j == 16) {             /* repeat last length 3 to 6 times */
+                               } else if (j == 16) {   /* repeat last length 3 to 6 times */
                                        while (k_dynamic < 2) {
-                                               b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
+                                               b_dynamic |=
+                                                   ((unsigned long)
+                                                    fgetc(in_file)) <<
+                                                   k_dynamic;
                                                k_dynamic += 8;
                                        }
-                                       j = 3 + ((unsigned) b_dynamic & 3);
+                                       j = 3 + ((unsigned)b_dynamic & 3);
                                        b_dynamic >>= 2;
                                        k_dynamic -= 2;
-                                       if ((unsigned) i + j > n) {
+                                       if ((unsigned)i + j > n) {
                                                return 1;
                                        }
                                        while (j--) {
@@ -768,28 +806,34 @@ static int inflate_block(int *e)
                                        }
                                } else if (j == 17) {   /* 3 to 10 zero length codes */
                                        while (k_dynamic < 3) {
-                                               b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
+                                               b_dynamic |=
+                                                   ((unsigned long)
+                                                    fgetc(in_file)) <<
+                                                   k_dynamic;
                                                k_dynamic += 8;
                                        }
-                                       j = 3 + ((unsigned) b_dynamic & 7);
+                                       j = 3 + ((unsigned)b_dynamic & 7);
                                        b_dynamic >>= 3;
                                        k_dynamic -= 3;
-                                       if ((unsigned) i + j > n) {
+                                       if ((unsigned)i + j > n) {
                                                return 1;
                                        }
                                        while (j--) {
                                                ll[i++] = 0;
                                        }
                                        l = 0;
-                               } else {                /* j == 18: 11 to 138 zero length codes */
+                               } else {        /* j == 18: 11 to 138 zero length codes */
                                        while (k_dynamic < 7) {
-                                               b_dynamic |= ((unsigned long)fgetc(in_file)) << k_dynamic;
+                                               b_dynamic |=
+                                                   ((unsigned long)
+                                                    fgetc(in_file)) <<
+                                                   k_dynamic;
                                                k_dynamic += 8;
                                        }
-                                       j = 11 + ((unsigned) b_dynamic & 0x7f);
+                                       j = 11 + ((unsigned)b_dynamic & 0x7f);
                                        b_dynamic >>= 7;
                                        k_dynamic -= 7;
-                                       if ((unsigned) i + j > n) {
+                                       if ((unsigned)i + j > n) {
                                                return 1;
                                        }
                                        while (j--) {
@@ -808,21 +852,25 @@ static int inflate_block(int *e)
 
                        /* build the decoding tables for literal/length and distance codes */
                        bl = lbits;
-                       if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) {
+                       if ((i =
+                            huft_build(ll, nl, 257, cplens, cplext, &tl,
+                                       &bl)) != 0) {
                                if (i == 1) {
                                        error_msg("Incomplete literal tree");
                                        huft_free(tl);
                                }
-                               return i;                       /* incomplete code set */
+                               return i;       /* incomplete code set */
                        }
                        bd = dbits;
-                       if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) {
+                       if ((i =
+                            huft_build(ll + nl, nd, 0, cpdist, cpdext, &td,
+                                       &bd)) != 0) {
                                if (i == 1) {
                                        error_msg("incomplete distance tree");
                                        huft_free(td);
                                }
                                huft_free(tl);
-                               return i;                       /* incomplete code set */
+                               return i;       /* incomplete code set */
                        }
 
                        /* decompress until an end-of-block code */
@@ -850,8 +898,8 @@ static int inflate_block(int *e)
  */
 static int inflate()
 {
-       int e;                          /* last block flag */
-       int r;                          /* result code */
+       int e;                  /* last block flag */
+       int r;                  /* result code */
        unsigned h = 0;         /* maximum struct huft's malloc'ed */
 
        /* initialize window, bit buffer */
@@ -892,40 +940,41 @@ static int inflate()
  *   The magic header has already been checked. The output buffer is cleared.
  * in, out: input and output file descriptors
  */
-extern int unzip(FILE *l_in_file, FILE *l_out_file)
+extern int unzip(FILE * l_in_file, FILE * l_out_file)
 {
        const int extra_field = 0x04;   /* bit 2 set: extra field present */
        const int orig_name = 0x08;     /* bit 3 set: original file name present */
        const int comment = 0x10;       /* bit 4 set: file comment present */
        unsigned char buf[8];   /* extended local header */
        unsigned char flags;    /* compression flags */
-       char magic[2];                  /* magic header */
+       char magic[2];          /* magic header */
        int method;
        typedef void (*sig_type) (int);
-       int exit_code=0;        /* program exit code */
+       int exit_code = 0;      /* program exit code */
        int i;
 
        in_file = l_in_file;
        out_file = l_out_file;
 
        if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
-               (void) signal(SIGINT, (sig_type) abort_gzip);
+               (void)signal(SIGINT, (sig_type) abort_gzip);
        }
 #ifdef SIGTERM
-//     if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
-//             (void) signal(SIGTERM, (sig_type) abort_gzip);
-//     }
+//      if (signal(SIGTERM, SIG_IGN) != SIG_IGN) {
+//              (void) signal(SIGTERM, (sig_type) abort_gzip);
+//      }
 #endif
 #ifdef SIGHUP
        if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
-               (void) signal(SIGHUP, (sig_type) abort_gzip);
+               (void)signal(SIGHUP, (sig_type) abort_gzip);
        }
 #endif
 
        signal(SIGPIPE, SIG_IGN);
 
        /* Allocate all global buffers (for DYN_ALLOC option) */
-       window = xmalloc((size_t)(((2L*WSIZE)+1L)*sizeof(unsigned char)));
+       window =
+           xmalloc((size_t) (((2L * WSIZE) + 1L) * sizeof(unsigned char)));
        outcnt = 0;
        bytes_out = 0L;
 
@@ -938,14 +987,15 @@ extern int unzip(FILE *l_in_file, FILE *l_out_file)
                return EXIT_FAILURE;
        }
 
-       method = (int) fgetc(in_file);
+       method = (int)fgetc(in_file);
        if (method != 8) {
-               error_msg("unknown method %d -- get newer version of gzip", method);
+               error_msg("unknown method %d -- get newer version of gzip",
+                         method);
                exit_code = 1;
                return -1;
        }
 
-       flags = (unsigned char) fgetc(in_file);
+       flags = (unsigned char)fgetc(in_file);
 
        /* Ignore time stamp(4), extra flags(1), OS type(1) */
        for (i = 0; i < 6; i++)
@@ -962,16 +1012,16 @@ extern int unzip(FILE *l_in_file, FILE *l_out_file)
 
        /* Discard original name if any */
        if ((flags & orig_name) != 0) {
-               while (fgetc(in_file) != 0)   /* null */
+               while (fgetc(in_file) != 0) ;   /* null */
        }
 
        /* Discard file comment if any */
        if ((flags & comment) != 0) {
-               while (fgetc(in_file) != 0)   /* null */
+               while (fgetc(in_file) != 0) ;   /* null */
        }
 
        if (method < 0) {
-               return(exit_code);
+               return (exit_code);
        }
 
        make_crc_table();
@@ -1001,12 +1051,17 @@ extern int unzip(FILE *l_in_file, FILE *l_out_file)
        fread(buf, 1, 8, in_file);
 
        /* Validate decompression - crc */
-       if (!exit_code && (unsigned int)((buf[0] | (buf[1] << 8)) |((buf[2] | (buf[3] << 8)) << 16)) != (crc ^ 0xffffffffL)) {
+       if (!exit_code
+           && (unsigned int)((buf[0] | (buf[1] << 8)) |
+                             ((buf[2] | (buf[3] << 8)) << 16)) !=
+           (crc ^ 0xffffffffL)) {
                error_msg("invalid compressed data--crc error");
                exit_code = 1;
        }
        /* Validate decompression - size */
-       if (!exit_code && ((buf[4] | (buf[5] << 8)) |((buf[6] | (buf[7] << 8)) << 16)) != (unsigned long) bytes_out) {
+       if (!exit_code
+           && ((buf[4] | (buf[5] << 8)) | ((buf[6] | (buf[7] << 8)) << 16)) !=
+           (unsigned long)bytes_out) {
                error_msg("invalid compressed data--length error");
                exit_code = 1;
        }
index f58ec90..76f220b 100644 (file)
@@ -33,7 +33,6 @@ FILE *wfopen(const char *path, const char *mode)
        return fp;
 }
 
-
 /* END CODE */
 /*
 Local Variables:
index f577315..2469b6a 100644 (file)
@@ -25,7 +25,6 @@
 #include <unistd.h>
 #include "libbb.h"
 
-
 extern void *xmalloc(size_t size)
 {
        void *ptr = malloc(size);
@@ -50,13 +49,14 @@ extern void *xcalloc(size_t nmemb, size_t size)
        return ptr;
 }
 
-extern char * xstrdup (const char *s) {
+extern char *xstrdup(const char *s)
+{
        char *t;
 
        if (s == NULL)
                return NULL;
 
-       t = strdup (s);
+       t = strdup(s);
 
        if (t == NULL)
                perror_msg_and_die("strdup");
@@ -64,7 +64,8 @@ extern char * xstrdup (const char *s) {
        return t;
 }
 
-extern char * xstrndup (const char *s, int n) {
+extern char *xstrndup(const char *s, int n)
+{
        char *t;
 
        if (s == NULL)
@@ -72,7 +73,7 @@ extern char * xstrndup (const char *s, int n) {
 
        t = xmalloc(++n);
 
-       return safe_strncpy(t,s,n);
+       return safe_strncpy(t, s, n);
 }
 
 FILE *xfopen(const char *path, const char *mode)
index 7d77a3b..596a763 100644 (file)
 
 extern char *xreadlink(const char *path)
 {
-       static const int GROWBY = 80; /* how large we will grow strings by */
+       static const int GROWBY = 80;   /* how large we will grow strings by */
 
        char *buf = NULL;
        int bufsize = 0, readsize = 0;
 
        do {
                buf = xrealloc(buf, bufsize += GROWBY);
-               readsize = readlink(path, buf, bufsize); /* 1st try */
+               readsize = readlink(path, buf, bufsize);        /* 1st try */
                if (readsize == -1) {
-                   perror_msg("%s", path);
-                   return NULL;
+                       perror_msg("%s", path);
+                       return NULL;
                }
        }
        while (bufsize < readsize + 1);
@@ -34,4 +34,3 @@ extern char *xreadlink(const char *path)
 
        return buf;
 }
-
index 69ac1d1..2c91965 100644 (file)
@@ -15,7 +15,6 @@
    General Public License for more details.
 */
 
-
 #include "active_list.h"
 #include <stdio.h>
 #include <string.h>
 
 #include "libbb/libbb.h"
 
-void active_list_init(struct active_list *ptr) {
-    INIT_LIST_HEAD(&ptr->node);
-    INIT_LIST_HEAD(&ptr->depend);
-    ptr->depended = NULL;
+void active_list_init(struct active_list *ptr)
+{
+       INIT_LIST_HEAD(&ptr->node);
+       INIT_LIST_HEAD(&ptr->depend);
+       ptr->depended = NULL;
 }
 
 /**
  */
-struct active_list * active_list_next(struct active_list *head, struct active_list *ptr) {
-    struct active_list *next=NULL;
-    if ( !head ) {
-        opkg_msg(ERROR, "Internal error: head=%p, ptr=%p\n", head, ptr);
-        return NULL;
-    }
-    if ( !ptr )
-        ptr = head;
-    next = list_entry(ptr->node.next, struct active_list, node);
-    if ( next == head ) {
-        return NULL;
-    }
-    if ( ptr->depended && &ptr->depended->depend == ptr->node.next ) {
-        return ptr->depended;
-    }
-    while ( next->depend.next != &next->depend ) {
-        next = list_entry(next->depend.next, struct active_list, node);
-    }
-    return next;
+struct active_list *active_list_next(struct active_list *head,
+                                    struct active_list *ptr)
+{
+       struct active_list *next = NULL;
+       if (!head) {
+               opkg_msg(ERROR, "Internal error: head=%p, ptr=%p\n", head, ptr);
+               return NULL;
+       }
+       if (!ptr)
+               ptr = head;
+       next = list_entry(ptr->node.next, struct active_list, node);
+       if (next == head) {
+               return NULL;
+       }
+       if (ptr->depended && &ptr->depended->depend == ptr->node.next) {
+               return ptr->depended;
+       }
+       while (next->depend.next != &next->depend) {
+               next = list_entry(next->depend.next, struct active_list, node);
+       }
+       return next;
 }
 
-
-struct active_list * active_list_prev(struct active_list *head, struct active_list *ptr) {
-    struct active_list *prev=NULL;
-    if ( !head ) {
-        opkg_msg(ERROR, "Internal error: head=%p, ptr=%p\n", head, ptr);
-        return NULL;
-    }
-    if ( !ptr )
-        ptr = head;
-    if ( ptr->depend.prev != &ptr->depend ) {
-        prev = list_entry(ptr->depend.prev, struct active_list, node);
-        return prev;
-    }
-    if ( ptr->depended  && ptr->depended != head && &ptr->depended->depend == ptr->node.prev ) {
-        prev = list_entry(ptr->depended->node.prev, struct active_list, node);
-    } else
-        prev = list_entry(ptr->node.prev, struct active_list, node);
-    if ( prev == head )
-        return NULL;
-    return prev;
+struct active_list *active_list_prev(struct active_list *head,
+                                    struct active_list *ptr)
+{
+       struct active_list *prev = NULL;
+       if (!head) {
+               opkg_msg(ERROR, "Internal error: head=%p, ptr=%p\n", head, ptr);
+               return NULL;
+       }
+       if (!ptr)
+               ptr = head;
+       if (ptr->depend.prev != &ptr->depend) {
+               prev = list_entry(ptr->depend.prev, struct active_list, node);
+               return prev;
+       }
+       if (ptr->depended && ptr->depended != head
+           && &ptr->depended->depend == ptr->node.prev) {
+               prev =
+                   list_entry(ptr->depended->node.prev, struct active_list,
+                              node);
+       } else
+               prev = list_entry(ptr->node.prev, struct active_list, node);
+       if (prev == head)
+               return NULL;
+       return prev;
 }
 
-
-struct active_list *active_list_move_node(struct active_list *old_head, struct active_list *new_head, struct active_list *node) {
-    struct active_list *prev;
-    if (!old_head || !new_head || !node)
-        return NULL;
-    if (old_head == new_head)
-        return node;
-    prev = active_list_prev(old_head, node);
-    active_list_add(new_head, node);
-    return prev;
+struct active_list *active_list_move_node(struct active_list *old_head,
+                                         struct active_list *new_head,
+                                         struct active_list *node)
+{
+       struct active_list *prev;
+       if (!old_head || !new_head || !node)
+               return NULL;
+       if (old_head == new_head)
+               return node;
+       prev = active_list_prev(old_head, node);
+       active_list_add(new_head, node);
+       return prev;
 }
 
-static void list_head_clear (struct list_head *head) {
-    struct active_list *next;
-    struct list_head *n, *ptr;
-    if (!head)
-        return;
-    list_for_each_safe(ptr, n , head) {
-        next = list_entry(ptr, struct active_list, node);
-        if (next->depend.next != &next->depend) {
-            list_head_clear(&next->depend);
-        }
-        active_list_init(next);
-    }
+static void list_head_clear(struct list_head *head)
+{
+       struct active_list *next;
+       struct list_head *n, *ptr;
+       if (!head)
+               return;
+       list_for_each_safe(ptr, n, head) {
+               next = list_entry(ptr, struct active_list, node);
+               if (next->depend.next != &next->depend) {
+                       list_head_clear(&next->depend);
+               }
+               active_list_init(next);
+       }
 }
-void active_list_clear(struct active_list *head) {
-    list_head_clear(&head->node);
-    if (head->depend.next != &head->depend) {
-        list_head_clear(&head->depend);
-    }
-    active_list_init(head);
+
+void active_list_clear(struct active_list *head)
+{
+       list_head_clear(&head->node);
+       if (head->depend.next != &head->depend) {
+               list_head_clear(&head->depend);
+       }
+       active_list_init(head);
 }
 
-void active_list_add_depend(struct active_list *node, struct active_list *depend) {
-    list_del_init(&depend->node);
-    list_add_tail(&depend->node, &node->depend);
-    depend->depended  = node;
+void active_list_add_depend(struct active_list *node,
+                           struct active_list *depend)
+{
+       list_del_init(&depend->node);
+       list_add_tail(&depend->node, &node->depend);
+       depend->depended = node;
 }
 
-void active_list_add(struct active_list *head, struct active_list *node) {
-    list_del_init(&node->node);
-    list_add_tail(&node->node, &head->node);
-    node->depended  = head;
+void active_list_add(struct active_list *head, struct active_list *node)
+{
+       list_del_init(&node->node);
+       list_add_tail(&node->node, &head->node);
+       node->depended = head;
 }
 
-struct active_list * active_list_head_new(void) {
-    struct active_list * head = xcalloc(1, sizeof(struct active_list));
-    active_list_init(head);
-    return head;
+struct active_list *active_list_head_new(void)
+{
+       struct active_list *head = xcalloc(1, sizeof(struct active_list));
+       active_list_init(head);
+       return head;
 }
 
-void active_list_head_delete(struct active_list *head) {
-    active_list_clear(head);
-    free(head);
+void active_list_head_delete(struct active_list *head)
+{
+       active_list_clear(head);
+       free(head);
 }
 
 /*
@@ -135,31 +151,37 @@ void active_list_head_delete(struct active_list *head) {
  *  Note. the list should not be large, or it will be very inefficient.
  *
  */
-struct active_list * active_list_sort(struct active_list *head, int (*compare)(const void *, const void *)) {
-    struct active_list tmphead;
-    struct active_list *node, *ptr;
-    if ( !head )
-        return NULL;
-    active_list_init(&tmphead);
-    for (node = active_list_next(head, NULL); node; node = active_list_next(head, NULL)) {
-        if (tmphead.node.next == &tmphead.node) {
-            active_list_move_node(head, &tmphead, node);
-        } else {
-            for (ptr = active_list_next(&tmphead, NULL); ptr; ptr=active_list_next(&tmphead, ptr)) {
-                if (compare(ptr, node) <= 0) {
-                    break;
-                }
-            }
-            if (!ptr) {
-                active_list_move_node(head, &tmphead, node);
-            } else {
-                active_list_move_node(head, ptr, node);
-            }
-        }
-        node->depended = &tmphead;
-    }
-    for (ptr = active_list_prev(&tmphead, NULL); ptr; ptr=active_list_prev(&tmphead, NULL)) {
-        active_list_move_node(&tmphead, head, ptr);
-    }
-    return head;
+struct active_list *active_list_sort(struct active_list *head,
+                                    int (*compare) (const void *,
+                                                    const void *))
+{
+       struct active_list tmphead;
+       struct active_list *node, *ptr;
+       if (!head)
+               return NULL;
+       active_list_init(&tmphead);
+       for (node = active_list_next(head, NULL); node;
+            node = active_list_next(head, NULL)) {
+               if (tmphead.node.next == &tmphead.node) {
+                       active_list_move_node(head, &tmphead, node);
+               } else {
+                       for (ptr = active_list_next(&tmphead, NULL); ptr;
+                            ptr = active_list_next(&tmphead, ptr)) {
+                               if (compare(ptr, node) <= 0) {
+                                       break;
+                               }
+                       }
+                       if (!ptr) {
+                               active_list_move_node(head, &tmphead, node);
+                       } else {
+                               active_list_move_node(head, ptr, node);
+                       }
+               }
+               node->depended = &tmphead;
+       }
+       for (ptr = active_list_prev(&tmphead, NULL); ptr;
+            ptr = active_list_prev(&tmphead, NULL)) {
+               active_list_move_node(&tmphead, head, ptr);
+       }
+       return head;
 }
index ecb79a6..396e051 100644 (file)
 #include "list.h"
 
 struct active_list {
-    struct list_head node;
-    struct list_head depend;
-    struct active_list *depended;
+       struct list_head node;
+       struct list_head depend;
+       struct active_list *depended;
 };
 
-
-struct active_list * active_list_head_new(void);
+struct active_list *active_list_head_new(void);
 void active_list_head_delete(struct active_list *);
 void active_list_init(struct active_list *ptr);
 void active_list_clear(struct active_list *head);
-void active_list_add_depend(struct active_list *node, struct active_list *depend);
+void active_list_add_depend(struct active_list *node,
+                           struct active_list *depend);
 void active_list_add(struct active_list *head, struct active_list *node);
-struct active_list *active_list_move_node(struct active_list *old_head, struct active_list *new_head, struct active_list *node);
+struct active_list *active_list_move_node(struct active_list *old_head,
+                                         struct active_list *new_head,
+                                         struct active_list *node);
 
-struct active_list * active_list_sort(struct active_list *head, int (*compare_fcn_t)(const void *, const void *));
+struct active_list *active_list_sort(struct active_list *head,
+                                    int (*compare_fcn_t) (const void *,
+                                                          const void *));
 
-struct active_list * active_list_next(struct active_list *head, struct active_list *ptr);
+struct active_list *active_list_next(struct active_list *head,
+                                    struct active_list *ptr);
 
-struct active_list * active_list_prev(struct active_list *head, struct active_list *ptr);
+struct active_list *active_list_prev(struct active_list *head,
+                                    struct active_list *ptr);
 
 #endif
index c45a6b9..434edf6 100644 (file)
 #include "sprintf_alloc.h"
 #include "opkg_conf.h"
 
-int conffile_init(conffile_t *conffile, const char *file_name, const char *md5sum)
+int conffile_init(conffile_t * conffile, const char *file_name,
+                 const char *md5sum)
 {
-    return nv_pair_init(conffile, file_name, md5sum);
+       return nv_pair_init(conffile, file_name, md5sum);
 }
 
-void conffile_deinit(conffile_t *conffile)
+void conffile_deinit(conffile_t * conffile)
 {
-    nv_pair_deinit(conffile);
+       nv_pair_deinit(conffile);
 }
 
-int conffile_has_been_modified(conffile_t *conffile)
+int conffile_has_been_modified(conffile_t * conffile)
 {
-    char *chksum;
-    char *filename = conffile->name;
-    char *root_filename;
-    int ret = 1;
+       char *chksum;
+       char *filename = conffile->name;
+       char *root_filename;
+       int ret = 1;
 
-    if (conffile->value == NULL) {
-        opkg_msg(NOTICE, "Conffile %s has no md5sum.\n", conffile->name);
-        return 1;
-    }
+       if (conffile->value == NULL) {
+               opkg_msg(NOTICE, "Conffile %s has no md5sum.\n",
+                        conffile->name);
+               return 1;
+       }
 
-    root_filename = root_filename_alloc(filename);
+       root_filename = root_filename_alloc(filename);
 
 #ifdef HAVE_MD5
-    if(conffile->value && strlen(conffile->value) > 33) {
-        chksum = file_sha256sum_alloc(root_filename);
-    } else {
-        chksum = file_md5sum_alloc(root_filename);
-    }
+       if (conffile->value && strlen(conffile->value) > 33) {
+               chksum = file_sha256sum_alloc(root_filename);
+       } else {
+               chksum = file_md5sum_alloc(root_filename);
+       }
 #else
-    chksum = file_sha256sum_alloc(root_filename);
+       chksum = file_sha256sum_alloc(root_filename);
 #endif
-    if (chksum && (ret = strcmp(chksum, conffile->value))) {
-        opkg_msg(INFO, "Conffile %s:\n\told chk=%s\n\tnew chk=%s\n",
-               conffile->name, chksum, conffile->value);
-    }
+       if (chksum && (ret = strcmp(chksum, conffile->value))) {
+               opkg_msg(INFO, "Conffile %s:\n\told chk=%s\n\tnew chk=%s\n",
+                        conffile->name, chksum, conffile->value);
+       }
 
-    free(root_filename);
-    if (chksum)
-        free(chksum);
+       free(root_filename);
+       if (chksum)
+               free(chksum);
 
-    return ret;
+       return ret;
 }
index a188c6d..091bf5e 100644 (file)
@@ -21,9 +21,9 @@
 #include "nv_pair.h"
 typedef struct nv_pair conffile_t;
 
-int conffile_init(conffile_t *conffile, const char *file_name, const char *md5sum);
-void conffile_deinit(conffile_t *conffile);
-int conffile_has_been_modified(conffile_t *conffile);
+int conffile_init(conffile_t * conffile, const char *file_name,
+                 const char *md5sum);
+void conffile_deinit(conffile_t * conffile);
+int conffile_has_been_modified(conffile_t * conffile);
 
 #endif
-
index 1db7790..25f5b9d 100644 (file)
 
 #include "conffile_list.h"
 
-void conffile_list_init(conffile_list_t *list)
+void conffile_list_init(conffile_list_t * list)
 {
-    nv_pair_list_init(list);
+       nv_pair_list_init(list);
 }
 
-void conffile_list_deinit(conffile_list_t *list)
+void conffile_list_deinit(conffile_list_t * list)
 {
-    nv_pair_list_deinit(list);
+       nv_pair_list_deinit(list);
 }
 
-conffile_t *conffile_list_append(conffile_list_t *list, const char *file_name,
-                        const char *md5sum)
+conffile_t *conffile_list_append(conffile_list_t * list, const char *file_name,
+                                const char *md5sum)
 {
-    return nv_pair_list_append(list, file_name, md5sum);
+       return nv_pair_list_append(list, file_name, md5sum);
 }
 
-void conffile_list_push(conffile_list_t *list, conffile_t *data)
+void conffile_list_push(conffile_list_t * list, conffile_t * data)
 {
-    nv_pair_list_push(list, data);
+       nv_pair_list_push(list, data);
 }
 
-conffile_list_elt_t *conffile_list_pop(conffile_list_t *list)
+conffile_list_elt_t *conffile_list_pop(conffile_list_t * list)
 {
-    conffile_list_elt_t *pos = nv_pair_list_pop(list);
-    return pos;
+       conffile_list_elt_t *pos = nv_pair_list_pop(list);
+       return pos;
 }
-
index 942f68e..c689d8f 100644 (file)
@@ -25,13 +25,12 @@ typedef nv_pair_list_t conffile_list_t;
 
 #include "conffile.h"
 
-void conffile_list_init(conffile_list_t *list);
-void conffile_list_deinit(conffile_list_t *list);
+void conffile_list_init(conffile_list_t * list);
+void conffile_list_deinit(conffile_list_t * list);
 
-conffile_t *conffile_list_append(conffile_list_t *list, const char *name,
-                              const char *root_dir);
-void conffile_list_push(conffile_list_t *list, conffile_t *data);
-conffile_list_elt_t *conffile_list_pop(conffile_list_t *list);
+conffile_t *conffile_list_append(conffile_list_t * list, const char *name,
+                                const char *root_dir);
+void conffile_list_push(conffile_list_t * list, conffile_t * data);
+conffile_list_elt_t *conffile_list_pop(conffile_list_t * list);
 
 #endif
-
index c54903c..4f949ac 100644 (file)
@@ -35,8 +35,7 @@
 #include "sha256.h"
 #endif
 
-int
-file_exists(const char *file_name)
+int file_exists(const char *file_name)
 {
        struct stat st;
 
@@ -46,8 +45,7 @@ file_exists(const char *file_name)
        return 1;
 }
 
-int
-file_is_dir(const char *file_name)
+int file_is_dir(const char *file_name)
 {
        struct stat st;
 
@@ -64,8 +62,7 @@ file_is_dir(const char *file_name)
 
    Return value is NULL if the file is at EOF when called.
 */
-char *
-file_read_line_alloc(FILE *fp)
+char *file_read_line_alloc(FILE * fp)
 {
        char buf[BUFSIZ];
        unsigned int buf_len;
@@ -84,7 +81,7 @@ file_read_line_alloc(FILE *fp)
                }
                if (line) {
                        line_size += buf_len;
-                       line = xrealloc(line, line_size+1);
+                       line = xrealloc(line, line_size + 1);
                        strncat(line, buf, line_size);
                } else {
                        line_size = buf_len + 1;
@@ -97,8 +94,7 @@ file_read_line_alloc(FILE *fp)
        return line;
 }
 
-int
-file_move(const char *src, const char *dest)
+int file_move(const char *src, const char *dest)
 {
        int err;
 
@@ -111,28 +107,25 @@ file_move(const char *src, const char *dest)
                                unlink(src);
                } else {
                        opkg_perror(ERROR, "Failed to rename %s to %s",
-                               src, dest);
+                                   src, dest);
                }
        }
 
        return err;
 }
 
-int
-file_copy(const char *src, const char *dest)
+int file_copy(const char *src, const char *dest)
 {
        int err;
 
        err = copy_file(src, dest, FILEUTILS_FORCE | FILEUTILS_PRESERVE_STATUS);
        if (err)
-               opkg_msg(ERROR, "Failed to copy file %s to %s.\n",
-                               src, dest);
+               opkg_msg(ERROR, "Failed to copy file %s to %s.\n", src, dest);
 
        return err;
 }
 
-int
-file_mkdir_hier(const char *path, long mode)
+int file_mkdir_hier(const char *path, long mode)
 {
        return make_directory(path, mode, FILEUTILS_RECUR);
 }
@@ -140,103 +133,102 @@ file_mkdir_hier(const char *path, long mode)
 #ifdef HAVE_MD5
 char *file_md5sum_alloc(const char *file_name)
 {
-    static const int md5sum_bin_len = 16;
-    static const int md5sum_hex_len = 32;
-
-    static const unsigned char bin2hex[16] = {
-       '0', '1', '2', '3',
-       '4', '5', '6', '7',
-       '8', '9', 'a', 'b',
-       'c', 'd', 'e', 'f'
-    };
-
-    int i, err;
-    FILE *file;
-    char *md5sum_hex;
-    unsigned char md5sum_bin[md5sum_bin_len];
-
-    md5sum_hex = xcalloc(1, md5sum_hex_len + 1);
-
-    file = fopen(file_name, "r");
-    if (file == NULL) {
-       opkg_perror(ERROR, "Failed to open file %s", file_name);
-       free(md5sum_hex);
-       return NULL;
-    }
-
-    err = md5_stream(file, md5sum_bin);
-    if (err) {
-       opkg_msg(ERROR, "Could't compute md5sum for %s.\n", file_name);
-       fclose(file);
-       free(md5sum_hex);
-       return NULL;
-    }
+       static const int md5sum_bin_len = 16;
+       static const int md5sum_hex_len = 32;
+
+       static const unsigned char bin2hex[16] = {
+               '0', '1', '2', '3',
+               '4', '5', '6', '7',
+               '8', '9', 'a', 'b',
+               'c', 'd', 'e', 'f'
+       };
+
+       int i, err;
+       FILE *file;
+       char *md5sum_hex;
+       unsigned char md5sum_bin[md5sum_bin_len];
+
+       md5sum_hex = xcalloc(1, md5sum_hex_len + 1);
+
+       file = fopen(file_name, "r");
+       if (file == NULL) {
+               opkg_perror(ERROR, "Failed to open file %s", file_name);
+               free(md5sum_hex);
+               return NULL;
+       }
 
-    fclose(file);
+       err = md5_stream(file, md5sum_bin);
+       if (err) {
+               opkg_msg(ERROR, "Could't compute md5sum for %s.\n", file_name);
+               fclose(file);
+               free(md5sum_hex);
+               return NULL;
+       }
 
-    for (i=0; i < md5sum_bin_len; i++) {
-       md5sum_hex[i*2] = bin2hex[md5sum_bin[i] >> 4];
-       md5sum_hex[i*2+1] = bin2hex[md5sum_bin[i] & 0xf];
-    }
+       fclose(file);
 
-    md5sum_hex[md5sum_hex_len] = '\0';
+       for (i = 0; i < md5sum_bin_len; i++) {
+               md5sum_hex[i * 2] = bin2hex[md5sum_bin[i] >> 4];
+               md5sum_hex[i * 2 + 1] = bin2hex[md5sum_bin[i] & 0xf];
+       }
+
+       md5sum_hex[md5sum_hex_len] = '\0';
 
-    return md5sum_hex;
+       return md5sum_hex;
 }
 #endif
 
 #ifdef HAVE_SHA256
 char *file_sha256sum_alloc(const char *file_name)
 {
-    static const int sha256sum_bin_len = 32;
-    static const int sha256sum_hex_len = 64;
-
-    static const unsigned char bin2hex[16] = {
-       '0', '1', '2', '3',
-       '4', '5', '6', '7',
-       '8', '9', 'a', 'b',
-       'c', 'd', 'e', 'f'
-    };
-
-    int i, err;
-    FILE *file;
-    char *sha256sum_hex;
-    unsigned char sha256sum_bin[sha256sum_bin_len];
-
-    sha256sum_hex = xcalloc(1, sha256sum_hex_len + 1);
-
-    file = fopen(file_name, "r");
-    if (file == NULL) {
-       opkg_perror(ERROR, "Failed to open file %s", file_name);
-       free(sha256sum_hex);
-       return NULL;
-    }
-
-    err = sha256_stream(file, sha256sum_bin);
-    if (err) {
-       opkg_msg(ERROR, "Could't compute sha256sum for %s.\n", file_name);
-       fclose(file);
-       free(sha256sum_hex);
-       return NULL;
-    }
+       static const int sha256sum_bin_len = 32;
+       static const int sha256sum_hex_len = 64;
+
+       static const unsigned char bin2hex[16] = {
+               '0', '1', '2', '3',
+               '4', '5', '6', '7',
+               '8', '9', 'a', 'b',
+               'c', 'd', 'e', 'f'
+       };
+
+       int i, err;
+       FILE *file;
+       char *sha256sum_hex;
+       unsigned char sha256sum_bin[sha256sum_bin_len];
+
+       sha256sum_hex = xcalloc(1, sha256sum_hex_len + 1);
+
+       file = fopen(file_name, "r");
+       if (file == NULL) {
+               opkg_perror(ERROR, "Failed to open file %s", file_name);
+               free(sha256sum_hex);
+               return NULL;
+       }
+
+       err = sha256_stream(file, sha256sum_bin);
+       if (err) {
+               opkg_msg(ERROR, "Could't compute sha256sum for %s.\n",
+                        file_name);
+               fclose(file);
+               free(sha256sum_hex);
+               return NULL;
+       }
 
-    fclose(file);
+       fclose(file);
 
-    for (i=0; i < sha256sum_bin_len; i++) {
-       sha256sum_hex[i*2] = bin2hex[sha256sum_bin[i] >> 4];
-       sha256sum_hex[i*2+1] = bin2hex[sha256sum_bin[i] & 0xf];
-    }
+       for (i = 0; i < sha256sum_bin_len; i++) {
+               sha256sum_hex[i * 2] = bin2hex[sha256sum_bin[i] >> 4];
+               sha256sum_hex[i * 2 + 1] = bin2hex[sha256sum_bin[i] & 0xf];
+       }
 
-    sha256sum_hex[sha256sum_hex_len] = '\0';
+       sha256sum_hex[sha256sum_hex_len] = '\0';
 
-    return sha256sum_hex;
+       return sha256sum_hex;
 }
 
 #endif
 
-
-int
-rm_r(const char *path)
+int rm_r(const char *path)
 {
        int ret = 0;
        DIR *dir;
@@ -264,7 +256,7 @@ rm_r(const char *path)
                if ((dent = readdir(dir)) == NULL) {
                        if (errno) {
                                opkg_perror(ERROR, "Failed to read dir %s",
-                                               path);
+                                           path);
                                ret = -1;
                        }
                        break;
@@ -284,7 +276,7 @@ rm_r(const char *path)
                        struct stat st;
                        if ((ret = lstat(dent->d_name, &st)) == -1) {
                                opkg_perror(ERROR, "Failed to lstat %s",
-                                               dent->d_name);
+                                           dent->d_name);
                                break;
                        }
                        if (S_ISDIR(st.st_mode)) {
@@ -305,7 +297,7 @@ rm_r(const char *path)
                opkg_perror(ERROR, "Failed to change to dir %s/..", path);
        }
 
-       if (rmdir(path) == -1 ) {
+       if (rmdir(path) == -1) {
                ret = -1;
                opkg_perror(ERROR, "Failed to remove dir %s", path);
        }
index cfad551..a7e2a38 100644 (file)
@@ -20,7 +20,7 @@
 
 int file_exists(const char *file_name);
 int file_is_dir(const char *file_name);
-char *file_read_line_alloc(FILE *file);
+char *file_read_line_alloc(FILE * file);
 int file_move(const char *src, const char *dest);
 int file_copy(const char *src, const char *dest);
 int file_mkdir_hier(const char *path, long mode);
index 37b53e9..791cf42 100644 (file)
 #include "opkg_message.h"
 #include "libbb/libbb.h"
 
-
-static unsigned long
-djb2_hash(const unsigned char *str)
+static unsigned long djb2_hash(const unsigned char *str)
 {
        unsigned long hash = 5381;
        int c;
        while ((c = *str++))
-               hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+               hash = ((hash << 5) + hash) + c;        /* hash * 33 + c */
        return hash;
 }
 
-static int
-hash_index(hash_table_t *hash, const char *key)
+static int hash_index(hash_table_t * hash, const char *key)
 {
        return djb2_hash((const unsigned char *)key) % hash->n_buckets;
 }
@@ -42,8 +39,7 @@ hash_index(hash_table_t *hash, const char *key)
 /*
  * this is an open table keyed by strings
  */
-void
-hash_table_init(const char *name, hash_table_t *hash, int len)
+void hash_table_init(const char *name, hash_table_t * hash, int len)
 {
        if (hash->entries != NULL) {
                opkg_msg(ERROR, "Internal error: non empty hash table.\n");
@@ -57,159 +53,155 @@ hash_table_init(const char *name, hash_table_t *hash, int len)
        hash->entries = xcalloc(hash->n_buckets, sizeof(hash_entry_t));
 }
 
-void
-hash_print_stats(hash_table_t *hash)
+void hash_print_stats(hash_table_t * hash)
 {
        printf("hash_table: %s, %d bytes\n"
-               "\tn_buckets=%d, n_elements=%d, n_collisions=%d\n"
-               "\tmax_bucket_len=%d, n_used_buckets=%d, ave_bucket_len=%.2f\n"
-               "\tn_hits=%d, n_misses=%d\n",
-               hash->name,
-               hash->n_buckets*(int)sizeof(hash_entry_t),
-               hash->n_buckets,
-               hash->n_elements,
-               hash->n_collisions,
-               hash->max_bucket_len,
-               hash->n_used_buckets,
-               (hash->n_used_buckets ?
-                       ((float)hash->n_elements)/hash->n_used_buckets : 0.0f),
-               hash->n_hits,
-               hash->n_misses);
+              "\tn_buckets=%d, n_elements=%d, n_collisions=%d\n"
+              "\tmax_bucket_len=%d, n_used_buckets=%d, ave_bucket_len=%.2f\n"
+              "\tn_hits=%d, n_misses=%d\n",
+              hash->name,
+              hash->n_buckets * (int)sizeof(hash_entry_t),
+              hash->n_buckets,
+              hash->n_elements,
+              hash->n_collisions,
+              hash->max_bucket_len,
+              hash->n_used_buckets,
+              (hash->n_used_buckets ?
+               ((float)hash->n_elements) / hash->n_used_buckets : 0.0f),
+              hash->n_hits, hash->n_misses);
 }
 
-void hash_table_deinit(hash_table_t *hash)
+void hash_table_deinit(hash_table_t * hash)
 {
-    int i;
-    if (!hash)
-        return;
-
-    /* free the reminaing entries */
-    for (i = 0; i < hash->n_buckets; i++) {
-       hash_entry_t *hash_entry = (hash->entries + i);
-       free (hash_entry->key);
-       /* skip the first entry as this is part of the array */
-       hash_entry = hash_entry->next;
-        while (hash_entry)
-       {
-         hash_entry_t *old = hash_entry;
-         hash_entry = hash_entry->next;
-         free (old->key);
-         free (old);
+       int i;
+       if (!hash)
+               return;
+
+       /* free the reminaing entries */
+       for (i = 0; i < hash->n_buckets; i++) {
+               hash_entry_t *hash_entry = (hash->entries + i);
+               free(hash_entry->key);
+               /* skip the first entry as this is part of the array */
+               hash_entry = hash_entry->next;
+               while (hash_entry) {
+                       hash_entry_t *old = hash_entry;
+                       hash_entry = hash_entry->next;
+                       free(old->key);
+                       free(old);
+               }
        }
-    }
 
-    free (hash->entries);
+       free(hash->entries);
 
-    hash->entries = NULL;
-    hash->n_buckets = 0;
+       hash->entries = NULL;
+       hash->n_buckets = 0;
 }
 
-void *hash_table_get(hash_table_t *hash, const char *key)
+void *hash_table_get(hash_table_t * hash, const char *key)
 {
-  int ndx= hash_index(hash, key);
-  hash_entry_t *hash_entry = hash->entries + ndx;
-  while (hash_entry)
-  {
-    if (hash_entry->key)
-    {
-      if (strcmp(key, hash_entry->key) == 0) {
-        hash->n_hits++;
-        return hash_entry->data;
-      }
-    }
-    hash_entry = hash_entry->next;
-  }
-  hash->n_misses++;
-  return NULL;
+       int ndx = hash_index(hash, key);
+       hash_entry_t *hash_entry = hash->entries + ndx;
+       while (hash_entry) {
+               if (hash_entry->key) {
+                       if (strcmp(key, hash_entry->key) == 0) {
+                               hash->n_hits++;
+                               return hash_entry->data;
+                       }
+               }
+               hash_entry = hash_entry->next;
+       }
+       hash->n_misses++;
+       return NULL;
 }
 
-int hash_table_insert(hash_table_t *hash, const char *key, void *value)
+int hash_table_insert(hash_table_t * hash, const char *key, void *value)
 {
-     int bucket_len = 0;
-     int ndx= hash_index(hash, key);
-     hash_entry_t *hash_entry = hash->entries + ndx;
-     if (hash_entry->key) {
-         if (strcmp(hash_entry->key, key) == 0) {
-              /* alread in table, update the value */
-              hash_entry->data = value;
-              return 0;
-         } else {
-              /*
-               * if this is a collision, we have to go to the end of the ll,
-               * then add a new entry
-               * before we can hook up the value
-               */
-              while (hash_entry->next) {
-                   hash_entry = hash_entry->next;
-                    if (strcmp(hash_entry->key, key) == 0) {
-                        hash_entry->data = value;
-                        return 0;
-                    }
-                   bucket_len++;
-               }
-              hash_entry->next = xcalloc(1, sizeof(hash_entry_t));
-              hash_entry = hash_entry->next;
-              hash_entry->next = NULL;
-
-              hash->n_collisions++;
-              if (++bucket_len > hash->max_bucket_len)
-                   hash->max_bucket_len = bucket_len;
-         }
-     } else
-         hash->n_used_buckets++;
-
-     hash->n_elements++;
-     hash_entry->key = xstrdup(key);
-     hash_entry->data = value;
-
-     return 0;
+       int bucket_len = 0;
+       int ndx = hash_index(hash, key);
+       hash_entry_t *hash_entry = hash->entries + ndx;
+       if (hash_entry->key) {
+               if (strcmp(hash_entry->key, key) == 0) {
+                       /* alread in table, update the value */
+                       hash_entry->data = value;
+                       return 0;
+               } else {
+                       /*
+                        * if this is a collision, we have to go to the end of the ll,
+                        * then add a new entry
+                        * before we can hook up the value
+                        */
+                       while (hash_entry->next) {
+                               hash_entry = hash_entry->next;
+                               if (strcmp(hash_entry->key, key) == 0) {
+                                       hash_entry->data = value;
+                                       return 0;
+                               }
+                               bucket_len++;
+                       }
+                       hash_entry->next = xcalloc(1, sizeof(hash_entry_t));
+                       hash_entry = hash_entry->next;
+                       hash_entry->next = NULL;
+
+                       hash->n_collisions++;
+                       if (++bucket_len > hash->max_bucket_len)
+                               hash->max_bucket_len = bucket_len;
+               }
+       } else
+               hash->n_used_buckets++;
+
+       hash->n_elements++;
+       hash_entry->key = xstrdup(key);
+       hash_entry->data = value;
+
+       return 0;
 }
 
-int hash_table_remove(hash_table_t *hash, const char *key)
+int hash_table_remove(hash_table_t * hash, const char *key)
 {
-    int ndx= hash_index(hash, key);
-    hash_entry_t *hash_entry = hash->entries + ndx;
-    hash_entry_t *next_entry=NULL, *last_entry=NULL;
-    while (hash_entry)
-    {
-        if (hash_entry->key)
-        {
-            if (strcmp(key, hash_entry->key) == 0) {
-                free(hash_entry->key);
-                if (last_entry) {
-                    last_entry->next = hash_entry->next;
-                    free(hash_entry);
-                } else {
-                    next_entry = hash_entry->next;
-                    if (next_entry) {
-                        memmove(hash_entry, next_entry, sizeof(hash_entry_t));
-                        free(next_entry);
-                    } else {
-                        memset(hash_entry, 0 , sizeof(hash_entry_t));
-                    }
-                }
-                return 1;
-            }
-        }
-        last_entry = hash_entry;
-        hash_entry = hash_entry->next;
-    }
-    return 0;
+       int ndx = hash_index(hash, key);
+       hash_entry_t *hash_entry = hash->entries + ndx;
+       hash_entry_t *next_entry = NULL, *last_entry = NULL;
+       while (hash_entry) {
+               if (hash_entry->key) {
+                       if (strcmp(key, hash_entry->key) == 0) {
+                               free(hash_entry->key);
+                               if (last_entry) {
+                                       last_entry->next = hash_entry->next;
+                                       free(hash_entry);
+                               } else {
+                                       next_entry = hash_entry->next;
+                                       if (next_entry) {
+                                               memmove(hash_entry, next_entry,
+                                                       sizeof(hash_entry_t));
+                                               free(next_entry);
+                                       } else {
+                                               memset(hash_entry, 0,
+                                                      sizeof(hash_entry_t));
+                                       }
+                               }
+                               return 1;
+                       }
+               }
+               last_entry = hash_entry;
+               hash_entry = hash_entry->next;
+       }
+       return 0;
 }
 
-void hash_table_foreach(hash_table_t *hash, void (*f)(const char *key, void *entry, void *data), void *data)
+void hash_table_foreach(hash_table_t * hash,
+                       void (*f) (const char *key, void *entry, void *data),
+                       void *data)
 {
-    int i;
-    if (!hash || !f)
-       return;
-
-    for (i = 0; i < hash->n_buckets; i++) {
-       hash_entry_t *hash_entry = (hash->entries + i);
-       do {
-           if(hash_entry->key) {
-               f(hash_entry->key, hash_entry->data, data);
-           }
-       } while((hash_entry = hash_entry->next));
-    }
-}
+       int i;
+       if (!hash || !f)
+               return;
 
+       for (i = 0; i < hash->n_buckets; i++) {
+               hash_entry_t *hash_entry = (hash->entries + i);
+               do {
+                       if (hash_entry->key) {
+                               f(hash_entry->key, hash_entry->data, data);
+                       }
+               } while ((hash_entry = hash_entry->next));
+       }
+}
index 472b3e2..8da5219 100644 (file)
@@ -22,30 +22,32 @@ typedef struct hash_entry hash_entry_t;
 typedef struct hash_table hash_table_t;
 
 struct hash_entry {
-  char * key;
-  void * data;
-  struct hash_entry * next;
+       char *key;
+       void *data;
+       struct hash_entry *next;
 };
 
 struct hash_table {
-  const char *name;
-  hash_entry_t * entries;
-  unsigned int n_buckets;
-  unsigned int n_elements;
-
-  /* useful stats */
-  unsigned int n_used_buckets;
-  unsigned int n_collisions;
-  unsigned int max_bucket_len;
-  unsigned int n_hits, n_misses;
+       const char *name;
+       hash_entry_t *entries;
+       unsigned int n_buckets;
+       unsigned int n_elements;
+
+       /* useful stats */
+       unsigned int n_used_buckets;
+       unsigned int n_collisions;
+       unsigned int max_bucket_len;
+       unsigned int n_hits, n_misses;
 };
 
-void hash_table_init(const char *name, hash_table_t *hash, int len);
-void hash_table_deinit(hash_table_t *hash);
-void hash_print_stats(hash_table_t *hash);
-void *hash_table_get(hash_table_t *hash, const char *key);
-int hash_table_insert(hash_table_t *hash, const char *key, void *value);
-int hash_table_remove(hash_table_t *has, const char *key);
-void hash_table_foreach(hash_table_t *hash, void (*f)(const char *key, void *entry, void *data), void *data);
+void hash_table_init(const char *name, hash_table_t * hash, int len);
+void hash_table_deinit(hash_table_t * hash);
+void hash_print_stats(hash_table_t * hash);
+void *hash_table_get(hash_table_t * hash, const char *key);
+int hash_table_insert(hash_table_t * hash, const char *key, void *value);
+int hash_table_remove(hash_table_t * has, const char *key);
+void hash_table_foreach(hash_table_t * hash,
+                       void (*f) (const char *key, void *entry, void *data),
+                       void *data);
 
 #endif /* _HASH_TABLE_H_ */
index c1325db..2b9aac3 100644 (file)
@@ -21,7 +21,7 @@
 #define _LINUX_LIST_H
 
 struct list_head {
-    struct list_head *next, *prev;
+       struct list_head *next, *prev;
 };
 
 #define LIST_POISON1  ((struct list_head *) 0x00100100)
@@ -37,12 +37,12 @@ struct list_head {
 } while (0)
 
 static inline void __list_add(struct list_head *newitem,
-                              struct list_head *prev,
-                              struct list_head *next) {
-    next->prev = newitem;
-    newitem->next = next;
-    newitem->prev = prev;
-    prev->next = newitem;
+                             struct list_head *prev, struct list_head *next)
+{
+       next->prev = newitem;
+       newitem->next = next;
+       newitem->prev = prev;
+       prev->next = newitem;
 }
 
 /**
@@ -53,8 +53,9 @@ static inline void __list_add(struct list_head *newitem,
  * Insert a new entry after the specified head.
  * This is good for implementing stacks.
  */
-static inline void list_add(struct list_head *newitem, struct list_head *head) {
-    __list_add(newitem, head, head->next);
+static inline void list_add(struct list_head *newitem, struct list_head *head)
+{
+       __list_add(newitem, head, head->next);
 }
 
 /**
@@ -65,11 +66,12 @@ static inline void list_add(struct list_head *newitem, struct list_head *head) {
  * Insert a new entry before the specified head.
  * This is useful for implementing queues.
  */
-static inline void list_add_tail(struct list_head *newitem, struct list_head *head) {
-    __list_add(newitem, head->prev, head);
+static inline void list_add_tail(struct list_head *newitem,
+                                struct list_head *head)
+{
+       __list_add(newitem, head->prev, head);
 }
 
-
 /*
  * Delete a list entry by making the prev/next entries
  * point to each other.
@@ -77,9 +79,10 @@ static inline void list_add_tail(struct list_head *newitem, struct list_head *he
  * This is only for internal list manipulation where we know
  * the prev/next entries already!
  */
-static inline void __list_del(struct list_head * prev, struct list_head * next) {
-    next->prev = prev;
-    prev->next = next;
+static inline void __list_del(struct list_head *prev, struct list_head *next)
+{
+       next->prev = prev;
+       prev->next = next;
 }
 
 /**
@@ -88,19 +91,21 @@ static inline void __list_del(struct list_head * prev, struct list_head * next)
  * Note: list_empty on entry does not return true after this, the entry is
  * in an undefined state.
  */
-static inline void list_del(struct list_head *entry) {
-    __list_del(entry->prev, entry->next);
-    entry->next = LIST_POISON1;
-    entry->prev = LIST_POISON2;
+static inline void list_del(struct list_head *entry)
+{
+       __list_del(entry->prev, entry->next);
+       entry->next = LIST_POISON1;
+       entry->prev = LIST_POISON2;
 }
 
 /**
  * list_del_init - deletes entry from list and reinitialize it.
  * @entry: the element to delete from the list.
  */
-static inline void list_del_init(struct list_head *entry) {
-    __list_del(entry->prev, entry->next);
-    INIT_LIST_HEAD(entry);
+static inline void list_del_init(struct list_head *entry)
+{
+       __list_del(entry->prev, entry->next);
+       INIT_LIST_HEAD(entry);
 }
 
 /**
@@ -108,9 +113,10 @@ static inline void list_del_init(struct list_head *entry) {
  * @list: the entry to move
  * @head: the head that will precede our entry
  */
-static inline void list_move(struct list_head *list, struct list_head *head) {
-    __list_del(list->prev, list->next);
-    list_add(list, head);
+static inline void list_move(struct list_head *list, struct list_head *head)
+{
+       __list_del(list->prev, list->next);
+       list_add(list, head);
 }
 
 /**
@@ -119,17 +125,19 @@ static inline void list_move(struct list_head *list, struct list_head *head) {
  * @head: the head that will follow our entry
  */
 static inline void list_move_tail(struct list_head *list,
-                                  struct list_head *head) {
-    __list_del(list->prev, list->next);
-    list_add_tail(list, head);
+                                 struct list_head *head)
+{
+       __list_del(list->prev, list->next);
+       list_add_tail(list, head);
 }
 
 /**
  * list_empty - tests whether a list is empty
  * @head: the list to test.
  */
-static inline int list_empty(const struct list_head *head) {
-    return head->next == head;
+static inline int list_empty(const struct list_head *head)
+{
+       return head->next == head;
 }
 
 /**
@@ -144,22 +152,23 @@ static inline int list_empty(const struct list_head *head) {
  *
  * @head: the list to test.
  */
-static inline int list_empty_careful(const struct list_head *head) {
-    struct list_head *next = head->next;
-    return (next == head) && (next == head->prev);
+static inline int list_empty_careful(const struct list_head *head)
+{
+       struct list_head *next = head->next;
+       return (next == head) && (next == head->prev);
 }
 
-static inline void __list_splice(struct list_head *list,
-                                 struct list_head *head) {
-    struct list_head *first = list->next;
-    struct list_head *last = list->prev;
-    struct list_head *at = head->next;
+static inline void __list_splice(struct list_head *list, struct list_head *head)
+{
+       struct list_head *first = list->next;
+       struct list_head *last = list->prev;
+       struct list_head *at = head->next;
 
-    first->prev = head;
-    head->next = first;
+       first->prev = head;
+       head->next = first;
 
-    last->next = at;
-    at->prev = last;
+       last->next = at;
+       at->prev = last;
 }
 
 /**
@@ -167,9 +176,10 @@ static inline void __list_splice(struct list_head *list,
  * @list: the new list to add.
  * @head: the place to add it in the first list.
  */
-static inline void list_splice(struct list_head *list, struct list_head *head) {
-    if (!list_empty(list))
-        __list_splice(list, head);
+static inline void list_splice(struct list_head *list, struct list_head *head)
+{
+       if (!list_empty(list))
+               __list_splice(list, head);
 }
 
 /**
@@ -180,15 +190,14 @@ static inline void list_splice(struct list_head *list, struct list_head *head) {
  * The list at @list is reinitialised
  */
 static inline void list_splice_init(struct list_head *list,
-                                    struct list_head *head) {
-    if (!list_empty(list)) {
-        __list_splice(list, head);
-        INIT_LIST_HEAD(list);
-    }
+                                   struct list_head *head)
+{
+       if (!list_empty(list)) {
+               __list_splice(list, head);
+               INIT_LIST_HEAD(list);
+       }
 }
 
-
-
 #define _offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 #define container_of(ptr, type, member) ({                      \
         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
index 2213dc1..5db235e 100644 (file)
 #include <sys/types.h>
 
 #if USE_UNLOCKED_IO
-# include "unlocked-io.h"
+#include "unlocked-io.h"
 #endif
 
 #ifdef _LIBC
-# include <endian.h>
-# if __BYTE_ORDER == __BIG_ENDIAN
-#  define WORDS_BIGENDIAN 1
-# endif
+#include <endian.h>
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define WORDS_BIGENDIAN 1
+#endif
 /* We need to keep the namespace clean so define the MD5 function
    protected using leading __ .  */
-# define md5_init_ctx __md5_init_ctx
-# define md5_process_block __md5_process_block
-# define md5_process_bytes __md5_process_bytes
-# define md5_finish_ctx __md5_finish_ctx
-# define md5_read_ctx __md5_read_ctx
-# define md5_stream __md5_stream
-# define md5_buffer __md5_buffer
+#define md5_init_ctx __md5_init_ctx
+#define md5_process_block __md5_process_block
+#define md5_process_bytes __md5_process_bytes
+#define md5_finish_ctx __md5_finish_ctx
+#define md5_read_ctx __md5_read_ctx
+#define md5_stream __md5_stream
+#define md5_buffer __md5_buffer
 #endif
 
 #ifdef WORDS_BIGENDIAN
-# define SWAP(n)                                                       \
+#define SWAP(n)                                                        \
     (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
 #else
-# define SWAP(n) (n)
+#define SWAP(n) (n)
 #endif
 
 #define BLOCKSIZE 4096
 #if BLOCKSIZE % 64 != 0
-# error "invalid BLOCKSIZE"
+#error "invalid BLOCKSIZE"
 #endif
 
 /* This array contains the bytes used to pad the buffer to the next
    64-byte boundary.  (RFC 1321, 3.1: Step 1)  */
-static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
-
+static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */  };
 
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
-void
-md5_init_ctx (struct md5_ctx *ctx)
+void md5_init_ctx(struct md5_ctx *ctx)
 {
-  ctx->A = 0x67452301;
-  ctx->B = 0xefcdab89;
-  ctx->C = 0x98badcfe;
-  ctx->D = 0x10325476;
+       ctx->A = 0x67452301;
+       ctx->B = 0xefcdab89;
+       ctx->C = 0x98badcfe;
+       ctx->D = 0x10325476;
 
-  ctx->total[0] = ctx->total[1] = 0;
-  ctx->buflen = 0;
+       ctx->total[0] = ctx->total[1] = 0;
+       ctx->buflen = 0;
 }
 
 /* Copy the 4 byte value from v into the memory location pointed to by *cp,
    If your architecture allows unaligned access this is equivalent to
    * (uint32_t *) cp = v  */
-static inline void
-set_uint32 (char *cp, uint32_t v)
+static inline void set_uint32(char *cp, uint32_t v)
 {
-  memcpy (cp, &v, sizeof v);
+       memcpy(cp, &v, sizeof v);
 }
 
 /* Put result from CTX in first 16 bytes following RESBUF.  The result
    must be in little endian byte order.  */
-void *
-md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
+void *md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
 {
-  char *r = resbuf;
-  set_uint32 (r + 0 * sizeof ctx->A, SWAP (ctx->A));
-  set_uint32 (r + 1 * sizeof ctx->B, SWAP (ctx->B));
-  set_uint32 (r + 2 * sizeof ctx->C, SWAP (ctx->C));
-  set_uint32 (r + 3 * sizeof ctx->D, SWAP (ctx->D));
+       char *r = resbuf;
+       set_uint32(r + 0 * sizeof ctx->A, SWAP(ctx->A));
+       set_uint32(r + 1 * sizeof ctx->B, SWAP(ctx->B));
+       set_uint32(r + 2 * sizeof ctx->C, SWAP(ctx->C));
+       set_uint32(r + 3 * sizeof ctx->D, SWAP(ctx->D));
 
-  return resbuf;
+       return resbuf;
 }
 
 /* Process the remaining bytes in the internal buffer and the usual
    prolog according to the standard and write the result to RESBUF.  */
-void *
-md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
+void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
 {
-  /* Take yet unprocessed bytes into account.  */
-  uint32_t bytes = ctx->buflen;
-  size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
+       /* Take yet unprocessed bytes into account.  */
+       uint32_t bytes = ctx->buflen;
+       size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
 
-  /* Now count remaining bytes.  */
-  ctx->total[0] += bytes;
-  if (ctx->total[0] < bytes)
-    ++ctx->total[1];
+       /* Now count remaining bytes.  */
+       ctx->total[0] += bytes;
+       if (ctx->total[0] < bytes)
+               ++ctx->total[1];
 
-  /* Put the 64-bit file length in *bits* at the end of the buffer.  */
-  ctx->buffer[size - 2] = SWAP (ctx->total[0] << 3);
-  ctx->buffer[size - 1] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
+       /* Put the 64-bit file length in *bits* at the end of the buffer.  */
+       ctx->buffer[size - 2] = SWAP(ctx->total[0] << 3);
+       ctx->buffer[size - 1] =
+           SWAP((ctx->total[1] << 3) | (ctx->total[0] >> 29));
 
-  memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
+       memcpy(&((char *)ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
 
-  /* Process last bytes.  */
-  md5_process_block (ctx->buffer, size * 4, ctx);
+       /* Process last bytes.  */
+       md5_process_block(ctx->buffer, size * 4, ctx);
 
-  return md5_read_ctx (ctx, resbuf);
+       return md5_read_ctx(ctx, resbuf);
 }
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
-int
-md5_stream (FILE *stream, void *resblock)
+int md5_stream(FILE * stream, void *resblock)
 {
-  struct md5_ctx ctx;
-  char buffer[BLOCKSIZE + 72];
-  size_t sum;
-
-  /* Initialize the computation context.  */
-  md5_init_ctx (&ctx);
-
-  /* Iterate over full file contents.  */
-  while (1)
-    {
-      /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
-         computation function processes the whole buffer so that with the
-         next round of the loop another block can be read.  */
-      size_t n;
-      sum = 0;
-
-      /* Read block.  Take care for partial reads.  */
-      while (1)
-       {
-         n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
-
-         sum += n;
-
-         if (sum == BLOCKSIZE)
-           break;
-
-         if (n == 0)
-           {
-             /* Check for the error flag IFF N == 0, so that we don't
-                exit the loop after a partial read due to e.g., EAGAIN
-                or EWOULDBLOCK.  */
-             if (ferror (stream))
-               return 1;
-             goto process_partial_block;
-           }
-
-         /* We've read at least one byte, so ignore errors.  But always
-            check for EOF, since feof may be true even though N > 0.
-            Otherwise, we could end up calling fread after EOF.  */
-         if (feof (stream))
-           goto process_partial_block;
+       struct md5_ctx ctx;
+       char buffer[BLOCKSIZE + 72];
+       size_t sum;
+
+       /* Initialize the computation context.  */
+       md5_init_ctx(&ctx);
+
+       /* Iterate over full file contents.  */
+       while (1) {
+               /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
+                  computation function processes the whole buffer so that with the
+                  next round of the loop another block can be read.  */
+               size_t n;
+               sum = 0;
+
+               /* Read block.  Take care for partial reads.  */
+               while (1) {
+                       n = fread(buffer + sum, 1, BLOCKSIZE - sum, stream);
+
+                       sum += n;
+
+                       if (sum == BLOCKSIZE)
+                               break;
+
+                       if (n == 0) {
+                               /* Check for the error flag IFF N == 0, so that we don't
+                                  exit the loop after a partial read due to e.g., EAGAIN
+                                  or EWOULDBLOCK.  */
+                               if (ferror(stream))
+                                       return 1;
+                               goto process_partial_block;
+                       }
+
+                       /* We've read at least one byte, so ignore errors.  But always
+                          check for EOF, since feof may be true even though N > 0.
+                          Otherwise, we could end up calling fread after EOF.  */
+                       if (feof(stream))
+                               goto process_partial_block;
+               }
+
+               /* Process buffer with BLOCKSIZE bytes.  Note that
+                  BLOCKSIZE % 64 == 0
+                */
+               md5_process_block(buffer, BLOCKSIZE, &ctx);
        }
 
-      /* Process buffer with BLOCKSIZE bytes.  Note that
-         BLOCKSIZE % 64 == 0
-       */
-      md5_process_block (buffer, BLOCKSIZE, &ctx);
-    }
-
 process_partial_block:
 
-  /* Process any remaining bytes.  */
-  if (sum > 0)
-    md5_process_bytes (buffer, sum, &ctx);
+       /* Process any remaining bytes.  */
+       if (sum > 0)
+               md5_process_bytes(buffer, sum, &ctx);
 
-  /* Construct result in desired memory.  */
-  md5_finish_ctx (&ctx, resblock);
-  return 0;
+       /* Construct result in desired memory.  */
+       md5_finish_ctx(&ctx, resblock);
+       return 0;
 }
 
 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
    result is always in little endian byte order, so that a byte-wise
    output yields to the wanted ASCII representation of the message
    digest.  */
-void *
-md5_buffer (const char *buffer, size_t len, void *resblock)
+void *md5_buffer(const char *buffer, size_t len, void *resblock)
 {
-  struct md5_ctx ctx;
+       struct md5_ctx ctx;
 
-  /* Initialize the computation context.  */
-  md5_init_ctx (&ctx);
+       /* Initialize the computation context.  */
+       md5_init_ctx(&ctx);
 
-  /* Process whole buffer but last len % 64 bytes.  */
-  md5_process_bytes (buffer, len, &ctx);
+       /* Process whole buffer but last len % 64 bytes.  */
+       md5_process_bytes(buffer, len, &ctx);
 
-  /* Put result in desired memory area.  */
-  return md5_finish_ctx (&ctx, resblock);
+       /* Put result in desired memory area.  */
+       return md5_finish_ctx(&ctx, resblock);
 }
 
-
-void
-md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
+void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx)
 {
-  /* When we already have some bits in our internal buffer concatenate
-     both inputs first.  */
-  if (ctx->buflen != 0)
-    {
-      size_t left_over = ctx->buflen;
-      size_t add = 128 - left_over > len ? len : 128 - left_over;
-
-      memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
-      ctx->buflen += add;
-
-      if (ctx->buflen > 64)
-       {
-         md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
-
-         ctx->buflen &= 63;
-         /* The regions in the following copy operation cannot overlap.  */
-         memcpy (ctx->buffer,
-                 &((char *) ctx->buffer)[(left_over + add) & ~63],
-                 ctx->buflen);
+       /* When we already have some bits in our internal buffer concatenate
+          both inputs first.  */
+       if (ctx->buflen != 0) {
+               size_t left_over = ctx->buflen;
+               size_t add = 128 - left_over > len ? len : 128 - left_over;
+
+               memcpy(&((char *)ctx->buffer)[left_over], buffer, add);
+               ctx->buflen += add;
+
+               if (ctx->buflen > 64) {
+                       md5_process_block(ctx->buffer, ctx->buflen & ~63, ctx);
+
+                       ctx->buflen &= 63;
+                       /* The regions in the following copy operation cannot overlap.  */
+                       memcpy(ctx->buffer,
+                              &((char *)ctx->buffer)[(left_over + add) & ~63],
+                              ctx->buflen);
+               }
+
+               buffer = (const char *)buffer + add;
+               len -= add;
        }
 
-      buffer = (const char *) buffer + add;
-      len -= add;
-    }
-
-  /* Process available complete blocks.  */
-  if (len >= 64)
-    {
+       /* Process available complete blocks.  */
+       if (len >= 64) {
 #if !_STRING_ARCH_unaligned
-# define alignof(type) offsetof (struct { char c; type x; }, x)
-# define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0)
-      if (UNALIGNED_P (buffer))
-       while (len > 64)
-         {
-           md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
-           buffer = (const char *) buffer + 64;
-           len -= 64;
-         }
-      else
+#define alignof(type) offsetof (struct { char c; type x; }, x)
+#define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0)
+               if (UNALIGNED_P(buffer))
+                       while (len > 64) {
+                               md5_process_block(memcpy
+                                                 (ctx->buffer, buffer, 64), 64,
+                                                 ctx);
+                               buffer = (const char *)buffer + 64;
+                               len -= 64;
+               } else
 #endif
-       {
-         md5_process_block (buffer, len & ~63, ctx);
-         buffer = (const char *) buffer + (len & ~63);
-         len &= 63;
+               {
+                       md5_process_block(buffer, len & ~63, ctx);
+                       buffer = (const char *)buffer + (len & ~63);
+                       len &= 63;
+               }
        }
-    }
-
-  /* Move remaining bytes in internal buffer.  */
-  if (len > 0)
-    {
-      size_t left_over = ctx->buflen;
-
-      memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
-      left_over += len;
-      if (left_over >= 64)
-       {
-         md5_process_block (ctx->buffer, 64, ctx);
-         left_over -= 64;
-         memcpy (ctx->buffer, &ctx->buffer[16], left_over);
+
+       /* Move remaining bytes in internal buffer.  */
+       if (len > 0) {
+               size_t left_over = ctx->buflen;
+
+               memcpy(&((char *)ctx->buffer)[left_over], buffer, len);
+               left_over += len;
+               if (left_over >= 64) {
+                       md5_process_block(ctx->buffer, 64, ctx);
+                       left_over -= 64;
+                       memcpy(ctx->buffer, &ctx->buffer[16], left_over);
+               }
+               ctx->buflen = left_over;
        }
-      ctx->buflen = left_over;
-    }
 }
 
-
 /* These are the four functions used in the four steps of the MD5 algorithm
    and defined in the RFC 1321.  The first function is a little bit optimized
    (as found in Colin Plumbs public domain implementation).  */
@@ -295,41 +278,39 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
 /* Process LEN bytes of BUFFER, accumulating context into CTX.
    It is assumed that LEN % 64 == 0.  */
 
-void
-md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
+void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
 {
-  uint32_t correct_words[16];
-  const uint32_t *words = buffer;
-  size_t nwords = len / sizeof (uint32_t);
-  const uint32_t *endp = words + nwords;
-  uint32_t A = ctx->A;
-  uint32_t B = ctx->B;
-  uint32_t C = ctx->C;
-  uint32_t D = ctx->D;
-
-  /* First increment the byte count.  RFC 1321 specifies the possible
-     length of the file up to 2^64 bits.  Here we only compute the
-     number of bytes.  Do a double word increment.  */
-  ctx->total[0] += len;
-  if (ctx->total[0] < len)
-    ++ctx->total[1];
-
-  /* Process all bytes in the buffer with 64 bytes in each round of
-     the loop.  */
-  while (words < endp)
-    {
-      uint32_t *cwp = correct_words;
-      uint32_t A_save = A;
-      uint32_t B_save = B;
-      uint32_t C_save = C;
-      uint32_t D_save = D;
-
-      /* First round: using the given function, the context and a constant
-         the next context is computed.  Because the algorithms processing
-         unit is a 32-bit word and it is determined to work on words in
-         little endian byte order we perhaps have to change the byte order
-         before the computation.  To reduce the work for the next steps
-         we store the swapped words in the array CORRECT_WORDS.  */
+       uint32_t correct_words[16];
+       const uint32_t *words = buffer;
+       size_t nwords = len / sizeof(uint32_t);
+       const uint32_t *endp = words + nwords;
+       uint32_t A = ctx->A;
+       uint32_t B = ctx->B;
+       uint32_t C = ctx->C;
+       uint32_t D = ctx->D;
+
+       /* First increment the byte count.  RFC 1321 specifies the possible
+          length of the file up to 2^64 bits.  Here we only compute the
+          number of bytes.  Do a double word increment.  */
+       ctx->total[0] += len;
+       if (ctx->total[0] < len)
+               ++ctx->total[1];
+
+       /* Process all bytes in the buffer with 64 bytes in each round of
+          the loop.  */
+       while (words < endp) {
+               uint32_t *cwp = correct_words;
+               uint32_t A_save = A;
+               uint32_t B_save = B;
+               uint32_t C_save = C;
+               uint32_t D_save = D;
+
+               /* First round: using the given function, the context and a constant
+                  the next context is computed.  Because the algorithms processing
+                  unit is a 32-bit word and it is determined to work on words in
+                  little endian byte order we perhaps have to change the byte order
+                  before the computation.  To reduce the work for the next steps
+                  we store the swapped words in the array CORRECT_WORDS.  */
 
 #define OP(a, b, c, d, s, T)                                           \
       do                                                               \
@@ -341,41 +322,41 @@ md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
         }                                                              \
       while (0)
 
-      /* It is unfortunate that C does not provide an operator for
-         cyclic rotation.  Hope the C compiler is smart enough.  */
+               /* It is unfortunate that C does not provide an operator for
+                  cyclic rotation.  Hope the C compiler is smart enough.  */
 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
 
-      /* Before we start, one word to the strange constants.
-         They are defined in RFC 1321 as
-
-         T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
-
-         Here is an equivalent invocation using Perl:
-
-         perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
-       */
-
-      /* Round 1.  */
-      OP (A, B, C, D, 7, 0xd76aa478);
-      OP (D, A, B, C, 12, 0xe8c7b756);
-      OP (C, D, A, B, 17, 0x242070db);
-      OP (B, C, D, A, 22, 0xc1bdceee);
-      OP (A, B, C, D, 7, 0xf57c0faf);
-      OP (D, A, B, C, 12, 0x4787c62a);
-      OP (C, D, A, B, 17, 0xa8304613);
-      OP (B, C, D, A, 22, 0xfd469501);
-      OP (A, B, C, D, 7, 0x698098d8);
-      OP (D, A, B, C, 12, 0x8b44f7af);
-      OP (C, D, A, B, 17, 0xffff5bb1);
-      OP (B, C, D, A, 22, 0x895cd7be);
-      OP (A, B, C, D, 7, 0x6b901122);
-      OP (D, A, B, C, 12, 0xfd987193);
-      OP (C, D, A, B, 17, 0xa679438e);
-      OP (B, C, D, A, 22, 0x49b40821);
-
-      /* For the second to fourth round we have the possibly swapped words
-         in CORRECT_WORDS.  Redefine the macro to take an additional first
-         argument specifying the function to use.  */
+               /* Before we start, one word to the strange constants.
+                  They are defined in RFC 1321 as
+
+                  T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
+
+                  Here is an equivalent invocation using Perl:
+
+                  perl -e 'foreach(1..64){printf "0x%08x\n", int (4294967296 * abs (sin $_))}'
+                */
+
+               /* Round 1.  */
+               OP(A, B, C, D, 7, 0xd76aa478);
+               OP(D, A, B, C, 12, 0xe8c7b756);
+               OP(C, D, A, B, 17, 0x242070db);
+               OP(B, C, D, A, 22, 0xc1bdceee);
+               OP(A, B, C, D, 7, 0xf57c0faf);
+               OP(D, A, B, C, 12, 0x4787c62a);
+               OP(C, D, A, B, 17, 0xa8304613);
+               OP(B, C, D, A, 22, 0xfd469501);
+               OP(A, B, C, D, 7, 0x698098d8);
+               OP(D, A, B, C, 12, 0x8b44f7af);
+               OP(C, D, A, B, 17, 0xffff5bb1);
+               OP(B, C, D, A, 22, 0x895cd7be);
+               OP(A, B, C, D, 7, 0x6b901122);
+               OP(D, A, B, C, 12, 0xfd987193);
+               OP(C, D, A, B, 17, 0xa679438e);
+               OP(B, C, D, A, 22, 0x49b40821);
+
+               /* For the second to fourth round we have the possibly swapped words
+                  in CORRECT_WORDS.  Redefine the macro to take an additional first
+                  argument specifying the function to use.  */
 #undef OP
 #define OP(f, a, b, c, d, k, s, T)                                     \
       do                                                               \
@@ -386,70 +367,70 @@ md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
        }                                                               \
       while (0)
 
-      /* Round 2.  */
-      OP (FG, A, B, C, D, 1, 5, 0xf61e2562);
-      OP (FG, D, A, B, C, 6, 9, 0xc040b340);
-      OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
-      OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
-      OP (FG, A, B, C, D, 5, 5, 0xd62f105d);
-      OP (FG, D, A, B, C, 10, 9, 0x02441453);
-      OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
-      OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
-      OP (FG, A, B, C, D, 9, 5, 0x21e1cde6);
-      OP (FG, D, A, B, C, 14, 9, 0xc33707d6);
-      OP (FG, C, D, A, B, 3, 14, 0xf4d50d87);
-      OP (FG, B, C, D, A, 8, 20, 0x455a14ed);
-      OP (FG, A, B, C, D, 13, 5, 0xa9e3e905);
-      OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8);
-      OP (FG, C, D, A, B, 7, 14, 0x676f02d9);
-      OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
-
-      /* Round 3.  */
-      OP (FH, A, B, C, D, 5, 4, 0xfffa3942);
-      OP (FH, D, A, B, C, 8, 11, 0x8771f681);
-      OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
-      OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
-      OP (FH, A, B, C, D, 1, 4, 0xa4beea44);
-      OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9);
-      OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60);
-      OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
-      OP (FH, A, B, C, D, 13, 4, 0x289b7ec6);
-      OP (FH, D, A, B, C, 0, 11, 0xeaa127fa);
-      OP (FH, C, D, A, B, 3, 16, 0xd4ef3085);
-      OP (FH, B, C, D, A, 6, 23, 0x04881d05);
-      OP (FH, A, B, C, D, 9, 4, 0xd9d4d039);
-      OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
-      OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
-      OP (FH, B, C, D, A, 2, 23, 0xc4ac5665);
-
-      /* Round 4.  */
-      OP (FI, A, B, C, D, 0, 6, 0xf4292244);
-      OP (FI, D, A, B, C, 7, 10, 0x432aff97);
-      OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
-      OP (FI, B, C, D, A, 5, 21, 0xfc93a039);
-      OP (FI, A, B, C, D, 12, 6, 0x655b59c3);
-      OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92);
-      OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
-      OP (FI, B, C, D, A, 1, 21, 0x85845dd1);
-      OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f);
-      OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
-      OP (FI, C, D, A, B, 6, 15, 0xa3014314);
-      OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
-      OP (FI, A, B, C, D, 4, 6, 0xf7537e82);
-      OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
-      OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
-      OP (FI, B, C, D, A, 9, 21, 0xeb86d391);
-
-      /* Add the starting values of the context.  */
-      A += A_save;
-      B += B_save;
-      C += C_save;
-      D += D_save;
-    }
-
-  /* Put checksum in context given as argument.  */
-  ctx->A = A;
-  ctx->B = B;
-  ctx->C = C;
-  ctx->D = D;
+               /* Round 2.  */
+               OP(FG, A, B, C, D, 1, 5, 0xf61e2562);
+               OP(FG, D, A, B, C, 6, 9, 0xc040b340);
+               OP(FG, C, D, A, B, 11, 14, 0x265e5a51);
+               OP(FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
+               OP(FG, A, B, C, D, 5, 5, 0xd62f105d);
+               OP(FG, D, A, B, C, 10, 9, 0x02441453);
+               OP(FG, C, D, A, B, 15, 14, 0xd8a1e681);
+               OP(FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
+               OP(FG, A, B, C, D, 9, 5, 0x21e1cde6);
+               OP(FG, D, A, B, C, 14, 9, 0xc33707d6);
+               OP(FG, C, D, A, B, 3, 14, 0xf4d50d87);
+               OP(FG, B, C, D, A, 8, 20, 0x455a14ed);
+               OP(FG, A, B, C, D, 13, 5, 0xa9e3e905);
+               OP(FG, D, A, B, C, 2, 9, 0xfcefa3f8);
+               OP(FG, C, D, A, B, 7, 14, 0x676f02d9);
+               OP(FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
+
+               /* Round 3.  */
+               OP(FH, A, B, C, D, 5, 4, 0xfffa3942);
+               OP(FH, D, A, B, C, 8, 11, 0x8771f681);
+               OP(FH, C, D, A, B, 11, 16, 0x6d9d6122);
+               OP(FH, B, C, D, A, 14, 23, 0xfde5380c);
+               OP(FH, A, B, C, D, 1, 4, 0xa4beea44);
+               OP(FH, D, A, B, C, 4, 11, 0x4bdecfa9);
+               OP(FH, C, D, A, B, 7, 16, 0xf6bb4b60);
+               OP(FH, B, C, D, A, 10, 23, 0xbebfbc70);
+               OP(FH, A, B, C, D, 13, 4, 0x289b7ec6);
+               OP(FH, D, A, B, C, 0, 11, 0xeaa127fa);
+               OP(FH, C, D, A, B, 3, 16, 0xd4ef3085);
+               OP(FH, B, C, D, A, 6, 23, 0x04881d05);
+               OP(FH, A, B, C, D, 9, 4, 0xd9d4d039);
+               OP(FH, D, A, B, C, 12, 11, 0xe6db99e5);
+               OP(FH, C, D, A, B, 15, 16, 0x1fa27cf8);
+               OP(FH, B, C, D, A, 2, 23, 0xc4ac5665);
+
+               /* Round 4.  */
+               OP(FI, A, B, C, D, 0, 6, 0xf4292244);
+               OP(FI, D, A, B, C, 7, 10, 0x432aff97);
+               OP(FI, C, D, A, B, 14, 15, 0xab9423a7);
+               OP(FI, B, C, D, A, 5, 21, 0xfc93a039);
+               OP(FI, A, B, C, D, 12, 6, 0x655b59c3);
+               OP(FI, D, A, B, C, 3, 10, 0x8f0ccc92);
+               OP(FI, C, D, A, B, 10, 15, 0xffeff47d);
+               OP(FI, B, C, D, A, 1, 21, 0x85845dd1);
+               OP(FI, A, B, C, D, 8, 6, 0x6fa87e4f);
+               OP(FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
+               OP(FI, C, D, A, B, 6, 15, 0xa3014314);
+               OP(FI, B, C, D, A, 13, 21, 0x4e0811a1);
+               OP(FI, A, B, C, D, 4, 6, 0xf7537e82);
+               OP(FI, D, A, B, C, 11, 10, 0xbd3af235);
+               OP(FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
+               OP(FI, B, C, D, A, 9, 21, 0xeb86d391);
+
+               /* Add the starting values of the context.  */
+               A += A_save;
+               B += B_save;
+               C += C_save;
+               D += D_save;
+       }
+
+       /* Put checksum in context given as argument.  */
+       ctx->A = A;
+       ctx->B = B;
+       ctx->C = C;
+       ctx->D = D;
 }
index 3ae657b..717e9ea 100644 (file)
 #define MD5_BLOCK_SIZE 64
 
 #ifndef __GNUC_PREREQ
-# if defined __GNUC__ && defined __GNUC_MINOR__
-#  define __GNUC_PREREQ(maj, min)                                      \
+#if defined __GNUC__ && defined __GNUC_MINOR__
+#define __GNUC_PREREQ(maj, min)                                        \
   ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
-# else
-#  define __GNUC_PREREQ(maj, min) 0
-# endif
+#else
+#define __GNUC_PREREQ(maj, min) 0
+#endif
 #endif
 
 #ifndef __THROW
-# if defined __cplusplus && __GNUC_PREREQ (2,8)
-#  define __THROW      throw ()
-# else
-#  define __THROW
-# endif
+#if defined __cplusplus && __GNUC_PREREQ (2,8)
+#define __THROW        throw ()
+#else
+#define __THROW
+#endif
 #endif
 
 #ifndef _LIBC
-# define __md5_buffer md5_buffer
-# define __md5_finish_ctx md5_finish_ctx
-# define __md5_init_ctx md5_init_ctx
-# define __md5_process_block md5_process_block
-# define __md5_process_bytes md5_process_bytes
-# define __md5_read_ctx md5_read_ctx
-# define __md5_stream md5_stream
+#define __md5_buffer md5_buffer
+#define __md5_finish_ctx md5_finish_ctx
+#define __md5_init_ctx md5_init_ctx
+#define __md5_process_block md5_process_block
+#define __md5_process_bytes md5_process_bytes
+#define __md5_read_ctx md5_read_ctx
+#define __md5_stream md5_stream
 #endif
 
 /* Structure to save state of computation between the single steps.  */
-struct md5_ctx
-{
-  uint32_t A;
-  uint32_t B;
-  uint32_t C;
-  uint32_t D;
-
-  uint32_t total[2];
-  uint32_t buflen;
-  uint32_t buffer[32];
+struct md5_ctx {
+       uint32_t A;
+       uint32_t B;
+       uint32_t C;
+       uint32_t D;
+
+       uint32_t total[2];
+       uint32_t buflen;
+       uint32_t buffer[32];
 };
 
 /*
@@ -74,45 +73,43 @@ struct md5_ctx
 
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
-extern void __md5_init_ctx (struct md5_ctx *ctx) __THROW;
+extern void __md5_init_ctx(struct md5_ctx *ctx) __THROW;
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is necessary that LEN is a multiple of 64!!! */
-extern void __md5_process_block (const void *buffer, size_t len,
-                                struct md5_ctx *ctx) __THROW;
+extern void __md5_process_block(const void *buffer, size_t len,
+                               struct md5_ctx *ctx) __THROW;
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is NOT required that LEN is a multiple of 64.  */
-extern void __md5_process_bytes (const void *buffer, size_t len,
-                                struct md5_ctx *ctx) __THROW;
+extern void __md5_process_bytes(const void *buffer, size_t len,
+                               struct md5_ctx *ctx) __THROW;
 
 /* Process the remaining bytes in the buffer and put result from CTX
    in first 16 bytes following RESBUF.  The result is always in little
    endian byte order, so that a byte-wise output yields to the wanted
    ASCII representation of the message digest.  */
-extern void *__md5_finish_ctx (struct md5_ctx *ctx, void *resbuf) __THROW;
-
+extern void *__md5_finish_ctx(struct md5_ctx *ctx, void *resbuf) __THROW;
 
 /* Put result from CTX in first 16 bytes following RESBUF.  The result is
    always in little endian byte order, so that a byte-wise output yields
    to the wanted ASCII representation of the message digest.  */
-extern void *__md5_read_ctx (const struct md5_ctx *ctx, void *resbuf) __THROW;
-
+extern void *__md5_read_ctx(const struct md5_ctx *ctx, void *resbuf) __THROW;
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
-extern int __md5_stream (FILE *stream, void *resblock) __THROW;
+extern int __md5_stream(FILE * stream, void *resblock) __THROW;
 
 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
    result is always in little endian byte order, so that a byte-wise
    output yields to the wanted ASCII representation of the message
    digest.  */
-extern void *__md5_buffer (const char *buffer, size_t len,
-                          void *resblock) __THROW;
+extern void *__md5_buffer(const char *buffer, size_t len,
+                         void *resblock) __THROW;
 
 #endif /* md5.h */
index 2728100..d323ce5 100644 (file)
 #include "nv_pair.h"
 #include "libbb/libbb.h"
 
-int nv_pair_init(nv_pair_t *nv_pair, const char *name, const char *value)
+int nv_pair_init(nv_pair_t * nv_pair, const char *name, const char *value)
 {
 
-    nv_pair->name = xstrdup(name);
-    nv_pair->value = xstrdup(value);
+       nv_pair->name = xstrdup(name);
+       nv_pair->value = xstrdup(value);
 
-    return 0;
+       return 0;
 }
 
-void nv_pair_deinit(nv_pair_t *nv_pair)
+void nv_pair_deinit(nv_pair_t * nv_pair)
 {
-    free(nv_pair->name);
-    nv_pair->name = NULL;
+       free(nv_pair->name);
+       nv_pair->name = NULL;
 
-    free(nv_pair->value);
-    nv_pair->value = NULL;
+       free(nv_pair->value);
+       nv_pair->value = NULL;
 }
-
-
index 72513e4..478435f 100644 (file)
 #define NV_PAIR_H
 
 typedef struct nv_pair nv_pair_t;
-struct nv_pair
-{
-    char *name;
-    char *value;
+struct nv_pair {
+       char *name;
+       char *value;
 };
 
-int nv_pair_init(nv_pair_t *nv_pair, const char *name, const char *value);
-void nv_pair_deinit(nv_pair_t *nv_pair);
+int nv_pair_init(nv_pair_t * nv_pair, const char *name, const char *value);
+void nv_pair_deinit(nv_pair_t * nv_pair);
 
 #endif
-
index 333e721..154f136 100644 (file)
 #include "nv_pair_list.h"
 #include "libbb/libbb.h"
 
-void nv_pair_list_init(nv_pair_list_t *list)
+void nv_pair_list_init(nv_pair_list_t * list)
 {
-    void_list_init((void_list_t *) list);
+       void_list_init((void_list_t *) list);
 }
 
-void nv_pair_list_deinit(nv_pair_list_t *list)
+void nv_pair_list_deinit(nv_pair_list_t * list)
 {
-    nv_pair_list_elt_t *pos;
-    nv_pair_t *nv_pair;
-
-    while(!void_list_empty(list)) {
-        pos = nv_pair_list_pop(list);
-        if (!pos)
-            break;
-       nv_pair =  (nv_pair_t *) pos->data;
-       nv_pair_deinit(nv_pair);
-       /* malloced in nv_pair_list_append */
-       free(nv_pair);
-       pos->data = NULL;
-        free(pos);
-    }
-    void_list_deinit((void_list_t *) list);
+       nv_pair_list_elt_t *pos;
+       nv_pair_t *nv_pair;
+
+       while (!void_list_empty(list)) {
+               pos = nv_pair_list_pop(list);
+               if (!pos)
+                       break;
+               nv_pair = (nv_pair_t *) pos->data;
+               nv_pair_deinit(nv_pair);
+               /* malloced in nv_pair_list_append */
+               free(nv_pair);
+               pos->data = NULL;
+               free(pos);
+       }
+       void_list_deinit((void_list_t *) list);
 }
 
-nv_pair_t *nv_pair_list_append(nv_pair_list_t *list, const char *name, const char *value)
+nv_pair_t *nv_pair_list_append(nv_pair_list_t * list, const char *name,
+                              const char *value)
 {
-    /* freed in nv_pair_list_deinit */
-    nv_pair_t *nv_pair = xcalloc(1, sizeof(nv_pair_t));
-    nv_pair_init(nv_pair, name, value);
-    void_list_append((void_list_t *) list, nv_pair);
+       /* freed in nv_pair_list_deinit */
+       nv_pair_t *nv_pair = xcalloc(1, sizeof(nv_pair_t));
+       nv_pair_init(nv_pair, name, value);
+       void_list_append((void_list_t *) list, nv_pair);
 
-    return nv_pair;
+       return nv_pair;
 }
 
-void nv_pair_list_push(nv_pair_list_t *list, nv_pair_t *data)
+void nv_pair_list_push(nv_pair_list_t * list, nv_pair_t * data)
 {
-    void_list_push((void_list_t *) list, data);
+       void_list_push((void_list_t *) list, data);
 }
 
-nv_pair_list_elt_t *nv_pair_list_pop(nv_pair_list_t *list)
+nv_pair_list_elt_t *nv_pair_list_pop(nv_pair_list_t * list)
 {
-    return (nv_pair_list_elt_t *) void_list_pop((void_list_t *) list);
+       return (nv_pair_list_elt_t *) void_list_pop((void_list_t *) list);
 }
 
-char *nv_pair_list_find(nv_pair_list_t *list, char *name)
+char *nv_pair_list_find(nv_pair_list_t * list, char *name)
 {
-     nv_pair_list_elt_t *iter;
-     nv_pair_t *nv_pair;
-
-     list_for_each_entry(iter, &list->head, node) {
-         nv_pair = (nv_pair_t *)iter->data;
-         if (strcmp(nv_pair->name, name) == 0) {
-              return nv_pair->value;
-         }
-     }
-     return NULL;
+       nv_pair_list_elt_t *iter;
+       nv_pair_t *nv_pair;
+
+       list_for_each_entry(iter, &list->head, node) {
+               nv_pair = (nv_pair_t *) iter->data;
+               if (strcmp(nv_pair->name, name) == 0) {
+                       return nv_pair->value;
+               }
+       }
+       return NULL;
 }
 
-nv_pair_list_elt_t *nv_pair_list_first(nv_pair_list_t *list) {
-    return (nv_pair_list_elt_t * )void_list_first((void_list_t *) list);
+nv_pair_list_elt_t *nv_pair_list_first(nv_pair_list_t * list)
+{
+       return (nv_pair_list_elt_t *) void_list_first((void_list_t *) list);
 }
 
-nv_pair_list_elt_t *nv_pair_list_prev(nv_pair_list_t *list, nv_pair_list_elt_t *node) {
-    return (nv_pair_list_elt_t * )void_list_prev((void_list_t *) list, (void_list_elt_t *)node);
+nv_pair_list_elt_t *nv_pair_list_prev(nv_pair_list_t * list,
+                                     nv_pair_list_elt_t * node)
+{
+       return (nv_pair_list_elt_t *) void_list_prev((void_list_t *) list,
+                                                    (void_list_elt_t *) node);
 }
 
-nv_pair_list_elt_t *nv_pair_list_next(nv_pair_list_t *list, nv_pair_list_elt_t *node) {
-    return (nv_pair_list_elt_t * )void_list_next((void_list_t *) list, (void_list_elt_t *)node);
+nv_pair_list_elt_t *nv_pair_list_next(nv_pair_list_t * list,
+                                     nv_pair_list_elt_t * node)
+{
+       return (nv_pair_list_elt_t *) void_list_next((void_list_t *) list,
+                                                    (void_list_elt_t *) node);
 }
 
-nv_pair_list_elt_t *nv_pair_list_last(nv_pair_list_t *list) {
-    return (nv_pair_list_elt_t * )void_list_last((void_list_t *) list);
+nv_pair_list_elt_t *nv_pair_list_last(nv_pair_list_t * list)
+{
+       return (nv_pair_list_elt_t *) void_list_last((void_list_t *) list);
 }
-
-
-
index 1223a1f..d314d7b 100644 (file)
@@ -25,24 +25,25 @@ typedef struct void_list_elt nv_pair_list_elt_t;
 
 typedef struct void_list nv_pair_list_t;
 
-static inline int nv_pair_list_empty(nv_pair_list_t *list)
+static inline int nv_pair_list_empty(nv_pair_list_t * list)
 {
-    return void_list_empty ((void_list_t *)list);
+       return void_list_empty((void_list_t *) list);
 }
 
-void nv_pair_list_init(nv_pair_list_t *list);
-void nv_pair_list_deinit(nv_pair_list_t *list);
+void nv_pair_list_init(nv_pair_list_t * list);
+void nv_pair_list_deinit(nv_pair_list_t * list);
 
-nv_pair_t *nv_pair_list_append(nv_pair_list_t *list,
+nv_pair_t *nv_pair_list_append(nv_pair_list_t * list,
                               const char *name, const char *value);
-void nv_pair_list_push(nv_pair_list_t *list, nv_pair_t *data);
-nv_pair_list_elt_t *nv_pair_list_pop(nv_pair_list_t *list);
-char *nv_pair_list_find(nv_pair_list_t *list, char *name);
+void nv_pair_list_push(nv_pair_list_t * list, nv_pair_t * data);
+nv_pair_list_elt_t *nv_pair_list_pop(nv_pair_list_t * list);
+char *nv_pair_list_find(nv_pair_list_t * list, char *name);
 
-nv_pair_list_elt_t *nv_pair_list_first(nv_pair_list_t *list);
-nv_pair_list_elt_t *nv_pair_list_prev(nv_pair_list_t *list, nv_pair_list_elt_t *node);
-nv_pair_list_elt_t *nv_pair_list_next(nv_pair_list_t *list, nv_pair_list_elt_t *node);
-nv_pair_list_elt_t *nv_pair_list_last(nv_pair_list_t *list);
+nv_pair_list_elt_t *nv_pair_list_first(nv_pair_list_t * list);
+nv_pair_list_elt_t *nv_pair_list_prev(nv_pair_list_t * list,
+                                     nv_pair_list_elt_t * node);
+nv_pair_list_elt_t *nv_pair_list_next(nv_pair_list_t * list,
+                                     nv_pair_list_elt_t * node);
+nv_pair_list_elt_t *nv_pair_list_last(nv_pair_list_t * list);
 
 #endif
-
index dbb904a..351983d 100644 (file)
@@ -43,8 +43,7 @@
 
 /** Private Functions ***/
 
-static int
-opkg_configure_packages(char *pkg_name)
+static int opkg_configure_packages(char *pkg_name)
 {
        pkg_vec_t *all;
        int i;
@@ -85,10 +84,9 @@ struct _curl_cb_data {
        int finish_range;
 };
 
-int
-curl_progress_cb(struct _curl_cb_data *cb_data, double t,      /* dltotal */
-               double d,       /* dlnow */
-               double ultotal, double ulnow)
+int curl_progress_cb(struct _curl_cb_data *cb_data, double t,  /* dltotal */
+                    double d,  /* dlnow */
+                    double ultotal, double ulnow)
 {
        int p = (t) ? d * 100 / t : 0;
        static int prev = -1;
@@ -111,12 +109,10 @@ curl_progress_cb(struct _curl_cb_data *cb_data, double t, /* dltotal */
        return 0;
 }
 
-
 static struct opkg_conf saved_conf;
 /*** Public API ***/
 
-int
-opkg_new()
+int opkg_new()
 {
        saved_conf = *conf;
 
@@ -141,8 +137,7 @@ err0:
        return -1;
 }
 
-void
-opkg_free(void)
+void opkg_free(void)
 {
 #ifdef HAVE_CURL
        opkg_curl_cleanup();
@@ -150,16 +145,14 @@ opkg_free(void)
        opkg_conf_deinit();
 }
 
-int
-opkg_re_read_config_files(void)
+int opkg_re_read_config_files(void)
 {
        opkg_free();
        *conf = saved_conf;
        return opkg_new();
 }
 
-void
-opkg_get_option(char *option, void **value)
+void opkg_get_option(char *option, void **value)
 {
        int i = 0;
        extern opkg_option_t options[];
@@ -177,22 +170,21 @@ opkg_get_option(char *option, void **value)
        /* get the option */
        switch (options[i].type) {
        case OPKG_OPT_TYPE_BOOL:
-               *((int *) value) = *((int *) options[i].value);
+               *((int *)value) = *((int *)options[i].value);
                return;
 
        case OPKG_OPT_TYPE_INT:
-               *((int *) value) = *((int *) options[i].value);
+               *((int *)value) = *((int *)options[i].value);
                return;
 
        case OPKG_OPT_TYPE_STRING:
-               *((char **) value) = xstrdup(options[i].value);
+               *((char **)value) = xstrdup(options[i].value);
                return;
        }
 
 }
 
-void
-opkg_set_option(char *option, void *value)
+void opkg_set_option(char *option, void *value)
 {
        int i = 0, found = 0;
        extern opkg_option_t options[];
@@ -219,18 +211,18 @@ opkg_set_option(char *option, void *value)
        /* set the option */
        switch (options[i].type) {
        case OPKG_OPT_TYPE_BOOL:
-               if (*((int *) value) == 0)
-                       *((int *) options[i].value) = 0;
+               if (*((int *)value) == 0)
+                       *((int *)options[i].value) = 0;
                else
-                       *((int *) options[i].value) = 1;
+                       *((int *)options[i].value) = 1;
                return;
 
        case OPKG_OPT_TYPE_INT:
-               *((int *) options[i].value) = *((int *) value);
+               *((int *)options[i].value) = *((int *)value);
                return;
 
        case OPKG_OPT_TYPE_STRING:
-               *((char **) options[i].value) = xstrdup(value);
+               *((char **)options[i].value) = xstrdup(value);
                return;
        }
 
@@ -243,8 +235,8 @@ opkg_set_option(char *option, void *value)
  */
 int
 opkg_install_package(const char *package_name,
-               opkg_progress_callback_t progress_callback,
-               void *user_data)
+                    opkg_progress_callback_t progress_callback,
+                    void *user_data)
 {
        int err;
        char *stripped_filename;
@@ -259,12 +251,11 @@ opkg_install_package(const char *package_name,
        /* ... */
        pkg_info_preinstall_check();
 
-
        /* check to ensure package is not already installed */
        old = pkg_hash_fetch_installed_by_name(package_name);
        if (old) {
                opkg_msg(ERROR, "Package %s is already installed\n",
-                               package_name);
+                        package_name);
                return -1;
        }
 
@@ -285,11 +276,11 @@ opkg_install_package(const char *package_name,
        deps = pkg_vec_alloc();
        /* this function does not return the original package, so we insert it later */
        ndepends = pkg_hash_fetch_unsatisfied_dependencies(new, deps,
-                       &unresolved);
+                                                          &unresolved);
        if (unresolved) {
                char **tmp = unresolved;
                opkg_msg(ERROR, "Couldn't satisfy the following dependencies"
-                              " for %s:\n", package_name);
+                        " for %s:\n", package_name);
                while (*tmp) {
                        opkg_msg(ERROR, "\t%s", *tmp);
                        free(*tmp);
@@ -319,7 +310,7 @@ opkg_install_package(const char *package_name,
 
                if (pkg->src == NULL) {
                        opkg_msg(ERROR, "Package %s not available from any "
-                                       "configured src\n", package_name);
+                                "configured src\n", package_name);
                        return -1;
                }
 
@@ -361,7 +352,6 @@ opkg_install_package(const char *package_name,
        }
        pkg_vec_free(all);
 
-
        /* 75% of "install" progress is for downloading */
        pdata.pkg = new;
        pdata.action = OPKG_INSTALL;
@@ -392,7 +382,7 @@ opkg_install_package(const char *package_name,
 
 int
 opkg_remove_package(const char *package_name,
-               opkg_progress_callback_t progress_callback, void *user_data)
+                   opkg_progress_callback_t progress_callback, void *user_data)
 {
        int err;
        pkg_t *pkg = NULL;
@@ -416,12 +406,12 @@ opkg_remove_package(const char *package_name,
 
        if (conf->restrict_to_default_dest) {
                pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(pkg->name,
-                                                     conf->default_dest);
+                                                                     conf->
+                                                                     default_dest);
        } else {
                pkg_to_remove = pkg_hash_fetch_installed_by_name(pkg->name);
        }
 
-
        progress(pdata, 75);
 
        err = opkg_remove_pkg(pkg_to_remove, 0);
@@ -430,15 +420,14 @@ opkg_remove_package(const char *package_name,
        opkg_conf_write_status_files();
        pkg_write_changed_filelists();
 
-
        progress(pdata, 100);
        return (err) ? -1 : 0;
 }
 
 int
 opkg_upgrade_package(const char *package_name,
-               opkg_progress_callback_t progress_callback,
-               void *user_data)
+                    opkg_progress_callback_t progress_callback,
+                    void *user_data)
 {
        int err;
        pkg_t *pkg;
@@ -529,7 +518,7 @@ opkg_upgrade_all(opkg_progress_callback_t progress_callback, void *user_data)
 
 int
 opkg_update_package_lists(opkg_progress_callback_t progress_callback,
-                       void *user_data)
+                         void *user_data)
 {
        char *tmp;
        int err, result = 0;
@@ -544,7 +533,7 @@ opkg_update_package_lists(opkg_progress_callback_t progress_callback,
        progress(pdata, 0);
 
        sprintf_alloc(&lists_dir, "%s", (conf->restrict_to_default_dest)
-               ? conf->default_dest->lists_dir : conf->lists_dir);
+                     ? conf->default_dest->lists_dir : conf->lists_dir);
 
        if (!file_is_dir(lists_dir)) {
                if (file_exists(lists_dir)) {
@@ -556,7 +545,7 @@ opkg_update_package_lists(opkg_progress_callback_t progress_callback,
                err = file_mkdir_hier(lists_dir, 0755);
                if (err) {
                        opkg_msg(ERROR, "Couldn't create lists_dir %s\n",
-                                       lists_dir);
+                                lists_dir);
                        free(lists_dir);
                        return 1;
                }
@@ -565,7 +554,7 @@ opkg_update_package_lists(opkg_progress_callback_t progress_callback,
        sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir);
        if (mkdtemp(tmp) == NULL) {
                opkg_perror(ERROR, "Coundn't create temporary directory %s",
-                               tmp);
+                           tmp);
                free(lists_dir);
                free(tmp);
                return 1;
@@ -624,15 +613,15 @@ opkg_update_package_lists(opkg_progress_callback_t progress_callback,
                        } else {
                                int err;
                                err = opkg_verify_file(list_file_name,
-                                                    sig_file_name);
+                                                      sig_file_name);
                                if (err == 0) {
                                        opkg_msg(INFO, "Signature check "
-                                                       "passed for %s",
-                                                       list_file_name);
+                                                "passed for %s",
+                                                list_file_name);
                                } else {
                                        opkg_msg(ERROR, "Signature check "
-                                                       "failed for %s",
-                                                       list_file_name);
+                                                "failed for %s",
+                                                list_file_name);
                                }
                        }
                        free(sig_file_name);
@@ -640,8 +629,8 @@ opkg_update_package_lists(opkg_progress_callback_t progress_callback,
                }
 #else
                opkg_msg(INFO, "Signature check skipped for %s as GPG support"
-                               " has not been enabled in this build\n",
-                               list_file_name);
+                        " has not been enabled in this build\n",
+                        list_file_name);
 #endif
                free(list_file_name);
 
@@ -659,8 +648,7 @@ opkg_update_package_lists(opkg_progress_callback_t progress_callback,
        return result;
 }
 
-static int
-pkg_compare_names_and_version(const void *a0, const void *b0)
+static int pkg_compare_names_and_version(const void *a0, const void *b0)
 {
        const pkg_t *a = *(const pkg_t **)a0;
        const pkg_t *b = *(const pkg_t **)b0;
@@ -674,8 +662,7 @@ pkg_compare_names_and_version(const void *a0, const void *b0)
        return ret;
 }
 
-int
-opkg_list_packages(opkg_package_callback_t callback, void *user_data)
+int opkg_list_packages(opkg_package_callback_t callback, void *user_data)
 {
        pkg_vec_t *all;
        int i;
@@ -716,7 +703,9 @@ opkg_list_upgradable_packages(opkg_package_callback_t callback, void *user_data)
        for (node = active_list_next(head, head); node;
             node = active_list_next(head, node)) {
                old = list_entry(node, pkg_t, list);
-               new = pkg_hash_fetch_best_installation_candidate_by_name(old->name);
+               new =
+                   pkg_hash_fetch_best_installation_candidate_by_name(old->
+                                                                      name);
                if (new == NULL)
                        continue;
                callback(new, user_data);
@@ -725,9 +714,8 @@ opkg_list_upgradable_packages(opkg_package_callback_t callback, void *user_data)
        return 0;
 }
 
-pkg_t *
-opkg_find_package(const char *name, const char *ver, const char *arch,
-               const char *repo)
+pkg_t *opkg_find_package(const char *name, const char *ver, const char *arch,
+                        const char *repo)
 {
        int pkg_found = 0;
        pkg_t *pkg = NULL;
@@ -780,8 +768,7 @@ opkg_find_package(const char *name, const char *ver, const char *arch,
  * @brief Check the accessibility of repositories.
  * @return return how many repositories cannot access. 0 means all okay.
  */
-int
-opkg_repository_accessibility_check(void)
+int opkg_repository_accessibility_check(void)
 {
        pkg_src_list_elt_t *iter;
        str_list_elt_t *iter1;
@@ -795,11 +782,12 @@ opkg_repository_accessibility_check(void)
        src = str_list_alloc();
 
        list_for_each_entry(iter, &conf->pkg_src_list.head, node) {
-               host = strstr(((pkg_src_t *)iter->data)->value, "://") + 3;
+               host = strstr(((pkg_src_t *) iter->data)->value, "://") + 3;
                end = index(host, '/');
                if (strstr(((pkg_src_t *) iter->data)->value, "://") && end)
                        stmp = xstrndup(((pkg_src_t *) iter->data)->value,
-                                    end - ((pkg_src_t *) iter->data)->value);
+                                       end -
+                                       ((pkg_src_t *) iter->data)->value);
                else
                        stmp = xstrdup(((pkg_src_t *) iter->data)->value);
 
index b39f7fb..9a145e7 100644 (file)
 
 typedef struct _opkg_progress_data_t opkg_progress_data_t;
 
-typedef void (*opkg_progress_callback_t) (const opkg_progress_data_t *progress, void *user_data);
-typedef void (*opkg_package_callback_t) (pkg_t *pkg, void *user_data);
-
-enum _opkg_action_t
-{
-  OPKG_INSTALL,
-  OPKG_REMOVE,
-  OPKG_DOWNLOAD
+typedef void (*opkg_progress_callback_t) (const opkg_progress_data_t * progress,
+                                         void *user_data);
+typedef void (*opkg_package_callback_t) (pkg_t * pkg, void *user_data);
+
+enum _opkg_action_t {
+       OPKG_INSTALL,
+       OPKG_REMOVE,
+       OPKG_DOWNLOAD
 };
 
-struct _opkg_progress_data_t
-{
-  int percentage;
-  int action;
-  pkg_t *pkg;
+struct _opkg_progress_data_t {
+       int percentage;
+       int action;
+       pkg_t *pkg;
 };
 
-int opkg_new (void);
-void opkg_free (void);
-int opkg_re_read_config_files (void);
-void opkg_get_option (char *option, void **value);
-void opkg_set_option (char *option, void *value);
-
-int opkg_install_package (const char *package_name, opkg_progress_callback_t callback, void *user_data);
-int opkg_remove_package (const char *package_name, opkg_progress_callback_t callback, void *user_data);
-int opkg_upgrade_package (const char *package_name, opkg_progress_callback_t callback, void *user_data);
-int opkg_upgrade_all (opkg_progress_callback_t callback, void *user_data);
-int opkg_update_package_lists (opkg_progress_callback_t callback, void *user_data);
-
-int opkg_list_packages (opkg_package_callback_t callback, void *user_data);
-int opkg_list_upgradable_packages (opkg_package_callback_t callback, void *user_data);
-pkg_t* opkg_find_package (const char *name, const char *version, const char *architecture, const char *repository);
+int opkg_new(void);
+void opkg_free(void);
+int opkg_re_read_config_files(void);
+void opkg_get_option(char *option, void **value);
+void opkg_set_option(char *option, void *value);
+
+int opkg_install_package(const char *package_name,
+                        opkg_progress_callback_t callback, void *user_data);
+int opkg_remove_package(const char *package_name,
+                       opkg_progress_callback_t callback, void *user_data);
+int opkg_upgrade_package(const char *package_name,
+                        opkg_progress_callback_t callback, void *user_data);
+int opkg_upgrade_all(opkg_progress_callback_t callback, void *user_data);
+int opkg_update_package_lists(opkg_progress_callback_t callback,
+                             void *user_data);
+
+int opkg_list_packages(opkg_package_callback_t callback, void *user_data);
+int opkg_list_upgradable_packages(opkg_package_callback_t callback,
+                                 void *user_data);
+pkg_t *opkg_find_package(const char *name, const char *version,
+                        const char *architecture, const char *repository);
 
 int opkg_repository_accessibility_check(void);
 
index d2adc31..d03e27c 100644 (file)
@@ -43,8 +43,7 @@
 #include "opkg_configure.h"
 #include "xsystem.h"
 
-static void
-print_pkg(pkg_t *pkg)
+static void print_pkg(pkg_t * pkg)
 {
        char *version = pkg_version_str_alloc(pkg);
        printf("%s - %s", pkg->name, version);
@@ -58,210 +57,218 @@ print_pkg(pkg_t *pkg)
 
 int opkg_state_changed;
 
-static void
-write_status_files_if_changed(void)
+static void write_status_files_if_changed(void)
 {
-     if (opkg_state_changed && !conf->noaction) {
-         opkg_msg(INFO, "Writing status file.\n");
-         opkg_conf_write_status_files();
-         pkg_write_changed_filelists();
-     } else {
-         opkg_msg(DEBUG, "Nothing to be done.\n");
-     }
+       if (opkg_state_changed && !conf->noaction) {
+               opkg_msg(INFO, "Writing status file.\n");
+               opkg_conf_write_status_files();
+               pkg_write_changed_filelists();
+       } else {
+               opkg_msg(DEBUG, "Nothing to be done.\n");
+       }
 }
 
-static void
-sigint_handler(int sig)
+static void sigint_handler(int sig)
 {
-     signal(sig, SIG_DFL);
-     opkg_msg(NOTICE, "Interrupted. Writing out status database.\n");
-     write_status_files_if_changed();
-     exit(128 + sig);
+       signal(sig, SIG_DFL);
+       opkg_msg(NOTICE, "Interrupted. Writing out status database.\n");
+       write_status_files_if_changed();
+       exit(128 + sig);
 }
 
-static int
-opkg_update_cmd(int argc, char **argv)
+static int opkg_update_cmd(int argc, char **argv)
 {
-     char *tmp;
-     int err;
-     int failures;
-     int pkglist_dl_error;
-     char *lists_dir;
-     pkg_src_list_elt_t *iter;
-     pkg_src_t *src;
-
-
-    sprintf_alloc(&lists_dir, "%s", conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir);
-
-    if (! file_is_dir(lists_dir)) {
-         if (file_exists(lists_dir)) {
-              opkg_msg(ERROR, "%s exists, but is not a directory.\n",
-                           lists_dir);
-              free(lists_dir);
-              return -1;
-         }
-         err = file_mkdir_hier(lists_dir, 0755);
-         if (err) {
-              free(lists_dir);
-              return -1;
-         }
-     }
-
-     failures = 0;
-
-     sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir);
-     if (mkdtemp (tmp) == NULL) {
-        opkg_perror(ERROR, "Failed to make temp dir %s", conf->tmp_dir);
-        return -1;
-     }
-
-
-     for (iter = void_list_first(&conf->pkg_src_list); iter; iter = void_list_next(&conf->pkg_src_list, iter)) {
-         char *url, *list_file_name;
-
-         src = (pkg_src_t *)iter->data;
-
-         if (src->extra_data && strcmp(src->extra_data, "__dummy__ "))
-             continue;
-
-         if (src->extra_data)  /* debian style? */
-             sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
-                           src->gzip ? "Packages.gz" : "Packages");
-         else
-             sprintf_alloc(&url, "%s/%s", src->value, src->gzip ? "Packages.gz" : "Packages");
-
-         sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
-         pkglist_dl_error = 0;
-         if (opkg_download(url, list_file_name, NULL, NULL, 0)) {
-              failures++;
-              pkglist_dl_error = 1;
-              opkg_msg(NOTICE, "*** Failed to download the package list from %s\n\n",
-                           url);
-         } else {
-              opkg_msg(NOTICE, "Updated list of available packages in %s\n",
-                           list_file_name);
-         }
-         free(url);
+       char *tmp;
+       int err;
+       int failures;
+       int pkglist_dl_error;
+       char *lists_dir;
+       pkg_src_list_elt_t *iter;
+       pkg_src_t *src;
+
+       sprintf_alloc(&lists_dir, "%s",
+                     conf->restrict_to_default_dest ? conf->default_dest->
+                     lists_dir : conf->lists_dir);
+
+       if (!file_is_dir(lists_dir)) {
+               if (file_exists(lists_dir)) {
+                       opkg_msg(ERROR, "%s exists, but is not a directory.\n",
+                                lists_dir);
+                       free(lists_dir);
+                       return -1;
+               }
+               err = file_mkdir_hier(lists_dir, 0755);
+               if (err) {
+                       free(lists_dir);
+                       return -1;
+               }
+       }
+
+       failures = 0;
+
+       sprintf_alloc(&tmp, "%s/update-XXXXXX", conf->tmp_dir);
+       if (mkdtemp(tmp) == NULL) {
+               opkg_perror(ERROR, "Failed to make temp dir %s", conf->tmp_dir);
+               return -1;
+       }
+
+       for (iter = void_list_first(&conf->pkg_src_list); iter;
+            iter = void_list_next(&conf->pkg_src_list, iter)) {
+               char *url, *list_file_name;
+
+               src = (pkg_src_t *) iter->data;
+
+               if (src->extra_data && strcmp(src->extra_data, "__dummy__ "))
+                       continue;
+
+               if (src->extra_data)    /* debian style? */
+                       sprintf_alloc(&url, "%s/%s/%s", src->value,
+                                     src->extra_data,
+                                     src->gzip ? "Packages.gz" : "Packages");
+               else
+                       sprintf_alloc(&url, "%s/%s", src->value,
+                                     src->gzip ? "Packages.gz" : "Packages");
+
+               sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
+               pkglist_dl_error = 0;
+               if (opkg_download(url, list_file_name, NULL, NULL, 0)) {
+                       failures++;
+                       pkglist_dl_error = 1;
+                       opkg_msg(NOTICE,
+                                "*** Failed to download the package list from %s\n\n",
+                                url);
+               } else {
+                       opkg_msg(NOTICE,
+                                "Updated list of available packages in %s\n",
+                                list_file_name);
+               }
+               free(url);
 #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL) || defined(HAVE_USIGN)
-          if (pkglist_dl_error == 0 && conf->check_signature) {
-              /* download detached signitures to verify the package lists */
-              /* get the url for the sig file */
-              if (src->extra_data)     /* debian style? */
-                  sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
-                          "Packages.sig");
-              else
-                  sprintf_alloc(&url, "%s/%s", src->value, "Packages.sig");
-
-              /* create temporary file for it */
-              char *tmp_file_name;
-
-              /* Put the signature in the right place */
-              sprintf_alloc (&tmp_file_name, "%s/%s.sig", lists_dir, src->name);
-
-              err = opkg_download(url, tmp_file_name, NULL, NULL, 0);
-              if (err) {
-                  failures++;
-                  opkg_msg(NOTICE, "Signature file download failed.\n");
-              } else {
-                  err = opkg_verify_file (list_file_name, tmp_file_name);
-                  if (err == 0)
-                      opkg_msg(NOTICE, "Signature check passed.\n");
-                  else
-                      opkg_msg(NOTICE, "Signature check failed.\n");
-              }
-              if (err && !conf->force_signature) {
-                  /* The signature was wrong so delete it */
-                  opkg_msg(NOTICE, "Remove wrong Signature file.\n");
-                  unlink (tmp_file_name);
-                  unlink (list_file_name);
-              }
-              /* We shouldn't unlink the signature ! */
-              // unlink (tmp_file_name);
-              free (tmp_file_name);
-              free (url);
-          }
+               if (pkglist_dl_error == 0 && conf->check_signature) {
+                       /* download detached signitures to verify the package lists */
+                       /* get the url for the sig file */
+                       if (src->extra_data)    /* debian style? */
+                               sprintf_alloc(&url, "%s/%s/%s", src->value,
+                                             src->extra_data, "Packages.sig");
+                       else
+                               sprintf_alloc(&url, "%s/%s", src->value,
+                                             "Packages.sig");
+
+                       /* create temporary file for it */
+                       char *tmp_file_name;
+
+                       /* Put the signature in the right place */
+                       sprintf_alloc(&tmp_file_name, "%s/%s.sig", lists_dir,
+                                     src->name);
+
+                       err = opkg_download(url, tmp_file_name, NULL, NULL, 0);
+                       if (err) {
+                               failures++;
+                               opkg_msg(NOTICE,
+                                        "Signature file download failed.\n");
+                       } else {
+                               err =
+                                   opkg_verify_file(list_file_name,
+                                                    tmp_file_name);
+                               if (err == 0)
+                                       opkg_msg(NOTICE,
+                                                "Signature check passed.\n");
+                               else
+                                       opkg_msg(NOTICE,
+                                                "Signature check failed.\n");
+                       }
+                       if (err && !conf->force_signature) {
+                               /* The signature was wrong so delete it */
+                               opkg_msg(NOTICE,
+                                        "Remove wrong Signature file.\n");
+                               unlink(tmp_file_name);
+                               unlink(list_file_name);
+                       }
+                       /* We shouldn't unlink the signature ! */
+                       // unlink (tmp_file_name);
+                       free(tmp_file_name);
+                       free(url);
+               }
 #else
-          // Do nothing
+               // Do nothing
 #endif
-         free(list_file_name);
-     }
-     rmdir (tmp);
-     free (tmp);
-     free(lists_dir);
+               free(list_file_name);
+       }
+       rmdir(tmp);
+       free(tmp);
+       free(lists_dir);
 
-     return failures;
+       return failures;
 }
 
-
-struct opkg_intercept
-{
-    char *oldpath;
-    char *statedir;
+struct opkg_intercept {
+       char *oldpath;
+       char *statedir;
 };
 
 typedef struct opkg_intercept *opkg_intercept_t;
 
-static opkg_intercept_t
-opkg_prep_intercepts(void)
+static opkg_intercept_t opkg_prep_intercepts(void)
 {
-    opkg_intercept_t ctx;
-    char *newpath;
+       opkg_intercept_t ctx;
+       char *newpath;
+
+       ctx = xcalloc(1, sizeof(*ctx));
+       ctx->oldpath = xstrdup(getenv("PATH"));
+       sprintf_alloc(&newpath, "%s/opkg/intercept:%s", DATADIR, ctx->oldpath);
+       sprintf_alloc(&ctx->statedir, "%s/opkg-intercept-XXXXXX",
+                     conf->tmp_dir);
+
+       if (mkdtemp(ctx->statedir) == NULL) {
+               opkg_perror(ERROR, "Failed to make temp dir %s", ctx->statedir);
+               free(ctx->oldpath);
+               free(ctx->statedir);
+               free(newpath);
+               free(ctx);
+               return NULL;
+       }
+
+       setenv("OPKG_INTERCEPT_DIR", ctx->statedir, 1);
+       setenv("PATH", newpath, 1);
+       free(newpath);
 
-    ctx = xcalloc(1, sizeof (*ctx));
-    ctx->oldpath = xstrdup(getenv("PATH"));
-    sprintf_alloc(&newpath, "%s/opkg/intercept:%s", DATADIR, ctx->oldpath);
-    sprintf_alloc(&ctx->statedir, "%s/opkg-intercept-XXXXXX", conf->tmp_dir);
+       return ctx;
+}
+
+static int opkg_finalize_intercepts(opkg_intercept_t ctx)
+{
+       DIR *dir;
+       int err = 0;
 
-    if (mkdtemp(ctx->statedir) == NULL) {
-        opkg_perror(ERROR,"Failed to make temp dir %s", ctx->statedir);
+       setenv("PATH", ctx->oldpath, 1);
        free(ctx->oldpath);
-       free(ctx->statedir);
-        free(newpath);
-       free(ctx);
-       return NULL;
-    }
 
-    setenv("OPKG_INTERCEPT_DIR", ctx->statedir, 1);
-    setenv("PATH", newpath, 1);
-    free(newpath);
+       dir = opendir(ctx->statedir);
+       if (dir) {
+               struct dirent *de;
+               while (de = readdir(dir), de != NULL) {
+                       char *path;
 
-    return ctx;
-}
+                       if (de->d_name[0] == '.')
+                               continue;
 
-static int
-opkg_finalize_intercepts(opkg_intercept_t ctx)
-{
-    DIR *dir;
-    int err = 0;
-
-    setenv ("PATH", ctx->oldpath, 1);
-    free (ctx->oldpath);
-
-    dir = opendir (ctx->statedir);
-    if (dir) {
-       struct dirent *de;
-       while (de = readdir (dir), de != NULL) {
-           char *path;
-
-           if (de->d_name[0] == '.')
-               continue;
-
-           sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
-           if (access (path, X_OK) == 0) {
-               const char *argv[] = {"sh", "-c", path, NULL};
-               xsystem (argv);
-           }
-           free (path);
-       }
-        closedir(dir);
-    } else
-       opkg_perror(ERROR, "Failed to open dir %s", ctx->statedir);
+                       sprintf_alloc(&path, "%s/%s", ctx->statedir,
+                                     de->d_name);
+                       if (access(path, X_OK) == 0) {
+                               const char *argv[] = { "sh", "-c", path, NULL };
+                               xsystem(argv);
+                       }
+                       free(path);
+               }
+               closedir(dir);
+       } else
+               opkg_perror(ERROR, "Failed to open dir %s", ctx->statedir);
 
-    rm_r(ctx->statedir);
-    free (ctx->statedir);
-    free (ctx);
+       rm_r(ctx->statedir);
+       free(ctx->statedir);
+       free(ctx);
 
-    return err;
+       return err;
 }
 
 /* For package pkg do the following: If it is already visited, return. If not,
@@ -273,454 +280,461 @@ opkg_finalize_intercepts(opkg_intercept_t ctx)
    pkg_vec ordered will finally contain the ordered set of packages.
 */
 static int
-opkg_recurse_pkgs_in_order(pkg_t *pkg, pkg_vec_t *all,
-                               pkg_vec_t *visited, pkg_vec_t *ordered)
+opkg_recurse_pkgs_in_order(pkg_t * pkg, pkg_vec_t * all,
+                          pkg_vec_t * visited, pkg_vec_t * ordered)
 {
-    int j,k,l,m;
-    int count;
-    pkg_t *dep;
-    compound_depend_t * compound_depend;
-    depend_t ** possible_satisfiers;
-    abstract_pkg_t *abpkg;
-    abstract_pkg_t **dependents;
-
-    /* If it's just an available package, that is, not installed and not even
-       unpacked, skip it */
-    /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED
-       would do here. However, if there is an intermediate node (pkg) that is
-       configured and installed between two unpacked packages, the latter
-       won't be properly reordered, unless all installed/unpacked pkgs are
-       checked */
-    if (pkg->state_status == SS_NOT_INSTALLED)
-        return 0;
-
-    /* If the  package has already been visited (by this function), skip it */
-    for(j = 0; j < visited->len; j++)
-        if ( ! strcmp(visited->pkgs[j]->name, pkg->name)) {
-            opkg_msg(DEBUG, "pkg %s already visited, skipping.\n", pkg->name);
-            return 0;
-        }
-
-    pkg_vec_insert(visited, pkg);
-
-    count = pkg->pre_depends_count + pkg->depends_count + \
-        pkg->recommends_count + pkg->suggests_count;
-
-    opkg_msg(DEBUG, "pkg %s.\n", pkg->name);
-
-    /* Iterate over all the dependencies of pkg. For each one, find a package
-       that is either installed or unpacked and satisfies this dependency.
-       (there should only be one such package per dependency installed or
-       unpacked). Then recurse to the dependency package */
-    for (j=0; j < count ; j++) {
-        compound_depend = &pkg->depends[j];
-        possible_satisfiers = compound_depend->possibilities;
-        for (k=0; k < compound_depend->possibility_count ; k++) {
-            abpkg = possible_satisfiers[k]->pkg;
-            dependents = abpkg->provided_by->pkgs;
-            l = 0;
-            if (dependents != NULL)
-                while (l < abpkg->provided_by->len && dependents[l] != NULL) {
-                    opkg_msg(DEBUG, "Descending on pkg %s.\n",
-                                 dependents [l]->name);
-
-                    /* find whether dependent l is installed or unpacked,
-                     * and then find which package in the list satisfies it */
-                    for(m = 0; m < all->len; m++) {
-                        dep = all->pkgs[m];
-                        if ( dep->state_status != SS_NOT_INSTALLED)
-                            if ( ! strcmp(dep->name, dependents[l]->name)) {
-                                opkg_recurse_pkgs_in_order(dep, all,
-                                                           visited, ordered);
-                                /* Stop the outer loop */
-                                l = abpkg->provided_by->len;
-                                /* break from the inner loop */
-                                break;
-                            }
-                    }
-                    l++;
-                }
-        }
-    }
-
-    /* When all recursions from this node down, are over, and all
-       dependencies have been added in proper order in the ordered array, add
-       also the package pkg to ordered array */
-    pkg_vec_insert(ordered, pkg);
-
-    return 0;
+       int j, k, l, m;
+       int count;
+       pkg_t *dep;
+       compound_depend_t *compound_depend;
+       depend_t **possible_satisfiers;
+       abstract_pkg_t *abpkg;
+       abstract_pkg_t **dependents;
+
+       /* If it's just an available package, that is, not installed and not even
+          unpacked, skip it */
+       /*&nb