home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 February / CHIP_2_98.iso / misc / src / rpm / build / files.c < prev    next >
C/C++ Source or Header  |  1997-09-17  |  26KB  |  997 lines
  1. /* RPM - Copyright (C) 1995 Red Hat Software
  2.  * 
  3.  * prepack.c - routines for packaging
  4.  */
  5.  
  6. #include "miscfn.h"
  7.  
  8. #include <stdlib.h>
  9. #include <unistd.h>
  10. #include <string.h>
  11. #include <sys/stat.h>
  12. #include <time.h>
  13.  
  14. #include "spec.h"
  15. #include "specP.h"
  16. #include "stringbuf.h"
  17. #include "build.h"
  18. #include "messages.h"
  19. #include "md5.h"
  20. #include "myftw.h"
  21. #include "header.h"
  22. #include "files.h"
  23. #include "names.h"
  24. #include "rpmlead.h"
  25. #include "rpmlib.h"
  26. #include "misc.h"
  27. #include "macro.h"
  28.  
  29. #define BINARY_HEADER 0
  30. #define SOURCE_HEADER 1
  31.  
  32. struct file_entry {
  33.     char file[1024];
  34.     int isdoc;
  35.     int conf;
  36.     int isspecfile;
  37.     int verify_flags;
  38.     char *uname;  /* reference -- do not free */
  39.     char *gname;  /* reference -- do not free */
  40.     struct stat statbuf;
  41.     struct file_entry *next;
  42. };
  43.  
  44. static int add_file(struct file_entry **festack, const char *name,
  45.             int isdoc, int isconf, int isdir, int verify_flags,
  46.             char *Pmode, char *Uname, char *Gname, char *prefix);
  47. static int compare_fe(const void *ap, const void *bp);
  48. static int add_file_aux(const char *file, struct stat *sb, int flag);
  49. static int glob_error(const char *foo, int bar);
  50. static int glob_pattern_p (char *pattern);
  51. static int parseForVerify(char *buf, int *verify_flags);
  52. static int parseForConfig(char *buf, int *conf);
  53. static int parseForAttr(char *origbuf, char **currPmode,
  54.             char **currUname, char **currGname);
  55.  
  56. static void resetDocdir(void);
  57. static void addDocdir(char *dirname);
  58. static int isDoc(char *filename);
  59.  
  60. static int processFileListFailed;
  61.  
  62. static void parseForDocFiles(struct PackageRec *package, char *line)
  63. {
  64.     if (! (line = strstr(line, "%doc"))) {
  65.     return;
  66.     }
  67.  
  68.     line += 4;
  69.     if ((*line != ' ') && (*line != '\t')) {
  70.     return;
  71.     }
  72.     line += strspn(line, " \t\n");
  73.     if ((! *line) || (*line == '/')) {
  74.     return;
  75.     }
  76.     
  77.     appendLineStringBuf(package->doc, "mkdir -p $DOCDIR");
  78.     appendStringBuf(package->doc, "cp -pr ");
  79.     appendStringBuf(package->doc, line);
  80.     appendLineStringBuf(package->doc, " $DOCDIR");
  81. }
  82.  
  83. int finish_filelists(Spec spec)
  84. {
  85.     char buf[1024];
  86.     FILE *file;
  87.     struct PackageRec *pr = spec->packages;
  88.     char *s, **files, **line;
  89.     char *version, *release, *packageVersion, *packageRelease, *docs, *name;
  90.  
  91.     headerGetEntry(spec->packages->header, RPMTAG_VERSION, NULL,
  92.          (void *) &version, NULL);
  93.     headerGetEntry(spec->packages->header, RPMTAG_RELEASE, NULL,
  94.          (void *) &release, NULL);
  95.     
  96.     while (pr) {
  97.     if (pr->fileFile) {
  98.         sprintf(buf, "%s/%s/%s", rpmGetVar(RPMVAR_BUILDDIR),
  99.             build_subdir, pr->fileFile);
  100.         rpmMessage(RPMMESS_DEBUG, "Reading file names from: %s\n", buf);
  101.         if ((file = fopen(buf, "r")) == NULL) {
  102.         rpmError(RPMERR_BADSPEC, "unable to open filelist: %s\n", buf);
  103.         return(RPMERR_BADSPEC);
  104.         }
  105.         while (fgets(buf, sizeof(buf), file)) {
  106.         expandMacros(buf);
  107.         appendStringBuf(pr->filelist, buf);
  108.         }
  109.         fclose(file);
  110.     }
  111.  
  112.     /* parse for %doc wierdness */
  113.     s = getStringBuf(pr->filelist);
  114.     files = splitString(s, strlen(s), '\n');
  115.     line = files;
  116.     while (*line) {
  117.         parseForDocFiles(pr, *line);
  118.         line++;
  119.     }
  120.     freeSplitString(files);
  121.  
  122.     /* Handle subpackage version/release overrides */
  123.         if (!headerGetEntry(pr->header, RPMTAG_VERSION, NULL,
  124.               (void *) &packageVersion, NULL)) {
  125.             packageVersion = version;
  126.     }
  127.         if (!headerGetEntry(pr->header, RPMTAG_RELEASE, NULL,
  128.               (void *) &packageRelease, NULL)) {
  129.             packageRelease = release;
  130.     }
  131.  
  132.     /* Generate the doc script */
  133.     appendStringBuf(spec->doc, "DOCDIR=$RPM_ROOT_DIR/$RPM_DOC_DIR/");
  134.     headerGetEntry(pr->header, RPMTAG_NAME, NULL, (void *) &name, NULL);
  135.     sprintf(buf, "%s-%s-%s", name, packageVersion, packageRelease);
  136.     appendLineStringBuf(spec->doc, buf);
  137.     docs = getStringBuf(pr->doc);
  138.     if (*docs) {
  139.         appendLineStringBuf(spec->doc, "rm -rf $DOCDIR");
  140.         appendLineStringBuf(spec->doc, docs);
  141.     }
  142.  
  143.     pr = pr->next;
  144.     }
  145.  
  146.     return 0;
  147. }
  148.  
  149. int process_filelist(Header header, struct PackageRec *pr,
  150.              StringBuf sb, int *size, char *name,
  151.              char *version, char *release, int type,
  152.              char *prefix, char *specFile)
  153. {
  154.     char buf[1024];
  155.     char **files, **fp;
  156.     struct file_entry *fes, *fest;
  157.     struct file_entry **file_entry_array;
  158.     int isdoc, conf, isdir, verify_flags;
  159.     char *currPmode=NULL;    /* hold info from %attr() */
  160.     char *currUname=NULL;    /* hold info from %attr() */
  161.     char *currGname=NULL;    /* hold info from %attr() */
  162.     char *filename, *s;
  163.     char *str;
  164.     int count = 0;
  165.     int c, x;
  166.     glob_t glob_result;
  167.     int special_doc;
  168.     int passed_special_doc = 0;
  169.     int tc;
  170.     char *tcs;
  171.     int currentTime;
  172.  
  173.     processFileListFailed = 0;
  174.     fes = NULL;
  175.     *size = 0;
  176.  
  177.     resetDocdir();
  178.  
  179.     str = getStringBuf(sb);
  180.     files = splitString(str, strlen(str), '\n');
  181.     fp = files;
  182.  
  183.     while (*fp) {
  184.     strcpy(buf, *fp);  /* temp copy */
  185.     isdoc = 0;
  186.     special_doc = 0;
  187.     conf = 0;
  188.     isdir = 0;
  189.     if (currPmode) {
  190.         free (currPmode);
  191.         currPmode = NULL;
  192.     }
  193.     if (currUname) {
  194.         free (currUname);
  195.         currUname = NULL;
  196.     }
  197.     if (currGname) {
  198.         free (currGname);
  199.         currGname = NULL;
  200.     }
  201.     verify_flags = RPMVERIFY_ALL;
  202.     filename = NULL;
  203.  
  204.     /* First preparse buf for %verify() */
  205.     if (parseForVerify(buf, &verify_flags)) {
  206.         processFileListFailed = 1;
  207.         fp++; continue;
  208.     }
  209.     
  210.     /* Next parse for %attr() */
  211.     if (parseForAttr(buf, &currPmode, &currUname, &currGname)) {
  212.         processFileListFailed = 1;
  213.         fp++; continue;
  214.     }
  215.  
  216.     /* Then parse for %config or %config() */
  217.     if (parseForConfig(buf, &conf)) {
  218.         processFileListFailed = 1;
  219.         fp++; continue;
  220.     }
  221.  
  222.     s = strtok(buf, " \t\n");
  223.     while (s) {
  224.         if (!strcmp(s, "%docdir")) {
  225.             s = strtok(NULL, " \t\n");
  226.         addDocdir(s);
  227.         break;
  228.         } else if (!strcmp(s, "%doc")) {
  229.         isdoc = 1;
  230.         } else if (!strcmp(s, "%dir")) {
  231.         isdir = 1;
  232.         } else {
  233.         if (filename) {
  234.             /* We already got a file -- error */
  235.             rpmError(RPMERR_BADSPEC,
  236.               "Two files on one line: %s", filename);
  237.             processFileListFailed = 1;
  238.         }
  239.         if (*s != '/') {
  240.             if (isdoc) {
  241.             special_doc = 1;
  242.             } else {
  243.             /* not in %doc, does not begin with / -- error */
  244.             rpmError(RPMERR_BADSPEC,
  245.                   "File must begin with \"/\": %s", s);
  246.             processFileListFailed = 1;
  247.             }
  248.         } else {
  249.             filename = s;
  250.         }
  251.         }
  252.         s = strtok(NULL, " \t\n");
  253.     }
  254.     if (special_doc) {
  255.         if (passed_special_doc) {
  256.         fp++;
  257.         continue;
  258.         } else {
  259.         if (filename || conf || isdir) {
  260.             rpmError(RPMERR_BADSPEC,
  261.               "Can't mix special %%doc with other forms: %s", fp);
  262.             processFileListFailed = 1;
  263.             fp++; continue;
  264.         }
  265.         sprintf(buf, "%s/%s-%s-%s", rpmGetVar(RPMVAR_DEFAULTDOCDIR), 
  266.             name, version, release);
  267.         filename = buf;
  268.         passed_special_doc = 1;
  269.         }
  270.     }
  271.     if (! filename) {
  272.         fp++;
  273.         continue;
  274.     }
  275.  
  276.     if (type == RPMLEAD_BINARY) {
  277.         /* check that file starts with leading "/" */
  278.         if (*filename != '/') {
  279.         rpmError(RPMERR_BADSPEC,
  280.               "File needs leading \"/\": %s", filename);
  281.         processFileListFailed = 1;
  282.         fp++; continue;
  283.         }
  284.  
  285.         if (glob_pattern_p(filename)) {
  286.         char fullname[1024];
  287.  
  288.         if (rpmGetVar(RPMVAR_ROOT)) {
  289.             sprintf(fullname, "%s%s", rpmGetVar(RPMVAR_ROOT), filename);
  290.         } else {
  291.             strcpy(fullname, filename);
  292.         }
  293.  
  294.             if (glob(fullname, 0, glob_error, &glob_result) ||
  295.             (glob_result.gl_pathc < 1)) {
  296.             rpmError(RPMERR_BADSPEC, "No matches: %s", fullname);
  297.             processFileListFailed = 1;
  298.             globfree(&glob_result);
  299.             fp++; continue;
  300.         }
  301.         
  302.         c = 0;
  303.         x = 0;
  304.         while (x < glob_result.gl_pathc) {
  305.             int offset = strlen(rpmGetVar(RPMVAR_ROOT) ? : "");
  306.             c += add_file(&fes, &(glob_result.gl_pathv[x][offset]),
  307.                   isdoc, conf, isdir, verify_flags,
  308.                   currPmode, currUname, currGname, prefix);
  309.             x++;
  310.         }
  311.         globfree(&glob_result);
  312.         } else {
  313.             c = add_file(&fes, filename, isdoc, conf, isdir,
  314.                  verify_flags, currPmode, currUname,
  315.                  currGname, prefix);
  316.         }
  317.     } else {
  318.         /* Source package are the simple case */
  319.         fest = malloc(sizeof(struct file_entry));
  320.         fest->isdoc = 0;
  321.         fest->conf = 0;
  322.         if (!strcmp(filename, specFile)) {
  323.         fest->isspecfile = 1;
  324.         } else {
  325.         fest->isspecfile = 0;
  326.         }
  327.         fest->verify_flags = 0;  /* XXX - something else? */
  328.         stat(filename, &fest->statbuf);
  329.         fest->uname = getUname(fest->statbuf.st_uid);
  330.         fest->gname = getGname(fest->statbuf.st_gid);
  331.         if (! (fest->uname && fest->gname)) {
  332.         rpmError(RPMERR_BADSPEC, "Bad owner/group: %s", filename);
  333.         fest->uname = "";
  334.         fest->gname = "";
  335.         processFileListFailed = 1;
  336.         }
  337.         strcpy(fest->file, filename);
  338.         fest->next = fes;
  339.         fes = fest;
  340.         c = 1;
  341.     }
  342.         
  343.     if (! c) {
  344.         rpmError(RPMERR_BADSPEC, "File not found: %s", filename);
  345.         processFileListFailed = 1;
  346.     }
  347.     count += c;
  348.     
  349.     fp++;
  350.     }
  351.  
  352.     /* If there are no files, don't add anything to the header */
  353.     if (count) {
  354.     char ** fileList;
  355.     char ** fileMD5List;
  356.     char ** fileLinktoList;
  357.     int_32 * fileSizeList;
  358.     int_32 * fileUIDList;
  359.     int_32 * fileGIDList;
  360.     char ** fileUnameList;
  361.     char ** fileGnameList;
  362.     int_32 * fileMtimesList;
  363.     int_32 * fileFlagsList;
  364.     int_16 * fileModesList;
  365.     int_16 * fileRDevsList;
  366.      int_32 * fileVerifyFlagsList;
  367.  
  368.     fileList = malloc(sizeof(char *) * count);
  369.     fileLinktoList = malloc(sizeof(char *) * count);
  370.     fileMD5List = malloc(sizeof(char *) * count);
  371.     fileSizeList = malloc(sizeof(int_32) * count);
  372.     fileUIDList = malloc(sizeof(int_32) * count);
  373.     fileGIDList = malloc(sizeof(int_32) * count);
  374.     fileUnameList = malloc(sizeof(char *) * count);
  375.     fileGnameList = malloc(sizeof(char *) * count);
  376.     fileMtimesList = malloc(sizeof(int_32) * count);
  377.     fileFlagsList = malloc(sizeof(int_32) * count);
  378.     fileModesList = malloc(sizeof(int_16) * count);
  379.     fileRDevsList = malloc(sizeof(int_16) * count);
  380.     fileVerifyFlagsList = malloc(sizeof(int_32) * count);
  381.  
  382.     /* Build a reverse sorted file array.  */
  383.     /* This makes uninstalls a lot easier. */
  384.     file_entry_array = malloc(sizeof(struct file_entry *) * count);
  385.     c = 0;
  386.     fest = fes;
  387.     while (fest) {
  388.         file_entry_array[c++] = fest;
  389.         fest = fest->next;
  390.     }
  391.     qsort(file_entry_array, count, sizeof(struct file_entry *),
  392.           compare_fe);
  393.         
  394.     /* Do timecheck */
  395.     tc = 0;
  396.     currentTime = time(NULL);
  397.     if ((tcs = rpmGetVar(RPMVAR_TIMECHECK))) {
  398.         tc = strtoul(tcs, NULL, 10);
  399.     }
  400.     
  401.     c = 0;
  402.     while (c < count) {
  403.         fest = file_entry_array[c];
  404.         if (type == RPMLEAD_BINARY) {
  405.         x = strlen(fest->file) - 1;
  406.         if (x && fest->file[x] == '/') {
  407.             fest->file[x] = '\0';
  408.         }
  409.         fileList[c] = fest->file;
  410.         } else {
  411.         fileList[c] = strrchr(fest->file, '/') + 1;
  412.         }
  413.         if ((c > 0) && !strcmp(fileList[c], fileList[c-1])) {
  414.         rpmError(RPMERR_BADSPEC, "File listed twice: %s", fileList[c]);
  415.         processFileListFailed = 1;
  416.         }
  417.         
  418.         fileUnameList[c] = fest->uname;
  419.         fileGnameList[c] = fest->gname;
  420.         *size += fest->statbuf.st_size;
  421.         if (S_ISREG(fest->statbuf.st_mode)) {
  422.         if ((type == RPMLEAD_BINARY) &&
  423.             rpmGetVar(RPMVAR_ROOT)) {
  424.             sprintf(buf, "%s%s", rpmGetVar(RPMVAR_ROOT), fest->file);
  425.         } else {
  426.             strcpy(buf, fest->file);
  427.         }
  428.         mdfile(buf, buf);
  429.         fileMD5List[c] = strdup(buf);
  430.         rpmMessage(RPMMESS_DEBUG, "md5(%s) = %s\n", fest->file, buf);
  431.         } else {
  432.         /* This is stupid */
  433.         fileMD5List[c] = strdup("");
  434.         }
  435.         fileSizeList[c] = fest->statbuf.st_size;
  436.         fileUIDList[c] = fest->statbuf.st_uid;
  437.         fileGIDList[c] = fest->statbuf.st_gid;
  438.         fileMtimesList[c] = fest->statbuf.st_mtime;
  439.  
  440.         /* Do timecheck */
  441.         if (tc && (type == RPMLEAD_BINARY)) {
  442.         if (currentTime - fest->statbuf.st_mtime > tc) {
  443.             rpmMessage(RPMMESS_WARNING, "TIMECHECK failure: %s\n",
  444.                 fest->file);
  445.         }
  446.         }
  447.     
  448.         fileFlagsList[c] = 0;
  449.         if (isDoc(fest->file))
  450.             fileFlagsList[c] |= RPMFILE_DOC;
  451.         if (fest->isdoc) 
  452.         fileFlagsList[c] |= RPMFILE_DOC;
  453.         if (fest->conf && !(fest->statbuf.st_mode & S_IFDIR))
  454.         fileFlagsList[c] |= fest->conf;
  455.         if (fest->isspecfile)
  456.         fileFlagsList[c] |= RPMFILE_SPECFILE;
  457.  
  458.         fileModesList[c] = fest->statbuf.st_mode;
  459.         fileRDevsList[c] = fest->statbuf.st_rdev;
  460.         fileVerifyFlagsList[c] = fest->verify_flags;
  461.  
  462.         if (S_ISLNK(fest->statbuf.st_mode)) {
  463.         if (rpmGetVar(RPMVAR_ROOT)) {
  464.             sprintf(buf, "%s%s", rpmGetVar(RPMVAR_ROOT), fest->file);
  465.         } else {
  466.             strcpy(buf, fest->file);
  467.         }
  468.             buf[readlink(buf, buf, 1024)] = '\0';
  469.         fileLinktoList[c] = strdup(buf);
  470.         } else {
  471.         /* This is stupid */
  472.         fileLinktoList[c] = strdup("");
  473.         }
  474.         c++;
  475.     }
  476.  
  477.     /* Add the header entries */
  478.     c = count;
  479.     headerAddEntry(header, RPMTAG_FILENAMES, RPM_STRING_ARRAY_TYPE, fileList, c);
  480.     headerAddEntry(header, RPMTAG_FILELINKTOS, RPM_STRING_ARRAY_TYPE,
  481.          fileLinktoList, c);
  482.     headerAddEntry(header, RPMTAG_FILEMD5S, RPM_STRING_ARRAY_TYPE, fileMD5List, c);
  483.     headerAddEntry(header, RPMTAG_FILESIZES, RPM_INT32_TYPE, fileSizeList, c);
  484.     headerAddEntry(header, RPMTAG_FILEUIDS, RPM_INT32_TYPE, fileUIDList, c);
  485.     headerAddEntry(header, RPMTAG_FILEGIDS, RPM_INT32_TYPE, fileGIDList, c);
  486.     headerAddEntry(header, RPMTAG_FILEUSERNAME, RPM_STRING_ARRAY_TYPE,
  487.          fileUnameList, c);
  488.     headerAddEntry(header, RPMTAG_FILEGROUPNAME, RPM_STRING_ARRAY_TYPE,
  489.          fileGnameList, c);
  490.     headerAddEntry(header, RPMTAG_FILEMTIMES, RPM_INT32_TYPE, fileMtimesList, c);
  491.     headerAddEntry(header, RPMTAG_FILEFLAGS, RPM_INT32_TYPE, fileFlagsList, c);
  492.     headerAddEntry(header, RPMTAG_FILEMODES, RPM_INT16_TYPE, fileModesList, c);
  493.     headerAddEntry(header, RPMTAG_FILERDEVS, RPM_INT16_TYPE, fileRDevsList, c);
  494.     headerAddEntry(header, RPMTAG_FILEVERIFYFLAGS, RPM_INT32_TYPE,
  495.          fileVerifyFlagsList, c);
  496.     
  497.     /* Free the allocated strings */
  498.     c = count;
  499.     while (c--) {
  500.         free(fileMD5List[c]);
  501.         free(fileLinktoList[c]);
  502.     }
  503.  
  504.     /* Free all those lists */
  505.     free(fileList);
  506.     free(fileLinktoList);
  507.     free(fileMD5List);
  508.     free(fileSizeList);
  509.     free(fileUIDList);
  510.     free(fileGIDList);
  511.     free(fileUnameList);
  512.     free(fileGnameList);
  513.     free(fileMtimesList);
  514.     free(fileFlagsList);
  515.     free(fileModesList);
  516.     free(fileRDevsList);
  517.     free(fileVerifyFlagsList);
  518.     
  519.     /* Free the file entry array */
  520.     free(file_entry_array);
  521.     
  522.     /* Free the file entry stack */
  523.     fest = fes;
  524.     while (fest) {
  525.         fes = fest->next;
  526.         free(fest);
  527.         fest = fes;
  528.     }
  529.     }
  530.     
  531.     freeSplitString(files);
  532.     return processFileListFailed;
  533. }
  534.  
  535. /*************************************************************/
  536. /*                                                           */
  537. /* misc                                                      */
  538. /*                                                           */
  539. /*************************************************************/
  540.  
  541. static int compare_fe(const void *ap, const void *bp)
  542. {
  543.     char *a, *b;
  544.  
  545.     a = (*(struct file_entry **)ap)->file;
  546.     b = (*(struct file_entry **)bp)->file;
  547.  
  548.     return strcmp(a, b);
  549. }
  550.  
  551. /*************************************************************/
  552. /*                                                           */
  553. /* Doc dir stuff                                             */
  554. /*                                                           */
  555. /*************************************************************/
  556.  
  557. /* XXX hard coded limit -- only 1024 %docdir allowed */
  558. static char *docdirs[1024];
  559. static int docdir_count;
  560.  
  561. static void resetDocdir(void)
  562. {
  563.     while (docdir_count--) {
  564.         free(docdirs[docdir_count]);
  565.     }
  566.     docdir_count = 0;
  567.     docdirs[docdir_count++] = strdup("/usr/doc");
  568.     docdirs[docdir_count++] = strdup("/usr/man");
  569.     docdirs[docdir_count++] = strdup("/usr/info");
  570.     docdirs[docdir_count++] = strdup("/usr/X11R6/man");
  571. }
  572.  
  573. static void addDocdir(char *dirname)
  574. {
  575.     if (docdir_count == 1024) {
  576.     fprintf(stderr, "RPMERR_INTERNAL: Hit limit in addDocdir()\n");
  577.     exit(RPMERR_INTERNAL);
  578.     }
  579.     docdirs[docdir_count++] = strdup(dirname);
  580. }
  581.  
  582. static int isDoc(char *filename)
  583. {
  584.     int x = 0;
  585.  
  586.     while (x < docdir_count) {
  587.         if (strstr(filename, docdirs[x]) == filename) {
  588.         return 1;
  589.         }
  590.     x++;
  591.     }
  592.     return 0;
  593. }
  594.  
  595. /*************************************************************/
  596. /*                                                           */
  597. /* File stating / tree walk                                  */
  598. /*                                                           */
  599. /*************************************************************/
  600.  
  601. /* Need three globals to keep track of things in ftw() */
  602. static int Gisdoc;
  603. static int Gconf;
  604. static int Gverify_flags;
  605. static int Gcount;
  606. static char *GPmode;
  607. static char *GUname;
  608. static char *GGname;
  609. static struct file_entry **Gfestack;
  610. static char *Gprefix;
  611.  
  612. static int add_file(struct file_entry **festack, const char *name,
  613.             int isdoc, int conf, int isdir, int verify_flags,
  614.             char *Pmode, char *Uname, char *Gname, char *prefix)
  615. {
  616.     struct file_entry *p;
  617.     char *copyTo, copied;
  618.     const char *prefixTest, *prefixPtr;
  619.     const char *copyFrom;
  620.     char fullname[1024];
  621.     int mode;
  622.  
  623.     /* Set these up for ftw() */
  624.     Gfestack = festack;
  625.     Gisdoc = isdoc;
  626.     Gconf = conf;
  627.     Gverify_flags = verify_flags;
  628.     GPmode = Pmode;
  629.     GUname = Uname;
  630.     GGname = Gname;
  631.     Gprefix = prefix;
  632.  
  633.     p = malloc(sizeof(struct file_entry));
  634.  
  635.     copyTo = p->file;
  636.     copied = '\0';
  637.     copyFrom = name;
  638.     while (*copyFrom) {
  639.     if (*copyFrom != '/' || copied != '/') {
  640.         *copyTo++ = copied = *copyFrom;
  641.     }
  642.     copyFrom++;
  643.     }
  644.     *copyTo = '\0';
  645.  
  646.     p->isdoc = isdoc;
  647.     p->conf = conf;
  648.     p->isspecfile = 0;  /* source packages are done by hand */
  649.     p->verify_flags = verify_flags;
  650.     if (rpmGetVar(RPMVAR_ROOT)) {
  651.     sprintf(fullname, "%s%s", rpmGetVar(RPMVAR_ROOT), name);
  652.     } else {
  653.     strcpy(fullname, name);
  654.     }
  655.  
  656.     /* If we are using a prefix, validate the file */
  657.     if (prefix) {
  658.     prefixTest = name;
  659.     prefixPtr = prefix;
  660.     while (*prefixTest == '/') {
  661.         prefixTest++;  /* Skip leading "/" */
  662.     }
  663.     while (*prefixPtr && *prefixTest && (*prefixTest == *prefixPtr)) {
  664.         prefixPtr++;
  665.         prefixTest++;
  666.     }
  667.     if (*prefixPtr) {
  668.         rpmError(RPMERR_BADSPEC, "File doesn't match prefix (%s): %s",
  669.           prefix, name);
  670.         return 0;
  671.     }
  672.     }
  673.  
  674.     /* OK, finally stat() the file */
  675.     if (lstat(fullname, &p->statbuf)) {
  676.     return 0;
  677.     }
  678.  
  679.     /*
  680.      * If %attr() was specified, then use those values instead of
  681.      * what lstat() returned.
  682.      */
  683.     if (Pmode && strcmp(Pmode, "-")) {
  684.      sscanf(Pmode, "%o", &mode);
  685.      mode |= p->statbuf.st_mode & S_IFMT;
  686.      p->statbuf.st_mode = (unsigned short)mode;
  687.     }
  688.  
  689.     if (Uname && strcmp(Uname, "-")) {
  690.      p->uname = getUnameS(Uname);
  691.     } else {
  692.      p->uname = getUname(p->statbuf.st_uid);
  693.     }
  694.     
  695.     if (Gname && strcmp(Gname, "-")) {
  696.      p->gname = getGnameS(Gname);
  697.     } else {
  698.      p->gname = getGname(p->statbuf.st_gid);
  699.     }
  700.     
  701.     if (! (p->uname && p->gname)) {
  702.     rpmError(RPMERR_BADSPEC, "Bad owner/group: %s\n", fullname);
  703.     p->uname = "";
  704.     p->gname = "";
  705.     return 0;
  706.     }
  707.     
  708.     if ((! isdir) && S_ISDIR(p->statbuf.st_mode)) {
  709.     /* This means we need to descend with ftw() */
  710.     Gcount = 0;
  711.     
  712.     /* We use our own ftw() call, because ftw() uses stat()    */
  713.     /* instead of lstat(), which causes it to follow symlinks! */
  714.     myftw(fullname, add_file_aux, 16);
  715.     
  716.     free(p);
  717.  
  718.     return Gcount;
  719.     } else {
  720.     /* Link it in */
  721.     p->next = *festack;
  722.     *festack = p;
  723.  
  724.     rpmMessage(RPMMESS_DEBUG, "ADDING: %s\n", name);
  725.  
  726.     /* return number of entries added */
  727.     return 1;
  728.     }
  729. }
  730.  
  731. static int add_file_aux(const char *file, struct stat *sb, int flag)
  732. {
  733.     const char *name = file;
  734.  
  735.     if (rpmGetVar(RPMVAR_ROOT)) {
  736.     name += strlen(rpmGetVar(RPMVAR_ROOT));
  737.     }
  738.  
  739.     /* The 1 will cause add_file() to *not* descend */
  740.     /* directories -- ftw() is already doing it!    */
  741.     Gcount += add_file(Gfestack, name, Gisdoc, Gconf, 1, Gverify_flags,
  742.             GPmode, GUname, GGname, Gprefix);
  743.  
  744.     return 0; /* for ftw() */
  745. }
  746.  
  747. /*************************************************************/
  748. /*                                                           */
  749. /* globbing                                                  */
  750. /*                                                           */
  751. /*************************************************************/
  752.  
  753. /* glob_pattern_p() taken from bash
  754.  * Copyright (C) 1985, 1988, 1989 Free Software Foundation, Inc.
  755.  */
  756.  
  757. /* Return nonzero if PATTERN has any special globbing chars in it.  */
  758. static int glob_pattern_p (char *pattern)
  759. {
  760.     register char *p = pattern;
  761.     register char c;
  762.     int open = 0;
  763.   
  764.     while ((c = *p++) != '\0')
  765.     switch (c) {
  766.     case '?':
  767.     case '*':
  768.         return (1);
  769.     case '[':      /* Only accept an open brace if there is a close */
  770.         open++;    /* brace to match it.  Bracket expressions must be */
  771.         continue;  /* complete, according to Posix.2 */
  772.     case ']':
  773.         if (open)
  774.         return (1);
  775.         continue;      
  776.     case '\\':
  777.         if (*p++ == '\0')
  778.         return (0);
  779.     }
  780.  
  781.     return (0);
  782. }
  783.  
  784. static int glob_error(const char *foo, int bar)
  785. {
  786.     return 1;
  787. }
  788.  
  789. /*************************************************************/
  790. /*                                                           */
  791. /* %attr parsing                                             */
  792. /*                                                           */
  793. /*************************************************************/
  794.  
  795. static int parseForAttr(char *buf, char **currPmode,
  796.             char **currUname, char **currGname)
  797. {
  798.     char *p, *start, *end;
  799.     char ourbuf[1024];
  800.     int mode, x;
  801.  
  802.     if (!(p = start = strstr(buf, "%attr"))) {
  803.     return 0;
  804.     }
  805.  
  806.     *currPmode = *currUname = *currGname = NULL;
  807.  
  808.     p += 5;
  809.     while (*p && (*p == ' ' || *p == '\t')) {
  810.     p++;
  811.     }
  812.  
  813.     if (*p != '(') {
  814.     rpmError(RPMERR_BADSPEC, "Bad %%attr() syntax: %s", buf);
  815.     return RPMERR_BADSPEC;
  816.     }
  817.     p++;
  818.  
  819.     end = p;
  820.     while (*end && *end != ')') {
  821.     end++;
  822.     }
  823.  
  824.     if (! *end) {
  825.     rpmError(RPMERR_BADSPEC, "Bad %%attr() syntax: %s", buf);
  826.     return RPMERR_BADSPEC;
  827.     }
  828.  
  829.     strncpy(ourbuf, p, end-p);
  830.     ourbuf[end-p] = '\0';
  831.  
  832.     *currPmode = strtok(ourbuf, ", \n\t");
  833.     *currUname = strtok(NULL, ", \n\t");
  834.     *currGname = strtok(NULL, ", \n\t");
  835.  
  836.     if (! (*currPmode && *currUname && *currGname)) {
  837.     rpmError(RPMERR_BADSPEC, "Bad %%attr() syntax: %s", buf);
  838.     *currPmode = *currUname = *currGname = NULL;
  839.     return RPMERR_BADSPEC;
  840.     }
  841.  
  842.     /* Do a quick test on the mode argument */
  843.     if (strcmp(*currPmode, "-")) {
  844.     x = sscanf(*currPmode, "%o", &mode);
  845.     if ((x == 0) || (mode >> 12)) {
  846.         rpmError(RPMERR_BADSPEC, "Bad %%attr() mode spec: %s", buf);
  847.         *currPmode = *currUname = *currGname = NULL;
  848.         return RPMERR_BADSPEC;
  849.     }
  850.     }
  851.     
  852.     *currPmode = strdup(*currPmode);
  853.     *currUname = strdup(*currUname);
  854.     *currGname = strdup(*currGname);
  855.     
  856.     /* Set everything we just parsed to blank spaces */
  857.     while (start <= end) {
  858.     *start++ = ' ';
  859.     }
  860.  
  861.     return 0;
  862. }
  863.  
  864. /*************************************************************/
  865. /*                                                           */
  866. /* %verify parsing                                           */
  867. /*                                                           */
  868. /*************************************************************/
  869.  
  870. static int parseForVerify(char *buf, int *verify_flags)
  871. {
  872.     char *p, *start, *end;
  873.     char ourbuf[1024];
  874.     int not;
  875.  
  876.     if (!(p = start = strstr(buf, "%verify"))) {
  877.     return 0;
  878.     }
  879.  
  880.     p += 7;
  881.     while (*p && (*p == ' ' || *p == '\t')) {
  882.     p++;
  883.     }
  884.  
  885.     if (*p != '(') {
  886.     rpmError(RPMERR_BADSPEC, "Bad %%verify() syntax: %s", buf);
  887.     return RPMERR_BADSPEC;
  888.     }
  889.     p++;
  890.  
  891.     end = p;
  892.     while (*end && *end != ')') {
  893.     end++;
  894.     }
  895.  
  896.     if (! *end) {
  897.     rpmError(RPMERR_BADSPEC, "Bad %%verify() syntax: %s", buf);
  898.     return RPMERR_BADSPEC;
  899.     }
  900.  
  901.     strncpy(ourbuf, p, end-p);
  902.     ourbuf[end-p] = '\0';
  903.     while (start <= end) {
  904.     *start++ = ' ';
  905.     }
  906.  
  907.     p = strtok(ourbuf, ", \n\t");
  908.     not = 0;
  909.     *verify_flags = RPMVERIFY_NONE;
  910.     while (p) {
  911.     if (!strcmp(p, "not")) {
  912.         not = 1;
  913.     } else if (!strcmp(p, "md5")) {
  914.         *verify_flags |= RPMVERIFY_MD5;
  915.     } else if (!strcmp(p, "size")) {
  916.         *verify_flags |= RPMVERIFY_FILESIZE;
  917.     } else if (!strcmp(p, "link")) {
  918.         *verify_flags |= RPMVERIFY_LINKTO;
  919.     } else if (!strcmp(p, "user")) {
  920.         *verify_flags |= RPMVERIFY_USER;
  921.     } else if (!strcmp(p, "group")) {
  922.         *verify_flags |= RPMVERIFY_GROUP;
  923.     } else if (!strcmp(p, "mtime")) {
  924.         *verify_flags |= RPMVERIFY_MTIME;
  925.     } else if (!strcmp(p, "mode")) {
  926.         *verify_flags |= RPMVERIFY_MODE;
  927.     } else if (!strcmp(p, "rdev")) {
  928.         *verify_flags |= RPMVERIFY_RDEV;
  929.     } else {
  930.         rpmError(RPMERR_BADSPEC, "Invalid %%verify token: %s", p);
  931.         return RPMERR_BADSPEC;
  932.     }
  933.     p = strtok(NULL, ", \n\t");
  934.     }
  935.  
  936.     if (not) {
  937.     *verify_flags = ~(*verify_flags);
  938.     }
  939.  
  940.     return 0;
  941. }
  942.  
  943. static int parseForConfig(char *buf, int *conf)
  944. {
  945.     char *p, *start, *end;
  946.     char ourbuf[1024];
  947.  
  948.     if (!(p = start = strstr(buf, "%config"))) {
  949.     return 0;
  950.     }
  951.     *conf = RPMFILE_CONFIG;
  952.  
  953.     p += 7;
  954.     while (*p && (*p == ' ' || *p == '\t')) {
  955.     p++;
  956.     }
  957.  
  958.     if (*p != '(') {
  959.     while (start < p) {
  960.         *start++ = ' ';
  961.     }
  962.     return 0;
  963.     }
  964.     p++;
  965.  
  966.     end = p;
  967.     while (*end && *end != ')') {
  968.     end++;
  969.     }
  970.  
  971.     if (! *end) {
  972.     rpmError(RPMERR_BADSPEC, "Bad %%config() syntax: %s", buf);
  973.     return RPMERR_BADSPEC;
  974.     }
  975.  
  976.     strncpy(ourbuf, p, end-p);
  977.     ourbuf[end-p] = '\0';
  978.     while (start <= end) {
  979.     *start++ = ' ';
  980.     }
  981.  
  982.     p = strtok(ourbuf, ", \n\t");
  983.     while (p) {
  984.     if (!strcmp(p, "missingok")) {
  985.         *conf |= RPMFILE_MISSINGOK;
  986.     } else if (!strcmp(p, "noreplace")) {
  987.         *conf |= RPMFILE_NOREPLACE;
  988.     } else {
  989.         rpmError(RPMERR_BADSPEC, "Invalid %%config token: %s", p);
  990.         return RPMERR_BADSPEC;
  991.     }
  992.     p = strtok(NULL, ", \n\t");
  993.     }
  994.  
  995.     return 0;
  996. }
  997.