Changeset 42c4de8 in rtems


Ignore:
Timestamp:
Feb 1, 2010, 12:03:02 AM (10 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
33369234
Parents:
1027f153
Message:

2010-02-01 Chris Johns <chrisj@…>

  • libmisc/shell/fts.c: Updated to the latest NetBSD version to resolve heap allocation bugs.
  • libmisc/shell/main_ls.c, libmisc/shell/print-ls.c: Fix printing size bugs.
  • libnetworking/rtems/mkrootfs.c: Fix byte order bug when creating the loopback interface address.
Location:
cpukit
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • cpukit/ChangeLog

    r1027f153 r42c4de8  
     12010-02-01      Chris Johns <chrisj@rtems.org>
     2
     3        * libmisc/shell/fts.c: Updated to the latest NetBSD version to
     4        resolve heap allocation bugs.
     5        * libmisc/shell/main_ls.c, libmisc/shell/print-ls.c: Fix printing
     6        size bugs.
     7        * libnetworking/rtems/mkrootfs.c: Fix byte order bug when creating
     8        the loopback interface address.
     9       
    1102010-01-28      Sebastian Huber <sebastian.huber@embedded-brains.de>
    211        * libblock/src/bdbuf.c: Fixed invalid chain extract.
  • cpukit/libmisc/shell/fts.c

    r1027f153 r42c4de8  
    1 /*      $NetBSD: fts.c,v 1.26 2005/10/22 20:55:13 christos Exp $        */
     1/*      $NetBSD: fts.c,v 1.40 2009/11/02 17:17:34 stacktic Exp $        */
    22
    33/*-
     
    3030 */
    3131
    32 #ifdef HAVE_CONFIG_H
    33 #include "config.h"
    34 #endif
    35 
    3632#if HAVE_NBTOOL_CONFIG_H
    3733#include "nbtool_config.h"
     
    4339static char sccsid[] = "@(#)fts.c       8.6 (Berkeley) 8/14/94";
    4440#else
    45 __RCSID("$NetBSD: fts.c,v 1.26 2005/10/22 20:55:13 christos Exp $");
     41__RCSID("$NetBSD: fts.c,v 1.40 2009/11/02 17:17:34 stacktic Exp $");
    4642#endif
    4743#endif /* LIBC_SCCS and not lint */
    4844
     45#ifndef __rtems__
     46#include "namespace.h"
     47#endif
    4948#include <sys/param.h>
    5049#include <sys/stat.h>
     
    6463
    6564#if ! HAVE_NBTOOL_CONFIG_H
    66 #define HAVE_STRUCT_DIRENT_D_NAMLEN 1
    67 #endif
    68 
    69 static FTSENT   *fts_alloc __P((FTS *, const char *, size_t));
    70 static FTSENT   *fts_build __P((FTS *, int));
    71 static void      fts_lfree __P((FTSENT *));
    72 static void      fts_load __P((FTS *, FTSENT *));
    73 static size_t    fts_maxarglen __P((char * const *));
    74 static size_t    fts_pow2 __P((size_t));
    75 static int       fts_palloc __P((FTS *, size_t));
    76 static void      fts_padjust __P((FTS *, FTSENT *));
    77 static FTSENT   *fts_sort __P((FTS *, FTSENT *, size_t));
    78 static u_short   fts_stat __P((FTS *, FTSENT *, int));
    79 static int       fts_safe_changedir __P((const FTS *, const FTSENT *, int,
    80     const char *));
     65#define HAVE_STRUCT_DIRENT_D_NAMLEN
     66#endif
     67
     68static FTSENT   *fts_alloc(FTS *, const char *, size_t);
     69static FTSENT   *fts_build(FTS *, int);
     70static void      fts_free(FTSENT *);
     71static void      fts_lfree(FTSENT *);
     72static void      fts_load(FTS *, FTSENT *);
     73static size_t    fts_maxarglen(char * const *);
     74static size_t    fts_pow2(size_t);
     75static int       fts_palloc(FTS *, size_t);
     76static void      fts_padjust(FTS *, FTSENT *);
     77static FTSENT   *fts_sort(FTS *, FTSENT *, size_t);
     78static unsigned short fts_stat(FTS *, FTSENT *, int);
     79static int       fts_safe_changedir(const FTS *, const FTSENT *, int,
     80    const char *);
     81
     82#if defined(ALIGNBYTES) && defined(ALIGN)
     83#define FTS_ALLOC_ALIGNED       1
     84#else
     85#undef  FTS_ALLOC_ALIGNED
     86#endif
    8187
    8288#define ISDOT(a)        (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
     
    99105
    100106FTS *
    101 fts_open(
    102         char * const *argv,
    103         int options,
    104         int (*compar) (const FTSENT **, const FTSENT **) )
     107fts_open(char * const *argv, int options,
     108    int (*compar)(const FTSENT **, const FTSENT **))
    105109{
    106110        FTS *sp;
     
    119123
    120124        /* Allocate/initialize the stream */
    121         if ((sp = malloc((u_int)sizeof(FTS))) == NULL)
     125        if ((sp = malloc((unsigned int)sizeof(FTS))) == NULL)
    122126                return (NULL);
    123127        memset(sp, 0, sizeof(FTS));
     
    205209                }
    206210        }
    207         free(parent);
     211
     212        if (nitems == 0)
     213                fts_free(parent);
     214
    208215        return (sp);
    209216
    210217mem3:   fts_lfree(root);
    211         free(parent);
     218        fts_free(parent);
    212219mem2:   free(sp->fts_path);
    213220mem1:   free(sp);
     
    216223
    217224static void
    218 fts_load(
    219         FTS *sp,
    220         FTSENT *p)
     225fts_load(FTS *sp, FTSENT *p)
    221226{
    222227        size_t len;
     
    245250
    246251int
    247 fts_close(
    248         FTS *sp)
     252fts_close(FTS *sp)
    249253{
    250254        FTSENT *freep, *p;
     
    259263         */
    260264        if (sp->fts_cur) {
    261                 if (ISSET(FTS_SYMFOLLOW))
     265                if (sp->fts_cur->fts_flags & FTS_SYMFOLLOW)
    262266                        (void)close(sp->fts_cur->fts_symfd);
    263267                for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
    264268                        freep = p;
    265269                        p = p->fts_link ? p->fts_link : p->fts_parent;
    266                         free(freep);
    267                 }
    268                 free(p);
     270                        fts_free(freep);
     271                }
     272                fts_free(p);
    269273        }
    270274
     
    278282        /* Return to original directory, save errno if necessary. */
    279283        if (!ISSET(FTS_NOCHDIR)) {
    280                 if (fchdir(sp->fts_rfd))
     284                if (fchdir(sp->fts_rfd) == -1)
    281285                        saved_errno = errno;
    282286                (void)close(sp->fts_rfd);
     
    285289        /* Free up the stream pointer. */
    286290        free(sp);
    287         /* ISSET() is illegal after this, since the macro touches sp */
    288 
    289         /* Set errno and return. */
    290291        if (saved_errno) {
    291292                errno = saved_errno;
    292                 return (-1);
    293         }
    294         return (0);
    295 }
     293                return -1;
     294        }
     295
     296        return 0;
     297}
     298
     299#if !defined(__FTS_COMPAT_TAILINGSLASH)
    296300
    297301/*
     
    303307            ? p->fts_pathlen - 1 : p->fts_pathlen)
    304308
     309#else /* !defined(__FTS_COMPAT_TAILINGSLASH) */
     310
     311/*
     312 * compatibility with the old behaviour.
     313 *
     314 * Special case a root of "/" so that slashes aren't appended which would
     315 * cause paths to be written as "//foo".
     316 */
     317
     318#define NAPPEND(p)                                                      \
     319        (p->fts_level == FTS_ROOTLEVEL && p->fts_pathlen == 1 &&        \
     320            p->fts_path[0] == '/' ? 0 : p->fts_pathlen)
     321
     322#endif /* !defined(__FTS_COMPAT_TAILINGSLASH) */
     323
    305324FTSENT *
    306 fts_read(
    307         FTS *sp )
     325fts_read(FTS *sp)
    308326{
    309327        FTSENT *p, *tmp;
     
    409427next:   tmp = p;
    410428        if ((p = p->fts_link) != NULL) {
    411                 free(tmp);
     429                fts_free(tmp);
    412430
    413431                /*
     
    456474        /* Move up to the parent node. */
    457475        p = tmp->fts_parent;
    458         free(tmp);
     476        fts_free(tmp);
    459477
    460478        if (p->fts_level == FTS_ROOTPARENTLEVEL) {
     
    463481                 * can distinguish between error and EOF.
    464482                 */
    465                 free(p);
     483                fts_free(p);
    466484                errno = 0;
    467485                return (sp->fts_cur = NULL);
     
    507525/* ARGSUSED */
    508526int
    509 fts_set(
    510         FTS *sp __attribute__((unused)),
    511         FTSENT *p,
    512         int instr)
     527fts_set(FTS *sp, FTSENT *p, int instr)
    513528{
    514529
     
    526541
    527542FTSENT *
    528 fts_children(
    529         FTS *sp,
    530         int instr )
     543fts_children(FTS *sp, int instr)
    531544{
    532545        FTSENT *p;
     
    612625 */
    613626static FTSENT *
    614 fts_build(
    615         FTS *sp,
    616         int type)
     627fts_build(FTS *sp, int type)
    617628{
    618629        struct dirent *dp;
     
    621632        FTSENT *cur, *tail;
    622633        DIR *dirp;
    623         int adjust, cderrno, descend, len, level, nlinks, saved_errno, nostat;
    624         size_t maxlen;
     634        void *oldaddr;
     635        size_t dnamlen;
     636        int cderrno, descend, level, nlinks, saved_errno, nostat, doadjust;
     637        size_t len, maxlen;
    625638#ifdef FTS_WHITEOUT
    626639        int oflag;
     
    643656                oflag = DTF_HIDEW|DTF_NODUP|DTF_REWIND;
    644657#else
    645 #define __opendir2(path, flag) opendir(path)
     658#define __opendir2(path, flag) opendir(path)
    646659#endif
    647660        if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
     
    720733        maxlen = sp->fts_pathlen - len;
    721734
     735#if defined(__FTS_COMPAT_LEVEL)
     736        if (cur->fts_level == SHRT_MAX) {
     737                (void)closedir(dirp);
     738                cur->fts_info = FTS_ERR;
     739                SET(FTS_STOP);
     740                errno = ENAMETOOLONG;
     741                return (NULL);
     742        }
     743#endif
     744
    722745        level = cur->fts_level + 1;
    723746
    724747        /* Read the directory, attaching each entry to the `link' pointer. */
    725         adjust = 0;
     748        doadjust = 0;
    726749        for (head = tail = NULL, nitems = 0; (dp = readdir(dirp)) != NULL;) {
    727                 size_t dlen;
    728750
    729751                if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
    730752                        continue;
    731753
    732 #if HAVE_STRUCT_DIRENT_D_NAMLEN
    733                 dlen = dp->d_namlen;
     754#if defined(HAVE_STRUCT_DIRENT_D_NAMLEN)
     755                dnamlen = dp->d_namlen;
    734756#else
    735                 dlen = strlen(dp->d_name);
    736 #endif
    737                 if ((p = fts_alloc(sp, dp->d_name, dlen)) == NULL)
     757                dnamlen = strlen(dp->d_name);
     758#endif
     759                if ((p = fts_alloc(sp, dp->d_name, dnamlen)) == NULL)
    738760                        goto mem1;
    739                 if (dlen >= maxlen) {   /* include space for NUL */
    740                         if (fts_palloc(sp, len + dlen + 1)) {
     761                if (dnamlen >= maxlen) {        /* include space for NUL */
     762                        oldaddr = sp->fts_path;
     763                        if (fts_palloc(sp, dnamlen + len + 1)) {
    741764                                /*
    742765                                 * No more memory for path or structures.  Save
     
    746769mem1:                           saved_errno = errno;
    747770                                if (p)
    748                                         free(p);
     771                                        fts_free(p);
    749772                                fts_lfree(head);
    750773                                (void)closedir(dirp);
     
    754777                                return (NULL);
    755778                        }
    756                         adjust = 1;
    757                         if (ISSET(FTS_NOCHDIR))
    758                                 cp = sp->fts_path + len;
     779                        /* Did realloc() change the pointer? */
     780                        if (oldaddr != sp->fts_path) {
     781                                doadjust = 1;
     782                                if (ISSET(FTS_NOCHDIR))
     783                                        cp = sp->fts_path + len;
     784                        }
    759785                        maxlen = sp->fts_pathlen - len;
    760786                }
    761787
    762                 p->fts_pathlen = len + dlen;
     788#if defined(__FTS_COMPAT_LENGTH)
     789                if (len + dnamlen >= USHRT_MAX) {
     790                        /*
     791                         * In an FTSENT, fts_pathlen is an unsigned short
     792                         * so it is possible to wraparound here.
     793                         * If we do, free up the current structure and the
     794                         * structures already allocated, then error out
     795                         * with ENAMETOOLONG.
     796                         */
     797                        fts_free(p);
     798                        fts_lfree(head);
     799                        (void)closedir(dirp);
     800                        cur->fts_info = FTS_ERR;
     801                        SET(FTS_STOP);
     802                        errno = ENAMETOOLONG;
     803                        return (NULL);
     804                }
     805#endif
     806                p->fts_level = level;
     807                p->fts_pathlen = len + dnamlen;
    763808                p->fts_parent = sp->fts_cur;
    764                 p->fts_level = level;
    765809
    766810#ifdef FTS_WHITEOUT
     
    775819                        } /* else
    776820                                p->fts_info = FTS_NSOK;
    777                           */
    778                           /* Coverity Scan Id 1 says above is dead code */
     821                                */
     822                                /* Coverity Scan Id 1 says above is dead code */
    779823                        p->fts_accpath = cur->fts_accpath;
    780824                } else if (nlinks == 0
     
    820864         * of the tree.
    821865         */
    822         if (adjust)
     866        if (doadjust)
    823867                fts_padjust(sp, head);
    824868
     
    828872         */
    829873        if (ISSET(FTS_NOCHDIR)) {
    830                 if (cp - 1 > sp->fts_path)
     874                if (len == sp->fts_pathlen || nitems == 0)
    831875                        --cp;
    832876                *cp = '\0';
     
    862906}
    863907
    864 static u_short
    865 fts_stat(
    866         FTS *sp,
    867         FTSENT *p,
    868         int follow )
     908static unsigned short
     909fts_stat(FTS *sp, FTSENT *p, int follow)
    869910{
    870911        FTSENT *t;
     
    949990
    950991static FTSENT *
    951 fts_sort(
    952         FTS *sp,
    953         FTSENT *head,
    954         size_t nitems )
     992fts_sort(FTS *sp, FTSENT *head, size_t nitems)
    955993{
    956994        FTSENT **ap, *p;
     
    9781016                *ap++ = p;
    9791017        qsort((void *)sp->fts_array, nitems, sizeof(FTSENT *),
    980                 (int (*) __P((const void *, const void *)))sp->fts_compar);
     1018                (int (*)(const void *, const void *))sp->fts_compar);
    9811019        for (head = *(ap = sp->fts_array); --nitems; ++ap)
    9821020                ap[0]->fts_link = ap[1];
     
    9861024
    9871025static FTSENT *
    988 fts_alloc(
    989         FTS *sp,
    990         const char *name,
    991         size_t namelen )
     1026fts_alloc(FTS *sp, const char *name, size_t namelen)
    9921027{
    9931028        FTSENT *p;
     1029#if defined(FTS_ALLOC_ALIGNED)
    9941030        size_t len;
     1031#endif
    9951032
    9961033        _DIAGASSERT(sp != NULL);
    9971034        _DIAGASSERT(name != NULL);
    9981035
    999 #if defined(ALIGNBYTES) && defined(ALIGN)
     1036#if defined(FTS_ALLOC_ALIGNED)
    10001037        /*
    10011038         * The file name is a variable length array and no stat structure is
     
    10131050
    10141051        if (!ISSET(FTS_NOSTAT))
    1015                 p->fts_statp =
    1016                     (__fts_stat_t *)ALIGN((u_long)(p->fts_name + namelen + 2));
     1052                p->fts_statp = (__fts_stat_t *)ALIGN(
     1053                    (unsigned long)(p->fts_name + namelen + 2));
    10171054#else
    10181055        if ((p = malloc(sizeof(FTSENT) + namelen)) == NULL)
     
    10251062                }
    10261063#endif
     1064
     1065        if (ISSET(FTS_NOSTAT))
     1066                p->fts_statp = NULL;
    10271067
    10281068        /* Copy the name plus the trailing NULL. */
     
    10401080
    10411081static void
    1042 fts_lfree(
    1043         FTSENT *head )
     1082fts_free(FTSENT *p)
     1083{
     1084#if !defined(FTS_ALLOC_ALIGNED)
     1085        if (p->fts_statp)
     1086                free(p->fts_statp);
     1087#endif
     1088        free(p);
     1089}
     1090
     1091static void
     1092fts_lfree(FTSENT *head)
    10441093{
    10451094        FTSENT *p;
     
    10501099        while ((p = head) != NULL) {
    10511100                head = head->fts_link;
    1052 
    1053 #if !defined(ALIGNBYTES) || !defined(ALIGN)
    1054                 if (p->fts_statp)
    1055                         free(p->fts_statp);
    1056 #endif
    1057                 free(p);
     1101                fts_free(p);
    10581102        }
    10591103}
    10601104
    10611105static size_t
    1062 fts_pow2(
    1063         size_t x )
     1106fts_pow2(size_t x)
    10641107{
    10651108
     
    10871130 */
    10881131static int
    1089 fts_palloc(
    1090         FTS *sp,
    1091         size_t size )
     1132fts_palloc(FTS *sp, size_t size)
    10921133{
    10931134        char *new;
     
    10951136        _DIAGASSERT(sp != NULL);
    10961137
    1097 #if 1
     1138#ifdef __FTS_COMPAT_LENGTH
    10981139        /* Protect against fts_pathlen overflow. */
    10991140        if (size > USHRT_MAX + 1) {
    1100                 errno = ENOMEM;
     1141                errno = ENAMETOOLONG;
    11011142                return (1);
    11021143        }
     
    11161157 */
    11171158static void
    1118 fts_padjust(
    1119         FTS *sp,
    1120         FTSENT *head )
     1159fts_padjust(FTS *sp, FTSENT *head)
    11211160{
    11221161        FTSENT *p;
     
    11461185
    11471186static size_t
    1148 fts_maxarglen(
    1149         char * const *argv )
     1187fts_maxarglen(char * const *argv)
    11501188{
    11511189        size_t len, max;
     
    11651203 */
    11661204static int
    1167 fts_safe_changedir(
    1168         const FTS *sp,
    1169         const FTSENT *p,
    1170         int fd,
    1171         const char *path)
     1205fts_safe_changedir(const FTS *sp, const FTSENT *p, int fd, const char *path)
    11721206{
    11731207        int oldfd = fd, ret = -1;
  • cpukit/libmisc/shell/main_ls.c

    r1027f153 r42c4de8  
    361361                        (void)getbsize(NULL, &blocksize);
    362362#else
    363         blocksize = 1024;
     363        /* Make equal to 1 so ls -l shows the actual blcok count */
     364        blocksize = 512;
    364365#endif
    365366                blocksize /= 512;
     
    543544        maxmajor = maxminor = 0;
    544545        for (cur = list, entries = 0; cur; cur = cur->fts_link) {
     546    uint64_t size;
    545547                if (cur->fts_info == FTS_ERR || cur->fts_info == FTS_NS) {
    546548                        warnx("%s: %s",
     
    572574                if (needstats) {
    573575                        sp = cur->fts_statp;
     576      size = ((uint64_t) sp->st_blocks) * sp->st_blksize;
     577      if (size < 0x100000000ULL)
     578        size = sp->st_size;
    574579                        if (sp->st_blocks > maxblock)
    575580                                maxblock = sp->st_blocks;
     
    578583                        if (sp->st_nlink > maxnlink)
    579584                                maxnlink = sp->st_nlink;
    580                         if (sp->st_size > maxsize)
    581                                 maxsize = sp->st_size;
     585                        if (size > maxsize)
     586                                maxsize = size;
    582587                        if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode)) {
    583588                                bcfile = 1;
     
    589594
    590595                        btotal += sp->st_blocks;
    591                         stotal += sp->st_size;
     596                        stotal += size;
    592597                        if (f_longform) {
    593598                                if (f_numericonly ||
  • cpukit/libmisc/shell/print-ls.c

    r1027f153 r42c4de8  
    162162                        } else {
    163163#endif
    164                                 (void)printf("%*llu ", dp->s_size,
    165                                     (long long)sp->st_size);
    166 #if RTEMS_REMOVED
     164      {
     165        unsigned long long size = sp->st_blocks;
     166        size *= sp->st_blksize;
     167        if (size < 0x100000000ULL)
     168          size = sp->st_size;
     169                                (void)printf("%*llu ", dp->s_size, size);
    167170                }
    168 #endif
    169171                if (f_accesstime)
    170172                        printtime(globals, sp->st_atime);
  • cpukit/libnetworking/rtems/mkrootfs.c

    r1027f153 r42c4de8  
    329329   */
    330330
    331   if (rtems_rootfs_append_host_rec (0x7f000001, "localhost", "localdomain"))
     331  if (rtems_rootfs_append_host_rec (htonl (0x7f000001), "localhost", "localdomain"))
    332332    return -1;
    333333
Note: See TracChangeset for help on using the changeset viewer.