home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 February / CHIP_2_98.iso / misc / src / rpm / build / trigger.c < prev    next >
C/C++ Source or Header  |  1997-09-17  |  4KB  |  154 lines
  1. /* handle triggers */
  2.  
  3. #include "config.h"
  4. #include "miscfn.h"
  5.  
  6. #include <stdlib.h>
  7. #include <string.h>
  8.  
  9. #include "trigger.h"
  10. #include "header.h"
  11. #include "spec.h"
  12. #include "specP.h"
  13. #include "messages.h"
  14. #include "rpmlib.h"
  15. #include "stringbuf.h"
  16. #include "misc.h"
  17.  
  18. #define FREE(x) { if (x) free(x); }
  19. #define CHUNK 8
  20.  
  21. int addTrigger(struct PackageRec *package,
  22.            int sense, char *script, char *args)
  23. {
  24.     struct TriggerEntry *te;
  25.     int i;
  26.     char *arg = NULL;
  27.     struct ReqComp *rc = NULL;
  28.     char *version;
  29.  
  30.     /* add the script */
  31.     i = package->trigger.used++;
  32.     if (i == package->trigger.alloced) {
  33.     /* extend */
  34.     package->trigger.alloced += CHUNK;
  35.     package->trigger.triggerScripts =
  36.         realloc(package->trigger.triggerScripts,
  37.             package->trigger.alloced *
  38.             sizeof(*(package->trigger.triggerScripts)));
  39.     }
  40.     package->trigger.triggerScripts[i] = strdup(script);
  41.     rpmMessage(RPMMESS_DEBUG, "TRIGGER %d:\n%s", i, script);
  42.  
  43.     /* create the entry (or entries) */
  44.     te = NULL;
  45.     while (arg || (arg = strtok(args, " ,\t\n"))) {
  46.     if (!te) {
  47.         te = malloc(sizeof(*te));
  48.         te->flags = sense;
  49.     }
  50.     if ((version = strtok(NULL, " ,\t\n"))) {
  51.         rc = ReqComparisons;
  52.         while (rc->token && strcmp(version, rc->token)) {
  53.         rc++;
  54.         }
  55.         if (rc->token) {
  56.         /* read a version */
  57.         te->flags |= rc->flags;
  58.         version = strtok(NULL, " ,\t\n");
  59.         }
  60.     }
  61.     if ((te->flags & RPMSENSE_SENSEMASK) && !version) {
  62.         rpmError(RPMERR_BADSPEC, "Version required in trigger");
  63.         return RPMERR_BADSPEC;
  64.     }
  65.     te->name = strdup(arg);
  66.     te->version = (rc && rc->token && version) ? strdup(version) : NULL;
  67.     te->index = i;
  68.  
  69.     rpmMessage(RPMMESS_DEBUG, "TRIGGER(%s): %s %s %s %d\n",
  70.            (sense == RPMSENSE_TRIGGER_IN) ? "in" : "un",
  71.            te->name,
  72.            (rc && rc->token) ? rc->token : "NONE",
  73.            te->version, te->index);
  74.     
  75.     /* link it in */
  76.     te->next = package->trigger.trigger;
  77.     package->trigger.trigger = te;
  78.     package->trigger.triggerCount++;
  79.     te = NULL;
  80.  
  81.     /* prepare for next round */
  82.     arg = NULL;
  83.     if (! (rc && rc->token)) {
  84.         /* No version -- we just read a name */
  85.         arg = version;
  86.     }
  87.     args = NULL;
  88.     }
  89.  
  90.     return 0;
  91. }
  92.  
  93. void generateTriggerEntries(Header h, struct PackageRec *p)
  94. {
  95.     struct TriggerEntry *te;
  96.     int i;
  97.     char **nameArray;
  98.     char **versionArray;
  99.     int_32 *flagArray;
  100.     int_32 *indexArray;
  101.  
  102.     /* Add the scripts */
  103.     
  104.     if (p->trigger.used) {
  105.     headerAddEntry(h, RPMTAG_TRIGGERSCRIPTS, RPM_STRING_ARRAY_TYPE,
  106.          p->trigger.triggerScripts, p->trigger.used);
  107.     }
  108.  
  109.     /* Add the entries */
  110.  
  111.     if (p->trigger.triggerCount) {
  112.     nameArray = malloc(p->trigger.triggerCount * sizeof(*nameArray));
  113.     versionArray = malloc(p->trigger.triggerCount * sizeof(*versionArray));
  114.     flagArray = malloc(p->trigger.triggerCount * sizeof(*flagArray));
  115.     indexArray = malloc(p->trigger.triggerCount * sizeof(*indexArray));
  116.     
  117.     te = p->trigger.trigger;
  118.     i = 0;
  119.     while (te) {
  120.         nameArray[i] = te->name;
  121.         versionArray[i] = te->version ? te->version : "";
  122.         flagArray[i] = te->flags;
  123.         indexArray[i] = te->index;
  124.         i++;
  125.         te = te->next;
  126.     }
  127.     
  128.     headerAddEntry(h, RPMTAG_TRIGGERNAME, RPM_STRING_ARRAY_TYPE, nameArray, i);
  129.     headerAddEntry(h, RPMTAG_TRIGGERVERSION, RPM_STRING_ARRAY_TYPE, versionArray, i);
  130.     headerAddEntry(h, RPMTAG_TRIGGERFLAGS, RPM_INT32_TYPE, flagArray, i);
  131.     headerAddEntry(h, RPMTAG_TRIGGERINDEX, RPM_INT32_TYPE, indexArray, i);
  132.     }
  133. }
  134.  
  135. void freeTriggers(struct TriggerStruct t)
  136. {
  137.     char **s;
  138.     struct TriggerEntry *te;
  139.     
  140.     s = t.triggerScripts;
  141.     while (t.used--) {
  142.     FREE(*s++);
  143.     }
  144.     FREE(t.triggerScripts);
  145.  
  146.     while (t.trigger) {
  147.     te = t.trigger;
  148.     t.trigger = t.trigger->next;
  149.     FREE(te->name);
  150.     FREE(te->version);
  151.     free(te);
  152.     }
  153. }
  154.