source: trunk/dports/sysutils/rpm/files/rpm-4.4.1-glob.patch @ 12697

Last change on this file since 12697 was 12697, checked in by jkh, 15 years ago

Update to rpm version 4.4.2. At the request of jbj, we're going to consolidate
the rpm ports and try and clean up this mess.
Reviewed by: jbj

  • Property svn:eol-style set to native
File size: 12.8 KB
  • misc/fnmatch.c

    ? misc/fnmatch.c-DEBUG
    ? misc/glob.c-DEBUG
    cvs server: Diffing misc
    RCS file: /cvs/devel/rpm/misc/fnmatch.c,v
    retrieving revision 1.7.2.2
    diff -u -b -B -w -p -r1.7.2.2 fnmatch.c
    internal_fnmatch (const char *pattern, c 
    607607
    608608
    609609int
    610 fnmatch (const char *pattern, const char *string, int flags)
     610xxfnmatch (const char *pattern, const char *string, int flags)
    611611{
    612612  return internal_fnmatch (pattern, string, flags & FNM_PERIOD, flags);
    613613}
  • misc/fnmatch.h

    RCS file: /cvs/devel/rpm/misc/fnmatch.h,v
    retrieving revision 1.3.8.2
    diff -u -b -B -w -p -r1.3.8.2 fnmatch.h
    extern "C" { 
    7575
    7676/* Match NAME against the filename pattern PATTERN,
    7777   returning zero if it matches, FNM_NOMATCH if not.  */
    78 extern int fnmatch __P ((__const char *__pattern, __const char *__name,
     78extern int xxfnmatch __P ((__const char *__pattern, __const char *__name,
    7979                         int __flags));
    8080
    8181#ifdef  __cplusplus
  • misc/glob.c

    RCS file: /cvs/devel/rpm/misc/glob.c,v
    retrieving revision 1.15.2.2
    diff -u -b -B -w -p -r1.15.2.2 glob.c
     
    4848
    4949# include <assert.h>
    5050
    51 #define __alloca        alloca
     51#define __xxalloca      alloca
    5252#define __stat          stat
    5353#define NAMLEN(_d)      NLENGTH(_d)
    5454
    static int __glob_pattern_p (const char  
    130130   If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
    131131   Otherwise, `glob' returns zero.  */
    132132int
    133 glob (const char *pattern, int flags,
     133xxglob (const char *pattern, int flags,
    134134        int (*errfunc) __P ((const char *, int)), glob_t *pglob)
    135135{
    136136  const char *filename;
    glob (const char *pattern, int flags, 
    165165          if (onealt == NULL)
    166166            {
    167167              if (!(flags & GLOB_APPEND))
    168                 globfree (pglob);
     168                xxglobfree (pglob);
    169169              return GLOB_NOSPACE;
    170170            }
    171171#endif
    glob (const char *pattern, int flags, 
    187187#ifndef __GNUC__
    188188              free (onealt);
    189189#endif
    190               return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
     190              return xxglob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
    191191            }
    192192
    193193          /* Now find the end of the whole brace expression.  */
    glob (const char *pattern, int flags, 
    201201#ifndef __GNUC__
    202202                  free (onealt);
    203203#endif
    204                   return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
     204                  return xxglob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
    205205                }
    206206            }
    207207          /* Please note that we now can be sure the brace expression
    glob (const char *pattern, int flags, 
    236236              memcpy (&alt_start[next - p], rest, rest_len);
    237237#endif
    238238
    239               result = glob (onealt,
     239              result = xxglob (onealt,
    240240                             ((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC))
    241241                              | GLOB_APPEND), errfunc, pglob);
    242242
    glob (const char *pattern, int flags, 
    247247                  free (onealt);
    248248#endif
    249249                  if (!(flags & GLOB_APPEND))
    250                     globfree (pglob);
     250                    xxglobfree (pglob);
    251251                  return result;
    252252                }
    253253
    glob (const char *pattern, int flags, 
    325325          char *drive_spec;
    326326
    327327          ++dirlen;
    328           drive_spec = (char *) __alloca (dirlen + 1);
     328          drive_spec = (char *) __xxalloca (dirlen + 1);
    329329#ifdef HAVE_MEMPCPY
    330330          *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';
    331331#else
    glob (const char *pattern, int flags, 
    341341             from "d:/", since "d:" and "d:/" are not the same.*/
    342342        }
    343343#endif
    344       newp = (char *) __alloca (dirlen + 1);
     344      newp = (char *) __xxalloca (dirlen + 1);
    345345#ifdef HAVE_MEMPCPY
    346346      *((char *) mempcpy (newp, pattern, dirlen)) = '\0';
    347347#else
    glob (const char *pattern, int flags, 
    360360          && dirlen > 1)
    361361        /* "pattern/".  Expand "pattern", appending slashes.  */
    362362        {
    363           int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
     363          int val = xxglob (dirname, flags | GLOB_MARK, errfunc, pglob);
    364364          if (val == 0)
    365365            pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK)
    366366                               | (flags & GLOB_MARK));
    glob (const char *pattern, int flags, 
    402402                /* `sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
    403403                   a moderate value.  */
    404404                buflen = 20;
    405               name = (char *) __alloca (buflen);
     405              name = (char *) __xxalloca (buflen);
    406406
    407407              success = getlogin_r (name, buflen) >= 0;
    408408#   else
    glob (const char *pattern, int flags, 
    421421                    /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.
    422422                       Try a moderate value.  */
    423423                    pwbuflen = 1024;
    424                   pwtmpbuf = (char *) __alloca (pwbuflen);
     424                  pwtmpbuf = (char *) __xxalloca (pwbuflen);
    425425
    426426                  while (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p)
    427427                         != 0)
    glob (const char *pattern, int flags, 
    432432                          break;
    433433                        }
    434434                      pwbuflen *= 2;
    435                       pwtmpbuf = (char *) __alloca (pwbuflen);
     435                      pwtmpbuf = (char *) __xxalloca (pwbuflen);
    436436                      __set_errno (save);
    437437                    }
    438438#   else
    glob (const char *pattern, int flags, 
    458458            {
    459459              char *newp;
    460460              size_t home_len = strlen (home_dir);
    461               newp = (char *) __alloca (home_len + dirlen);
     461              newp = (char *) __xxalloca (home_len + dirlen);
    462462# ifdef HAVE_MEMPCPY
    463463              mempcpy (mempcpy (newp, home_dir, home_len),
    464464                       &dirname[1], dirlen);
    glob (const char *pattern, int flags, 
    481481          else
    482482            {
    483483              char *newp;
    484               newp = (char *) __alloca (end_name - dirname);
     484              newp = (char *) __xxalloca (end_name - dirname);
    485485# ifdef HAVE_MEMPCPY
    486486              *((char *) mempcpy (newp, dirname + 1, end_name - dirname))
    487487                = '\0';
    glob (const char *pattern, int flags, 
    505505              /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.  Try a
    506506                 moderate value.  */
    507507              buflen = 1024;
    508             pwtmpbuf = (char *) __alloca (buflen);
     508            pwtmpbuf = (char *) __xxalloca (buflen);
    509509
    510510            while (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) != 0)
    511511              {
    glob (const char *pattern, int flags, 
    515515                    break;
    516516                  }
    517517                buflen *= 2;
    518                 pwtmpbuf = __alloca (buflen);
     518                pwtmpbuf = __xxalloca (buflen);
    519519                __set_errno (save);
    520520              }
    521521#  else
    glob (const char *pattern, int flags, 
    532532              char *newp;
    533533              size_t home_len = strlen (home_dir);
    534534              size_t rest_len = end_name == NULL ? 0 : strlen (end_name);
    535               newp = (char *) __alloca (home_len + rest_len + 1);
     535              newp = (char *) __xxalloca (home_len + rest_len + 1);
    536536#  ifdef HAVE_MEMPCPY
    537537              *((char *) mempcpy (mempcpy (newp, home_dir, home_len),
    538538                                  end_name, rest_len)) = '\0';
    glob (const char *pattern, int flags, 
    625625          dirs.gl_lstat = pglob->gl_lstat;
    626626        }
    627627
    628       status = glob (dirname,
     628      status = xxglob (dirname,
    629629                     ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE
    630630                                | GLOB_ALTDIRFUNC))
    631631                      | GLOB_NOSORT | GLOB_ONLYDIR),
    glob (const char *pattern, int flags, 
    647647
    648648            if (interrupt_state)
    649649              {
    650                 globfree (&dirs);
    651                 globfree (&files);
     650                xxglobfree (&dirs);
     651                xxglobfree (&files);
    652652                return GLOB_ABORTED;
    653653              }
    654654          }
    glob (const char *pattern, int flags, 
    665665
    666666          if (status != 0)
    667667            {
    668               globfree (&dirs);
    669               globfree (pglob);
     668              xxglobfree (&dirs);
     669              xxglobfree (pglob);
    670670              return status;
    671671            }
    672672
    glob (const char *pattern, int flags, 
    675675                            &pglob->gl_pathv[old_pathc],
    676676                            pglob->gl_pathc - old_pathc))
    677677            {
    678               globfree (&dirs);
    679               globfree (pglob);
     678              xxglobfree (&dirs);
     679              xxglobfree (pglob);
    680680              return GLOB_NOSPACE;
    681681            }
    682682        }
    glob (const char *pattern, int flags, 
    706706                                     sizeof (char *));
    707707              if (pglob->gl_pathv == NULL)
    708708                {
    709                   globfree (&dirs);
     709                  xxglobfree (&dirs);
    710710                  return GLOB_NOSPACE;
    711711                }
    712712
    glob (const char *pattern, int flags, 
    730730                                                             + filename_len);
    731731                  if (pglob->gl_pathv[pglob->gl_pathc] == NULL)
    732732                    {
    733                       globfree (&dirs);
    734                       globfree (pglob);
     733                      xxglobfree (&dirs);
     734                      xxglobfree (pglob);
    735735                      return GLOB_NOSPACE;
    736736                    }
    737737
    glob (const char *pattern, int flags, 
    763763            return GLOB_NOMATCH;
    764764        }
    765765
    766       globfree (&dirs);
     766      xxglobfree (&dirs);
    767767    }
    768768  else
    769769    {
    glob (const char *pattern, int flags, 
    783783                            &pglob->gl_pathv[ignore],
    784784                            pglob->gl_pathc - ignore))
    785785            {
    786               globfree (pglob);
     786              xxglobfree (pglob);
    787787              return GLOB_NOSPACE;
    788788            }
    789789        }
    glob (const char *pattern, int flags, 
    804804            char *new = xrealloc (pglob->gl_pathv[i], len);
    805805            if (new == NULL)
    806806              {
    807                 globfree (pglob);
     807                xxglobfree (pglob);
    808808                return GLOB_NOSPACE;
    809809              }
    810810            strcpy (&new[len - 2], "/");
    glob (const char *pattern, int flags, 
    831831
    832832/* Free storage allocated in PGLOB by a previous `glob' call.  */
    833833void
    834 globfree (glob_t *pglob)
     834xxglobfree (glob_t *pglob)
    835835{
    836836  if (pglob->gl_pathv != NULL)
    837837    {
    glob_in_dir (const char *pattern, const  
    10011001          struct stat st;
    10021002          size_t patlen = strlen (pattern);
    10031003          size_t dirlen = strlen (directory);
    1004           char *fullname = (char *) __alloca (dirlen + 1 + patlen + 1);
     1004          char *fullname = (char *) __xxalloca (dirlen + 1 + patlen + 1);
    10051005
    10061006# ifdef HAVE_MEMPCPY
    10071007          mempcpy (mempcpy (mempcpy (fullname, directory, dirlen),
    glob_in_dir (const char *pattern, const  
    10281028        {
    10291029          /* This is a special case for matching directories like in
    10301030             "*a/".  */
    1031           names = (struct globlink *) __alloca (sizeof (struct globlink));
     1031          names = (struct globlink *) __xxalloca (sizeof (struct globlink));
    10321032          names->name = (char *) xmalloc (1);
    10331033          if (names->name == NULL)
    10341034            goto memory_error;
    glob_in_dir (const char *pattern, const  
    10841084
    10851085                  name = d->d_name;
    10861086
    1087                   if (fnmatch (pattern, name, fnm_flags) == 0)
     1087                  if (xxfnmatch (pattern, name, fnm_flags) == 0)
    10881088                    {
    10891089                      struct globlink *new = (struct globlink *)
    1090                         __alloca (sizeof (struct globlink));
     1090                        __xxalloca (sizeof (struct globlink));
    10911091                      len = NAMLEN (d);
    10921092                      new->name = (char *) xmalloc (len + 1);
    10931093                      if (new->name == NULL)
    glob_in_dir (const char *pattern, const  
    11121112    {
    11131113      size_t len = strlen (pattern);
    11141114      nfound = 1;
    1115       names = (struct globlink *) __alloca (sizeof (struct globlink));
     1115      names = (struct globlink *) __xxalloca (sizeof (struct globlink));
    11161116      names->next = NULL;
    11171117      names->name = (char *) xmalloc (len + 1);
    11181118      if (names->name == NULL)
  • misc/glob.h

    RCS file: /cvs/devel/rpm/misc/glob.h,v
    retrieving revision 1.6.16.3
    diff -u -b -B -w -p -r1.6.16.3 glob.h
    typedef struct 
    152152   If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
    153153   Otherwise, `glob' returns zero.  */
    154154#if _FILE_OFFSET_BITS != 64
    155 extern int glob __P ((__const char *__pattern, int __flags,
     155extern int xxglob __P ((__const char *__pattern, int __flags,
    156156                      int (*__errfunc) (__const char *, int),
    157157                      glob_t *__pglob));
    158158
    159159/* Free storage allocated in PGLOB by a previous `glob' call.  */
    160 extern void globfree __P ((glob_t *__pglob));
     160extern void xxglobfree __P ((glob_t *__pglob));
    161161#else
    162162# if __GNUC__ >= 2
    163163extern int glob __P ((__const char *__pattern, int __flags,
  • rpmio/rpmrpc.c

    cvs server: Diffing rpmio
    RCS file: /cvs/devel/rpm/rpmio/rpmrpc.c,v
    retrieving revision 2.44.2.4
    diff -u -b -B -w -p -r2.44.2.4 rpmrpc.c
    fprintf(stderr, "*** Glob(%s,0x%x,%p,%p) 
    14661466        return -2;
    14671467        /*@notreached@*/ break;
    14681468    }
    1469     return glob(pattern, flags, errfunc, pglob);
     1469    return xxglob(pattern, flags, errfunc, pglob);
    14701470}
    14711471
    14721472void Globfree(glob_t *pglob)
    14731473{
    14741474if (_rpmio_debug)
    14751475fprintf(stderr, "*** Globfree(%p)\n", pglob);
    1476     globfree(pglob);
     1476    xxglobfree(pglob);
    14771477}
    14781478
    14791479DIR * Opendir(const char * path)
  • rpmio/stubs.c

    RCS file: /cvs/devel/rpm/rpmio/stubs.c,v
    retrieving revision 1.5.6.1
    diff -u -b -B -w -p -r1.5.6.1 stubs.c
     
    7171#endif
    7272
    7373#if defined(USE_GNU_GLOB)
    74 #include "misc/fnmatch.h"
    7574#include "misc/fnmatch.c"
    76 #include "misc/glob.h"
    7775#include "misc/glob.c"
    7876#endif
Note: See TracBrowser for help on using the repository browser.