tools/repo_updateinfoxml.c

   1 /*
   2  * Copyright (c) 2007, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 #define DO_ARRAY 1
   9
  10 #define _GNU_SOURCE
  11 #include <sys/types.h>
  12 #include <limits.h>
  13 #include <fcntl.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <expat.h>
  18
  19 #include "pool.h"
  20 #include "repo.h"
  21 #include "repo_updateinfoxml.h"
  22 #define DISABLE_SPLIT
  23 #include "tools_util.h"
  24
  25 /*
  26  * <updates>
  27  *   <update from="rel-eng@fedoraproject.org" status="stable" type="security" version="1.4">
  28  *     <id>FEDORA-2007-4594</id>
  29  *     <title>imlib-1.9.15-6.fc8</title>
  30  *     <release>Fedora 8</release>
  31  *     <issued date="2007-12-28 16:42:30"/>
  32  *     <references>
  33  *       <reference href="https://bugzilla.redhat.com/show_bug.cgi?id=426091" id="426091" title="CVE-2007-3568 imlib: infinite loop DoS using crafted BMP image" type="bugzilla"/>
  34  *     </references>
  35  *     <description>This update includes a fix for a denial-of-service issue (CVE-2007-3568) whereby an attacker who could get an imlib-using user to view a  specially-crafted BMP image could cause the user's CPU to go into an infinite loop.</description>
  36  *     <pkglist>
  37  *       <collection short="F8">
  38  *         <name>Fedora 8</name>
  39  *         <package arch="ppc64" name="imlib-debuginfo" release="6.fc8" src="http://download.fedoraproject.org/pub/fedora/linux/updates/8/ppc64/imlib-debuginfo-1.9.15-6.fc8.ppc64.rpm" version="1.9.15">
  40  *           <filename>imlib-debuginfo-1.9.15-6.fc8.ppc64.rpm</filename>
  41  *           <reboot_suggested>True</reboot_suggested>
  42  *         </package>
  43  *       </collection>
  44  *     </pkglist>
  45  *   </update>
  46  * </updates>
  47 */
  48
  49 enum state {
  50   STATE_START,
  51   STATE_UPDATES,      /* 1 */
  52   STATE_UPDATE,       /* 2 */
  53   STATE_ID,           /* 3 */
  54   STATE_TITLE,        /* 4 */
  55   STATE_RELEASE,      /* 5 */
  56   STATE_ISSUED,       /* 6 */
  57   STATE_MESSAGE,      /* 7 */
  58   STATE_REFERENCES,   /* 8 */
  59   STATE_REFERENCE,    /* 9 */
  60   STATE_DESCRIPTION,  /* 10 */
  61   STATE_PKGLIST,     /* 11 */
  62   STATE_COLLECTION,  /* 12 */
  63   STATE_NAME,        /* 13 */
  64   STATE_PACKAGE,     /* 14 */
  65   STATE_FILENAME,    /* 15 */
  66   STATE_REBOOT,      /* 16 */
  67   STATE_RESTART,     /* 17 */
  68   STATE_RELOGIN,     /* 18 */
  69   NUMSTATES
  70 };
  71
  72 struct stateswitch {
  73   enum state from;
  74   char *ename;
  75   enum state to;
  76   int docontent;
  77 };
  78
  79
  80 /* !! must be sorted by first column !! */
  81 static struct stateswitch stateswitches[] = {
  82   { STATE_START,       "updates",         STATE_UPDATES,     0 },
  83   { STATE_START,       "update",          STATE_UPDATE,      0 },
  84   { STATE_UPDATES,     "update",          STATE_UPDATE,      0 },
  85   { STATE_UPDATE,      "id",              STATE_ID,          1 },
  86   { STATE_UPDATE,      "title",           STATE_TITLE,       1 },
  87   { STATE_UPDATE,      "release",         STATE_RELEASE,     1 },
  88   { STATE_UPDATE,      "issued",          STATE_ISSUED,      1 },
  89   { STATE_UPDATE,      "description",     STATE_DESCRIPTION, 1 },
  90   { STATE_UPDATE,      "message",         STATE_MESSAGE    , 1 },
  91   { STATE_UPDATE,      "references",      STATE_REFERENCES,  0 },
  92   { STATE_UPDATE,      "pkglist",         STATE_PKGLIST,     0 },
  93   { STATE_REFERENCES,  "reference",       STATE_REFERENCE,   0 },
  94   { STATE_PKGLIST,     "collection",      STATE_COLLECTION,  0 },
  95   { STATE_COLLECTION,  "name",            STATE_NAME,        1 },
  96   { STATE_COLLECTION,  "package",         STATE_PACKAGE,     0 },
  97   { STATE_PACKAGE,     "filename",        STATE_FILENAME,    1 },
  98   { STATE_PACKAGE,     "reboot_suggested",STATE_REBOOT,      1 },
  99   { STATE_PACKAGE,     "restart_suggested",STATE_RESTART,    1 },
 100   { STATE_PACKAGE,     "relogin_suggested",STATE_RELOGIN,    1 },
 101   { NUMSTATES }
 102 };
 103
 104 struct parsedata {
 105   int depth;
 106   enum state state;
 107   int statedepth;
 108   char *content;
 109   int lcontent;
 110   int acontent;
 111   int docontent;
 112   Pool *pool;
 113   Repo *repo;
 114   Repodata *data;
 115   unsigned int datanum;
 116   Solvable *solvable;
 117   unsigned int timestamp;
 118
 119
 120   struct stateswitch *swtab[NUMSTATES];
 121   enum state sbtab[NUMSTATES];
 122   char *tempstr;
 123   int ltemp;
 124   int atemp;
 125 };
 126
 127 /*
 128  * if we have seen a <filename>...
 129  * inside of <package>...
 130  *
 131  *
 132  * If not, we must insert an empty filename to UPDATE_COLLECTION_FILENAME
 133  * at </package> in order to keep all UPDATE_COLLECTION_* arrays in sync
 134  */
 135
 136 static int package_filename_seen = 0;
 137 static int package_flags = 0; /* same for reboot/restart flags, to be written at </package> */
 138
 139 /*
 140  * create evr (as Id) from 'epoch', 'version' and 'release' attributes
 141  */
 142
 143 static Id
 144 makeevr_atts(Pool *pool, struct parsedata *pd, const char **atts)
 145 {
 146   const char *e, *v, *r, *v2;
 147   char *c;
 148   int l;
 149
 150   e = v = r = 0;
 151   for (; *atts; atts += 2)
 152     {
 153       if (!strcmp(*atts, "epoch"))
 154         e = atts[1];
 155       else if (!strcmp(*atts, "version"))
 156         v = atts[1];
 157       else if (!strcmp(*atts, "release"))
 158         r = atts[1];
 159     }
 160   if (e && !strcmp(e, "0"))
 161     e = 0;
 162   if (v && !e)
 163     {
 164       for (v2 = v; *v2 >= '0' && *v2 <= '9'; v2++)
 165         ;
 166       if (v2 > v && *v2 == ':')
 167         e = "0";
 168     }
 169   l = 1;
 170   if (e)
 171     l += strlen(e) + 1;
 172   if (v)
 173     l += strlen(v);
 174   if (r)
 175     l += strlen(r) + 1;
 176   if (l > pd->acontent)
 177     {
 178       pd->content = realloc(pd->content, l + 256);
 179       pd->acontent = l + 256;
 180     }
 181   c = pd->content;
 182   if (e)
 183     {
 184       strcpy(c, e);
 185       c += strlen(c);
 186       *c++ = ':';
 187     }
 188   if (v)
 189     {
 190       strcpy(c, v);
 191       c += strlen(c);
 192     }
 193   if (r)
 194     {
 195       *c++ = '-';
 196       strcpy(c, r);
 197       c += strlen(c);
 198     }
 199   *c = 0;
 200   if (!*pd->content)
 201     return 0;
 202 #if 0
 203   fprintf(stderr, "evr: %s\n", pd->content);
 204 #endif
 205   return str2id(pool, pd->content, 1);
 206 }
 207
 208
 209
 210 static void XMLCALL
 211 startElement(void *userData, const char *name, const char **atts)
 212 {
 213   struct parsedata *pd = userData;
 214   Pool *pool = pd->pool;
 215   Solvable *solvable = pd->solvable;
 216   struct stateswitch *sw;
 217   /*const char *str; */
 218
 219 #if 0
 220   fprintf(stderr, "start: [%d]%s\n", pd->state, name);
 221 #endif
 222   if (pd->depth != pd->statedepth)
 223     {
 224       pd->depth++;
 225       return;
 226     }
 227
 228   pd->depth++;
 229   if (!pd->swtab[pd->state])
 230     return;
 231   for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)  /* find name in statetable */
 232     if (!strcmp(sw->ename, name))
 233       break;
 234
 235   if (sw->from != pd->state)
 236     {
 237 #if 1
 238       fprintf(stderr, "into unknown: %s (from: %d)\n", name, pd->state);
 239       exit( 1 );
 240 #endif
 241       return;
 242     }
 243   pd->state = sw->to;
 244   pd->docontent = sw->docontent;
 245   pd->statedepth = pd->depth;
 246   pd->lcontent = 0;
 247   *pd->content = 0;
 248
 249   switch(pd->state)
 250     {
 251     case STATE_START:
 252       break;
 253     case STATE_UPDATES:
 254       break;
 255       /*
 256        * <update from="rel-eng@fedoraproject.org"
 257        *         status="stable"
 258        *         type="bugfix" (enhancement, security)
 259        *         version="1.4">
 260        */
 261     case STATE_UPDATE:
 262       {
 263         const char *from = 0, *status = 0, *type = 0, *version = 0;
 264         for (; *atts; atts += 2)
 265           {
 266             if (!strcmp(*atts, "from"))
 267               from = atts[1];
 268             else if (!strcmp(*atts, "status"))
 269               status = atts[1];
 270             else if (!strcmp(*atts, "type"))
 271               type = atts[1];
 272             else if (!strcmp(*atts, "version"))
 273               version = atts[1];
 274           }
 275
 276
 277         solvable = pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
 278         pd->datanum = (pd->solvable - pool->solvables) - pd->repo->start;
 279         repodata_extend(pd->data, pd->solvable - pool->solvables);
 280         repodata_extend(pd->data, pd->solvable - pool->solvables);
 281         pd->datanum = repodata_get_handle(pd->data, pd->datanum);
 282
 283
 284         solvable->vendor = str2id(pool, from, 1);
 285         solvable->evr = str2id(pool, version, 1);
 286         solvable->arch = ARCH_NOARCH;
 287         repodata_set_str(pd->data, pd->datanum, SOLVABLE_PATCHCATEGORY, type);
 288       }
 289       break;
 290       /* <id>FEDORA-2007-4594</id> */
 291     case STATE_ID:
 292       break;
 293       /* <title>imlib-1.9.15-6.fc8</title> */
 294     case STATE_TITLE:
 295       break;
 296       /* <release>Fedora 8</release> */
 297     case STATE_RELEASE:
 298       break;
 299       /*  <issued date="2008-03-21 21:36:55"/>
 300       */
 301     case STATE_ISSUED:
 302       {
 303         const char *date = 0;
 304         for (; *atts; atts += 2)
 305           {
 306             if (!strcmp(*atts, "date"))
 307               date = atts[1];
 308           }
 309         repodata_set_str(pd->data, pd->datanum, SOLVABLE_BUILDTIME, date);
 310       }
 311       break;
 312     case STATE_REFERENCES:
 313       break;
 314       /*  <reference href="https://bugzilla.redhat.com/show_bug.cgi?id=330471"
 315        *             id="330471"
 316        *             title="LDAP schema file missing for dhcpd"
 317        *             type="bugzilla"/>
 318        */
 319     case STATE_REFERENCE:
 320       {
 321         const char *href = 0, *id = 0, *title = 0, *type = 0;
 322         for (; *atts; atts += 2)
 323           {
 324             if (!strcmp(*atts, "href"))
 325               href = atts[1];
 326             else if (!strcmp(*atts, "id"))
 327               id = atts[1];
 328             else if (!strcmp(*atts, "title"))
 329               title = atts[1];
 330             else if (!strcmp(*atts, "type"))
 331               type = atts[1];
 332           }
 333 #if DO_ARRAY
 334         repodata_add_poolstr_array(pd->data, pd->datanum, UPDATE_REFERENCE_HREF, href);
 335         repodata_add_poolstr_array(pd->data, pd->datanum, UPDATE_REFERENCE_ID, id);
 336         repodata_add_poolstr_array(pd->data, pd->datanum, UPDATE_REFERENCE_TITLE, title);
 337         repodata_add_poolstr_array(pd->data, pd->datanum, UPDATE_REFERENCE_TYPE, type);
 338 #endif
 339       }
 340       break;
 341       /* <description>This update ...</description> */
 342     case STATE_DESCRIPTION:
 343       break;
 344       /* <message type="confirm">This update ...</message> */
 345     case STATE_MESSAGE:
 346       break;
 347     case STATE_PKGLIST:
 348       break;
 349       /* <collection short="F8" */
 350     case STATE_COLLECTION:
 351       break;
 352       /* <name>Fedora 8</name> */
 353     case STATE_NAME:
 354       break;
 355       /*   <package arch="ppc64" name="imlib-debuginfo" release="6.fc8"
 356        *            src="http://download.fedoraproject.org/pub/fedora/linux/updates/8/ppc64/imlib-debuginfo-1.9.15-6.fc8.ppc64.rpm"
 357        *            version="1.9.15">
 358        *
 359        *
 360        * -> patch.conflicts: {name} < {version}.{release}
 361        */
 362     case STATE_PACKAGE:
 363       {
 364         const char *arch = 0, *name = 0, *src = 0;
 365         Id evr = makeevr_atts(pool, pd, atts); /* parse "epoch", "version", "release" */
 366         Id n, a, na;
 367         Id rel_id;
 368
 369
 370         /* reset package_* markers, to be evaluated at </package> */
 371         package_filename_seen = 0;
 372         package_flags = 0;
 373
 374
 375         for (; *atts; atts += 2)
 376           {
 377             if (!strcmp(*atts, "arch"))
 378               arch = atts[1];
 379             else if (!strcmp(*atts, "name"))
 380               name = atts[1];
 381             else if (!strcmp(*atts, "src"))
 382               src = atts[1];
 383           }
 384         /* generated Ids for name and arch */
 385         n = str2id(pool, name, 1);
 386         if (arch)
 387           a = str2id(pool, arch, 1);
 388         else
 389           a = ARCH_NOARCH;
 390         /*  now combine both to a single Id */
 391         na = rel2id(pool, n, a, REL_ARCH, 1);
 392
 393
 394         rel_id = rel2id(pool, na, evr, REL_LT, 1);
 395
 396         solvable->conflicts = repo_addid_dep(pd->repo, solvable->conflicts, rel_id, 0);
 397 #if DO_ARRAY
 398         repodata_add_idarray(pd->data, pd->datanum, UPDATE_COLLECTION_NAME, n);
 399         repodata_add_idarray(pd->data, pd->datanum, UPDATE_COLLECTION_EVR, evr);
 400         repodata_add_idarray(pd->data, pd->datanum, UPDATE_COLLECTION_ARCH, a);
 401 #else
 402         /* _FILENAME and _FLAGS are written at </package> */
 403         if (1) {
 404           const char *evrstr = id2str(pool, evr);
 405           int buflen = strlen(name) + 1 + strlen(evrstr) + 1 + strlen(arch?arch:"") + 1;
 406           char *buf;
 407           if (!arch) arch = "";
 408           buf = (char *)malloc(buflen);
 409           if (!buf) exit(1);
 410           sprintf(buf, "%s %s %s", name, evrstr, arch);
 411           repodata_add_poolstr_array(pd->data, pd->datanum, UPDATE_COLLECTION, buf);
 412           free(buf);
 413         }
 414 #endif
 415       }
 416       break;
 417       /* <filename>libntlm-0.4.2-1.fc8.x86_64.rpm</filename> */
 418       /* <filename>libntlm-0.4.2-1.fc8.x86_64.rpm</filename> */
 419     case STATE_FILENAME:
 420       break;
 421       /* <reboot_suggested>True</reboot_suggested> */
 422     case STATE_REBOOT:
 423       break;
 424       /* <restart_suggested>True</restart_suggested> */
 425     case STATE_RESTART:
 426       break;
 427       /* <relogin_suggested>True</relogin_suggested> */
 428     case STATE_RELOGIN:
 429       break;
 430     default:
 431       break;
 432     }
 433   return;
 434 }
 435
 436
 437 static void XMLCALL
 438 endElement(void *userData, const char *name)
 439 {
 440   struct parsedata *pd = userData;
 441   Pool *pool = pd->pool;
 442   Solvable *s = pd->solvable;
 443   Repo *repo = pd->repo;
 444
 445 #if 0
 446       fprintf(stderr, "end: %s\n", name);
 447 #endif
 448   if (pd->depth != pd->statedepth)
 449     {
 450       pd->depth--;
 451 #if 1
 452       fprintf(stderr, "back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
 453 #endif
 454       return;
 455     }
 456
 457   pd->depth--;
 458   pd->statedepth--;
 459   switch (pd->state)
 460     {
 461     case STATE_START:
 462       break;
 463     case STATE_UPDATES:
 464       break;
 465     case STATE_UPDATE:
 466       s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
 467       break;
 468     case STATE_ID:
 469       {
 470         if (pd->content)
 471           {
 472             s->name = str2id(pool, join2("patch", ":", pd->content), 1);
 473           }
 474       }
 475       break;
 476       /* <title>imlib-1.9.15-6.fc8</title> */
 477     case STATE_TITLE:
 478       {
 479         while (pd->lcontent > 0
 480                && *(pd->content + pd->lcontent - 1) == '\n')
 481           {
 482             --pd->lcontent;
 483             *(pd->content + pd->lcontent) = 0;
 484           }
 485         repodata_set_str(pd->data, pd->datanum, SOLVABLE_SUMMARY, pd->content);
 486       }
 487       break;
 488       /*
 489        * <release>Fedora 8</release>
 490        */
 491     case STATE_RELEASE:
 492       break;
 493     case STATE_ISSUED:
 494       break;
 495     case STATE_REFERENCES:
 496       break;
 497     case STATE_REFERENCE:
 498       break;
 499       /*
 500        * <description>This update ...</description>
 501        */
 502     case STATE_DESCRIPTION:
 503       {
 504         repodata_set_str(pd->data, pd->datanum, SOLVABLE_DESCRIPTION, pd->content);
 505       }
 506       break;
 507       /*
 508        * <message>Warning! ...</message>
 509        */
 510     case STATE_MESSAGE:
 511       {
 512         repodata_set_str(pd->data, pd->datanum, UPDATE_MESSAGE, pd->content);
 513       }
 514       break;
 515     case STATE_PKGLIST:
 516       break;
 517     case STATE_COLLECTION:
 518       break;
 519     case STATE_NAME:
 520       break;
 521     case STATE_PACKAGE:
 522       {
 523 #if DO_ARRAY
 524         /* write _FILENAME and _FLAGS at </package>
 525          * to ensure all UPDATE_COLLECTION_* arrays are filled in parallel
 526          */
 527         if (!package_filename_seen)
 528           {
 529             repodata_add_poolstr_array(pd->data, pd->datanum, UPDATE_COLLECTION_FILENAME, "");
 530           }
 531         repodata_add_idarray(pd->data, pd->datanum, UPDATE_COLLECTION_FLAGS, package_flags+1);
 532 #endif
 533       }
 534       break;
 535       /* <filename>libntlm-0.4.2-1.fc8.x86_64.rpm</filename> */
 536       /* <filename>libntlm-0.4.2-1.fc8.x86_64.rpm</filename> */
 537     case STATE_FILENAME:
 538       {
 539 #if DO_ARRAY
 540         repodata_add_poolstr_array(pd->data, pd->datanum, UPDATE_COLLECTION_FILENAME, pd->content);
 541         package_filename_seen = 1;
 542 #endif
 543       }
 544       break;
 545       /* <reboot_suggested>True</reboot_suggested> */
 546     case STATE_REBOOT:
 547       {
 548         if (pd->content
 549             && (pd->content[0] == 'T'
 550                 || pd->content[0] == 't'|| pd->content[0] == '1'))
 551           {
 552             /* FIXME: this is per-package, the global flag should be computed at runtime */
 553             repodata_set_void(pd->data, pd->datanum, UPDATE_REBOOT);
 554             package_flags = 1;
 555           }
 556       }
 557       break;
 558       /* <restart_suggested>True</restart_suggested> */
 559     case STATE_RESTART:
 560       {
 561         if (pd->content
 562             && (pd->content[0] == 'T'
 563                 || pd->content[0] == 't' || pd->content[0] == '1'))
 564           {
 565             /* FIXME: this is per-package, the global flag should be computed at runtime */
 566             repodata_set_void(pd->data, pd->datanum, UPDATE_RESTART);
 567             package_flags = 2;
 568           }
 569       }
 570       break;
 571       /* <relogin_suggested>True</relogin_suggested> */
 572     case STATE_RELOGIN:
 573       {
 574         if (pd->content
 575             && (pd->content[0] == 'T'
 576                 || pd->content[0] == 't' || pd->content[0] == '1'))
 577           {
 578             /* FIXME: this is per-package, the global flag should be computed at runtime */
 579             repodata_set_void(pd->data, pd->datanum, UPDATE_RELOGIN);
 580             package_flags = 2;
 581           }
 582       }
 583       break;
 584     default:
 585       break;
 586     }
 587
 588   pd->state = pd->sbtab[pd->state];
 589   pd->docontent = 0;
 590 }
 591
 592
 593 static void XMLCALL
 594 characterData(void *userData, const XML_Char *s, int len)
 595 {
 596   struct parsedata *pd = userData;
 597   int l;
 598   char *c;
 599
 600   if (!pd->docontent)
 601     {
 602 #if 0
 603       fprintf(stderr, "Content: [%d]'%.*s'\n", pd->state, len, s);
 604 #endif
 605       return;
 606     }
 607   l = pd->lcontent + len + 1;
 608   if (l > pd->acontent)
 609     {
 610       pd->content = realloc(pd->content, l + 256);
 611       pd->acontent = l + 256;
 612     }
 613   c = pd->content + pd->lcontent;
 614   pd->lcontent += len;
 615   while (len-- > 0)
 616     *c++ = *s++;
 617   *c = 0;
 618 }
 619
 620
 621 #define BUFF_SIZE 8192
 622
 623 void
 624 repo_add_updateinfoxml(Repo *repo, FILE *fp, int flags)
 625 {
 626   Pool *pool = repo->pool;
 627   struct parsedata pd;
 628   char buf[BUFF_SIZE];
 629   int i, l;
 630   struct stateswitch *sw;
 631
 632   memset(&pd, 0, sizeof(pd));
 633   for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
 634     {
 635       if (!pd.swtab[sw->from])
 636         pd.swtab[sw->from] = sw;
 637       pd.sbtab[sw->to] = sw->from;
 638     }
 639   pd.pool = pool;
 640   pd.repo = repo;
 641   pd.data = repo_add_repodata(pd.repo, 0);
 642
 643   pd.content = malloc(256);
 644   pd.acontent = 256;
 645   pd.lcontent = 0;
 646   pd.tempstr = malloc(256);
 647   pd.atemp = 256;
 648   pd.ltemp = 0;
 649   XML_Parser parser = XML_ParserCreate(NULL);
 650   XML_SetUserData(parser, &pd);
 651   XML_SetElementHandler(parser, startElement, endElement);
 652   XML_SetCharacterDataHandler(parser, characterData);
 653   for (;;)
 654     {
 655       l = fread(buf, 1, sizeof(buf), fp);
 656       if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
 657         {
 658           fprintf(stderr, "repo_updateinfoxml: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
 659           exit(1);
 660         }
 661       if (l == 0)
 662         break;
 663     }
 664   XML_ParserFree(parser);
 665
 666   if (pd.data)
 667     repodata_internalize(pd.data);
 668
 669   free(pd.content);
 670   join_freemem();
 671 }
 672
 673 /* EOF */