home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 August / PCO0897.ISO / filesbbs / os2 / plnk065.arj / PLNK065.ZIP / pilot-link.0.6.5 / libsock / pi-file.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-23  |  22.0 KB  |  953 lines
  1. /* 
  2.  * Pilot File Interface Library
  3.  * Pace Willisson <pace@blitz.com> December 1996
  4.  * Additions by Kenneth Albanowski
  5.  *
  6.  * This is free software, licensed under the GNU Public License V2.
  7.  * See the file COPYING for details.
  8.  *
  9.  * the following is extracted from the combined wisdom of
  10.  * PDB by Kevin L. Flynn
  11.  * install-prc by Brian J. Swetland, D. Jeff Dionne and Kenneth Albanowski
  12.  * makedoc7 by Pat Beirne, <patb@corel.com>
  13.  * and the include files from the pilot SDK
  14.  */
  15.  
  16.  
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20. #include <time.h>
  21.  
  22. #include "pi-source.h"
  23. #include "pi-socket.h"
  24. #include "pi-file.h"
  25.  
  26. #define pi_mktag(c1,c2,c3,c4) (((c1)<<24)|((c2)<<16)|((c3)<<8)|(c4))
  27.  
  28. /*
  29.  * header:
  30.  * 32        name
  31.  * 2        flags
  32.  * 2        version
  33.  * 4        creation time
  34.  * 4         modification time
  35.  * 4        backup time
  36.  * 4        modification number
  37.  * 4        app info offset 
  38.  * 4        sort info offset
  39.  * 4        type
  40.  * 4        creator
  41.  * 4        uniq id seed (I think it is just garbage)
  42.  * 4        next record list id (normally 0, or ptr to extended hdr)
  43.  * 2        num records for this header
  44.  * Hypothetically plus 2 more bytes if an extended or perhaps secondary header (not supported)
  45.  *
  46.  * if the low bit of attr is on, then next thing is a list of resource entry
  47.  * descriptors:
  48.  *
  49.  * resource entry header
  50.  * 4        type
  51.  * 2        id
  52.  * 4        offset
  53.  *
  54.  * otherwise, if the low bit of attr is off, the next thing is a list of
  55.  * record entry decriptors:
  56.  *
  57.  * record entry header
  58.  * 4        offset
  59.  * 1        record attributes
  60.  * 3        unique id
  61.  *
  62.  * then two bytes of unknown purpose, \0\0 seems safe
  63.  *
  64.  * next, the app_info, if any, then the sort_info, if any
  65.  *
  66.  * then the space used the data. Every offset is an offset from the beginning of the
  67.  * file, and will point until this area. Each block starts at the given offset and
  68.  * ends at the beginning of the next block. The last block ends at the end of the file.
  69.  */
  70.  
  71. #define PI_HDR_SIZE 78
  72. #define PI_RESOURCE_ENT_SIZE 10
  73. #define PI_RECORD_ENT_SIZE 8
  74.  
  75. struct pi_file_entry {
  76.   int offset;
  77.   int size;
  78.   unsigned long type;
  79.   int id;
  80.   int attrs;
  81.   pi_uid_t uid;
  82. };
  83.  
  84. struct pi_file {
  85.   int err;
  86.   int for_writing;
  87.   FILE *f;
  88.   FILE *tmpf;
  89.   char *file_name;
  90.  
  91.   struct DBInfo info;
  92.   int app_info_size;
  93.   void *app_info;
  94.   int sort_info_size;
  95.   void *sort_info;
  96.   int next_record_list_id;
  97.   int resource_flag;
  98.   int ent_hdr_size;
  99.  
  100.   unsigned long unique_id_seed;
  101.   int nentries;
  102.   int nentries_allocated;
  103.   struct pi_file_entry *entries;
  104.  
  105.   void *rbuf;
  106.   int rbuf_size;
  107. };
  108.  
  109. static int pi_file_close_for_write (struct pi_file *pf);
  110. static void pi_file_free (struct pi_file *pf);
  111.  
  112. /* this seems to work, but what about leap years? */
  113. /*#define PILOT_TIME_DELTA (((unsigned)(1970 - 1904) * 365 * 24 * 60 * 60) + 1450800)*/
  114.  
  115. /* Exact value of "Jan 1, 1970 0:00:00 GMT" - "Jan 1, 1904 0:00:00 GMT" */
  116. #define PILOT_TIME_DELTA (unsigned)(2082844800)
  117.  
  118.  
  119. /* FIXME: These conversion functions apply no timezone correction. UNIX uses
  120.    UTC for time_t's, while the Pilot uses local time for database backup
  121.    time and appointments, etc. It is not particularly simple to convert
  122.    between these in UNIX, especially since the Pilot's local time is
  123.    unknown, and if syncing over political boundries, could easily be
  124.    different then the local time on the UNIX box. Since the Pilot does not
  125.    know what timezone it is in, there is no unambiguous way to correct for
  126.    this.
  127.    
  128.    Worse, the creation date for a program is stored in the local time _of
  129.    the computer which did the final linking of that program_. Again, the
  130.    Pilot does not store the timezone information needed to reconstruct
  131.    where/when this was.
  132.    
  133.    A better immediate tack would be to dissect these into struct tm's, and
  134.    return those.
  135.                                                                      --KJA
  136.    */
  137.    
  138. static time_t
  139. pilot_time_to_unix_time (unsigned long raw_time)
  140. {
  141.   return (time_t)(raw_time - PILOT_TIME_DELTA);
  142. }
  143.  
  144. static unsigned long
  145. unix_time_to_pilot_time (time_t t)
  146. {
  147.   return (unsigned long)((unsigned long)t + PILOT_TIME_DELTA);
  148. }
  149.  
  150. /*
  151.  * open .prc or .pdb file for reading
  152.  */
  153. struct pi_file *
  154. pi_file_open (char *name)
  155. {
  156.   struct pi_file *pf;
  157.   struct DBInfo *ip;
  158.   unsigned char buf[PI_HDR_SIZE];
  159.   unsigned char *p;
  160.   int file_size;
  161.   unsigned long offset, app_info_offset, sort_info_offset;
  162.   int total_hdr_size;
  163.   int i;
  164.   struct pi_file_entry *entp;
  165.  
  166.   if ((pf = calloc (1, sizeof *pf)) == NULL)
  167.     return (NULL);
  168.  
  169.   pf->for_writing = 0;
  170.  
  171.   if ((pf->f = fopen (name, "rb")) == NULL)
  172.     goto bad;
  173.  
  174.   fseek (pf->f, 0, SEEK_END);
  175.   file_size = ftell (pf->f);
  176.   fseek (pf->f, 0, SEEK_SET);
  177.  
  178.   if (fread (buf, PI_HDR_SIZE, 1, pf->f) != (size_t)1) {
  179.     fprintf (stderr, "%s: can't read header\n", name);
  180.     goto bad;
  181.   }
  182.  
  183.   p = buf;
  184.   ip = &pf->info;
  185.  
  186.   memcpy(ip->name, p, 32);
  187.   ip->flags = get_short(p+32);
  188.   ip->version = get_short(p+34);
  189.   ip->crdate = pilot_time_to_unix_time (get_long(p+36));
  190.   ip->moddate = pilot_time_to_unix_time (get_long(p+40));
  191.   ip->backupdate = pilot_time_to_unix_time (get_long(p+44));
  192.   ip->modnum = get_long(p+48);
  193.   app_info_offset = get_long(p+52);
  194.   sort_info_offset = get_long(p+56);
  195.   ip->type = get_long(p+60);
  196.   ip->creator = get_long(p+64);
  197.   pf->unique_id_seed = get_long(p+68);
  198.   
  199.   /* record list header */
  200.   pf->next_record_list_id = get_long(p+72);
  201.   pf->nentries = get_short(p+76);
  202.  
  203. #ifdef DEBUG  
  204.   printf("pi_file_open:\n Name '%s', flags 0x%4.4X, version %d\n", ip->name, ip->flags, ip->version);
  205.   printf(" Creation date %s\n", ctime(&ip->crdate));
  206.   printf(" Modification date %s\n", ctime(&ip->moddate));
  207.   printf(" Backup date %s\n", ctime(&ip->backupdate));
  208.   printf(" Appinfo size %d, sortinfo size %d\n", pf->app_info_size, pf->sort_info_size);
  209.   printf(" Type '%s'", printlong(ip->type));
  210.   printf(" Creator '%s', seed 0x%8.8lX\n", printlong(ip->creator), pf->unique_id_seed);
  211. #endif
  212.   
  213.   if (pf->next_record_list_id != 0) {
  214.     fprintf (stderr, "%s: extended format not supported\n", name);
  215.     goto bad;
  216.   }
  217.     
  218.   if (ip->flags & dlpDBFlagResource) {
  219.     pf->resource_flag = 1;
  220.     pf->ent_hdr_size = PI_RESOURCE_ENT_SIZE;
  221.   } else {
  222.     pf->resource_flag = 0;
  223.     pf->ent_hdr_size = PI_RECORD_ENT_SIZE;
  224.   }
  225.  
  226.   if (pf->app_info_size < 0 || pf->sort_info_size < 0 || pf->nentries < 0) {
  227.     fprintf (stderr, "%s: bad header\n", name);
  228.     goto bad;
  229.   }
  230.  
  231.   total_hdr_size = PI_HDR_SIZE + pf->app_info_size + pf->sort_info_size
  232.     + pf->nentries * pf->ent_hdr_size;
  233.  
  234.   if (total_hdr_size > file_size) {
  235.     fprintf (stderr, "%s: file too short\n", name);
  236.     goto bad;
  237.   }
  238.  
  239.   offset = file_size;
  240.  
  241.   if (pf->nentries) {
  242.     if ((pf->entries = calloc (pf->nentries, sizeof *pf->entries)) == NULL)
  243.       goto bad;
  244.     
  245.     for (i = 0, entp = pf->entries; i < pf->nentries; i++, entp++) {
  246.       if (fread (buf, pf->ent_hdr_size, 1, pf->f) != (size_t)1)
  247.       goto bad;
  248.  
  249.       p = buf;
  250.       if (pf->resource_flag) {
  251.         entp->type = get_long(p);
  252.         entp->id = get_short(p+4);
  253.         entp->offset = get_long(p+6);
  254. #ifdef DEBUG
  255.         printf("Entry %d '%s' #%d @%X\n", i, printlong(entp->type), entp->id, entp->offset);
  256. #endif
  257.       } else { 
  258.         entp->offset = get_long(p);
  259.         entp->attrs = get_byte(p+4);
  260.         entp->uid = get_treble(p+5);
  261. #ifdef DEBUG
  262.         printf("Entry %d 0x%8.8X %2.2X @%X\n", i, (int)entp->uid, entp->attrs, entp->offset);
  263. #endif
  264.       }
  265.     }
  266.     
  267.     for (i = 0, entp = pf->entries+pf->nentries-1; i < pf->nentries; i++, entp--) {
  268.       entp->size = offset - entp->offset;
  269.       offset = entp->offset;
  270. #ifdef DEBUG
  271.       printf("Entry %d, size %d\n",pf->nentries-i-1, entp->size);
  272. #endif
  273.     }
  274.   }
  275.   
  276.   if (sort_info_offset) {
  277.     pf->sort_info_size = offset - sort_info_offset;
  278.     offset = sort_info_offset;
  279. #ifdef DEBUG
  280.     printf("Sort info, size %d\n",pf->sort_info_size);
  281. #endif
  282.   }
  283.  
  284.   if (app_info_offset) {
  285.     pf->app_info_size = offset - app_info_offset;
  286.     offset = app_info_offset;
  287. #ifdef DEBUG
  288.     printf("App info, size %d\n",pf->app_info_size);
  289. #endif
  290.   }
  291.  
  292.   if (pf->app_info_size == 0)
  293.     pf->app_info = NULL;
  294.   else {
  295.     if ((pf->app_info = malloc (pf->app_info_size)) == NULL)
  296.       goto bad;
  297.     fseek(pf->f, app_info_offset, SEEK_SET);
  298.     if (fread (pf->app_info, 1, pf->app_info_size, pf->f) != (size_t)pf->app_info_size)
  299.       goto bad;
  300.   }
  301.  
  302.   if (pf->sort_info_size == 0)
  303.     pf->sort_info = NULL;
  304.   else {
  305.     if ((pf->sort_info = malloc (pf->sort_info_size)) == NULL)
  306.       goto bad;
  307.     fseek(pf->f, sort_info_offset, SEEK_SET);
  308.     if (fread(pf->sort_info, 1, pf->sort_info_size, pf->f) != (size_t)pf->sort_info_size)
  309.       goto bad;
  310.   }
  311.  
  312.   return (pf);
  313.  
  314. bad:
  315.   pi_file_close (pf);
  316.   return (NULL);
  317. }
  318.  
  319. int
  320. pi_file_close (struct pi_file *pf)
  321. {
  322.   int err;
  323.   if (pf->for_writing) {
  324.     if (pi_file_close_for_write (pf) < 0)
  325.       pf->err = 1;
  326.   }
  327.  
  328.   err = pf->err;
  329.  
  330.   pi_file_free (pf);
  331.  
  332.   if (err)
  333.     return (-1);
  334.  
  335.   return (0);
  336. }
  337.  
  338. static void
  339. pi_file_free (struct pi_file *pf)
  340. {
  341.   if (pf->f)
  342.     fclose (pf->f);
  343.   if (pf->app_info)
  344.     free (pf->app_info);
  345.   if (pf->sort_info)
  346.     free (pf->sort_info);
  347.   if (pf->entries)
  348.     free (pf->entries);
  349.   if (pf->file_name)
  350.     free (pf->file_name);
  351.   if (pf->rbuf)
  352.     free(pf->rbuf);
  353.   if (pf->tmpf)
  354.     fclose (pf->tmpf);
  355.   free (pf);
  356. }
  357.  
  358. int
  359. pi_file_get_info (struct pi_file *pf, struct DBInfo *infop)
  360. {
  361.   *infop = pf->info;
  362.   return (0);
  363. }
  364.  
  365. int
  366. pi_file_get_app_info (struct pi_file *pf, void **datap, int *sizep)
  367. {
  368.   *datap = pf->app_info;
  369.   *sizep = pf->app_info_size;
  370.   return (0);
  371. }
  372.  
  373. int
  374. pi_file_get_sort_info (struct pi_file *pf, void **datap, int *sizep)
  375. {
  376.   *datap = pf->sort_info;
  377.   *sizep = pf->sort_info_size;
  378.   return (0);
  379. }
  380.  
  381. static int
  382. pi_file_set_rbuf_size (struct pi_file *pf, int size)
  383. {
  384.   int new_size;
  385.   void *rbuf;
  386.  
  387.   if (size > pf->rbuf_size) {
  388.     if (pf->rbuf_size == 0) {
  389.       new_size = 64*1024;
  390.       rbuf = malloc (new_size);
  391.     } else {
  392.       new_size = size;
  393.       rbuf = realloc (pf->rbuf, new_size);
  394.     }
  395.  
  396.     if (rbuf == NULL)
  397.       return (-1);
  398.     
  399.     pf->rbuf_size = new_size;
  400.     pf->rbuf = rbuf;
  401.   }
  402.  
  403.   return (0);
  404. }
  405.  
  406. /* returned buffer is valid until next call, or until pi_file_close */
  407. int
  408. pi_file_read_resource (struct pi_file *pf, int idx,
  409.                void **bufp, int *sizep, unsigned long *type, int *idp)
  410. {
  411.   struct DBInfo *ip;
  412.   struct pi_file_entry *entp;
  413.  
  414.   if (pf->for_writing)
  415.     return (-1);
  416.  
  417.   ip = &pf->info;
  418.  
  419.   if (!pf->resource_flag)
  420.     return (-1);
  421.  
  422.   if (idx < 0 || idx >= pf->nentries)
  423.     return (-1);
  424.  
  425.   entp = &pf->entries[idx];
  426.  
  427.   if (pi_file_set_rbuf_size (pf, entp->size) < 0)
  428.     return (-1);
  429.  
  430.   fseek (pf->f, pf->entries[idx].offset, SEEK_SET);
  431.   if (fread (pf->rbuf, 1, entp->size, pf->f) != (size_t)entp->size)
  432.     return (-1);
  433.  
  434.   if (bufp)
  435.     *bufp = pf->rbuf;
  436.   if (sizep)
  437.     *sizep = entp->size;
  438.   if (type)
  439.     *type = entp->type;
  440.   if (idp)
  441.     *idp = entp->id;
  442.   
  443.   return (0);
  444. }
  445.  
  446. /* returned buffer is valid until next call, or until pi_file_close */
  447. int
  448. pi_file_read_record (struct pi_file *pf, int idx,
  449.              void **bufp, int *sizep, int *attrp, int *catp, pi_uid_t *uidp)
  450. {
  451.   struct DBInfo *ip;
  452.   struct pi_file_entry *entp;
  453.  
  454.   if (pf->for_writing)
  455.     return (-1);
  456.  
  457.   ip = &pf->info;
  458.  
  459.   if (pf->resource_flag)
  460.     return (-1);
  461.  
  462.   if (idx < 0 || idx >= pf->nentries)
  463.     return (-1);
  464.  
  465.   entp = &pf->entries[idx];
  466.  
  467.   if (pi_file_set_rbuf_size (pf, entp->size) < 0)
  468.     return (-1);
  469.  
  470.   fseek (pf->f, pf->entries[idx].offset, SEEK_SET);
  471.   if (fread (pf->rbuf, 1, entp->size, pf->f) != (size_t)entp->size)
  472.     return (-1);
  473.  
  474.   if (bufp)
  475.     *bufp = pf->rbuf;
  476.   if (sizep)
  477.     *sizep = entp->size;
  478.   if (attrp)
  479.     *attrp = entp->attrs & 0xf0;
  480.   if (catp)
  481.     *catp = entp->attrs & 0xf;
  482.   if (uidp)
  483.     *uidp = entp->uid;
  484.  
  485.   return (0);
  486. }
  487.  
  488. int
  489. pi_file_read_record_by_id (struct pi_file *pf, pi_uid_t uid,
  490.                void **bufp, int *sizep, int *idxp, int *attrp, int *catp)
  491. {
  492.   int idx;
  493.   struct pi_file_entry *entp;
  494.  
  495.   for (idx = 0, entp = pf->entries; idx < pf->nentries; idx++, entp++) {
  496.     if (entp->uid == uid) {
  497.       if (idxp)
  498.         *idxp = idx;
  499.       return (pi_file_read_record (pf, idx, bufp, sizep, attrp, catp, &uid));
  500.     }
  501.   }
  502.  
  503.   return (-1);
  504. }
  505.  
  506. int
  507. pi_file_id_used (struct pi_file *pf, pi_uid_t uid)
  508. {
  509.   int idx;
  510.   struct pi_file_entry *entp;
  511.  
  512.   for (idx = 0, entp = pf->entries; idx < pf->nentries; idx++, entp++) {
  513.     if (entp->uid == uid)
  514.       return (1);
  515.   }
  516.   return (0);
  517. }
  518.  
  519. struct pi_file *
  520. pi_file_create (char *name, struct DBInfo * info)
  521. {
  522.   struct pi_file *pf;
  523.  
  524.   if ((pf = calloc (1, sizeof *pf)) == NULL)
  525.     return (NULL);
  526.  
  527.   if ((pf->file_name = strdup (name)) == NULL)
  528.     goto bad;
  529.  
  530.   pf->for_writing = 1;
  531.   pf->info = *info;
  532.  
  533.   if (info->flags & dlpDBFlagResource) {
  534.     pf->resource_flag = 1;
  535.     pf->ent_hdr_size = PI_RESOURCE_ENT_SIZE;
  536.   } else {
  537.     pf->resource_flag = 0;
  538.     pf->ent_hdr_size = PI_RECORD_ENT_SIZE;
  539.   }
  540.  
  541.   if ((pf->tmpf = tmpfile ()) == NULL)
  542.     goto bad;
  543.  
  544.   return (pf);
  545.  
  546. bad:
  547.   pi_file_free (pf);
  548.   return (NULL);
  549. }
  550.  
  551. /* may call these any time before close (even multiple times) */
  552. int
  553. pi_file_set_info (struct pi_file *pf, struct DBInfo *ip)
  554. {
  555.   if (!pf->for_writing)
  556.     return (-1);
  557.  
  558.   if ((ip->flags & dlpDBFlagResource) != (pf->info.flags & dlpDBFlagResource))
  559.       return (-1);
  560.  
  561.   pf->info = *ip;
  562.  
  563.   return (0);
  564. }
  565.  
  566. int
  567. pi_file_set_app_info (struct pi_file *pf, void *data, int size)
  568. {
  569.   void *p;
  570.  
  571.   if (!size) {
  572.     if (pf->app_info)
  573.       free (pf->app_info);
  574.     pf->app_info_size = 0;
  575.     return (0);
  576.   }
  577.  
  578.   if ((p = malloc (size)) == NULL)
  579.     return (-1);
  580.   memcpy (p, data, size);
  581.  
  582.   if (pf->app_info)
  583.     free (pf->app_info);
  584.   pf->app_info = p;
  585.   pf->app_info_size = size;
  586.   return (0);
  587. }
  588.   
  589. int
  590. pi_file_set_sort_info (struct pi_file *pf, void *data, int size)
  591. {
  592.   void *p;
  593.  
  594.   if (!size) {
  595.     if (pf->sort_info)
  596.       free (pf->sort_info);
  597.     pf->sort_info_size = 0;
  598.     return (0);
  599.   }
  600.  
  601.   if ((p = malloc (size)) == NULL)
  602.     return (-1);
  603.   memcpy (p, data, size);
  604.  
  605.   if (pf->sort_info)
  606.     free (pf->sort_info);
  607.   pf->sort_info = p;
  608.   pf->sort_info_size = size;
  609.   return (0);
  610. }
  611.   
  612. /*
  613.  * internal function to extend entry list if necessary, and return a
  614.  * pointer to the next available slot
  615.  */
  616. static struct pi_file_entry *
  617. pi_file_append_entry (struct pi_file *pf)
  618. {
  619.   struct DBInfo *ip;
  620.   int new_count;
  621.   int new_size;
  622.   struct pi_file_entry *new_entries;
  623.   struct pi_file_entry *entp;
  624.  
  625.   ip = &pf->info;
  626.  
  627.   if (pf->nentries >= pf->nentries_allocated) {
  628.     if (pf->nentries_allocated == 0)
  629.       new_count = 100;
  630.     else
  631.       new_count = pf->nentries_allocated * 3 / 2;
  632.     new_size = new_count * sizeof *pf->entries;
  633.  
  634.     if (pf->entries == NULL)
  635.       new_entries = malloc (new_size);
  636.     else
  637.       new_entries = realloc (pf->entries, new_size);
  638.  
  639.     if (new_entries == NULL)
  640.       return (NULL);
  641.   
  642.     pf->nentries_allocated = new_count;
  643.     pf->entries = new_entries;
  644.   }
  645.  
  646.   entp = &pf->entries[pf->nentries++];
  647.   memset (entp, 0, sizeof *entp);
  648.   return (entp);
  649. }
  650.  
  651. int
  652. pi_file_append_resource (struct pi_file *pf, void *buf, int size,
  653.              unsigned long type, int id)
  654. {
  655.   struct pi_file_entry *entp;
  656.  
  657.   if (!pf->for_writing || !pf->resource_flag)
  658.     return (-1);
  659.  
  660.   entp = pi_file_append_entry (pf);
  661.   
  662.   if (size && (fwrite (buf, size, 1, pf->tmpf) != 1)) {
  663.     pf->err = 1;
  664.     return (-1);
  665.   }
  666.  
  667.   entp->size = size;
  668.   entp->type = type;
  669.   entp->id = id;
  670.  
  671.   return (0);
  672. }
  673.  
  674. int pi_file_append_record (struct pi_file *pf, void *buf, int size,
  675.                int attrs, int category, pi_uid_t uid)
  676. {
  677.   struct pi_file_entry *entp;
  678.  
  679. #ifdef DEBUG
  680.   printf ("append: %d\n", pf->nentries);
  681. #endif
  682.  
  683.   if (!pf->for_writing || pf->resource_flag)
  684.     return (-1);
  685.  
  686.   entp = pi_file_append_entry (pf);
  687.   
  688.   if (size && (fwrite (buf, size, 1, pf->tmpf) != 1)) {
  689.     pf->err = 1;
  690.     return (-1);
  691.   }
  692.  
  693.   entp->size = size;
  694.   entp->attrs = (attrs & 0xf0) | (category & 0xf);
  695.   entp->uid = uid;
  696.  
  697.   return (0);
  698. }
  699.  
  700. int pi_file_get_entries (struct pi_file * pf, int * entries)
  701. {
  702.   *entries = pf->nentries;
  703.   
  704.   return (0);
  705. }
  706.  
  707. static int
  708. pi_file_close_for_write (struct pi_file *pf)
  709. {
  710.   FILE *f;
  711.   struct DBInfo *ip;
  712.   unsigned char buf[PI_HDR_SIZE];
  713.   unsigned char *p;
  714.   int offset;
  715.   int i;
  716.   struct pi_file_entry *entp;
  717.   int c;
  718.  
  719.   ip = &pf->info;
  720.   if (pf->nentries >= 64*1024) {
  721.     printf ("too many entries for this implentation of pi-file: %d\n",
  722.         pf->nentries);
  723.     return (-1);
  724.   }
  725.  
  726.   if ((f = fopen (pf->file_name, "wb")) == NULL)
  727.     return (-1);
  728.  
  729.   ip = &pf->info;
  730.  
  731.   offset = PI_HDR_SIZE + pf->nentries * pf->ent_hdr_size + 2;
  732.  
  733.   p = buf;
  734.   memcpy(p, ip->name, 32);
  735.   set_short(p+32, ip->flags);
  736.   set_short(p+34, ip->version);
  737.   set_long(p+36, unix_time_to_pilot_time(ip->crdate));
  738.   set_long(p+40, unix_time_to_pilot_time(ip->moddate));
  739.   set_long(p+44, unix_time_to_pilot_time(ip->backupdate));
  740.   set_long(p+48, ip->modnum);
  741.   set_long(p+52, pf->app_info_size ? offset : 0); offset += pf->app_info_size;
  742.   set_long(p+56, pf->sort_info_size ? offset : 0); offset += pf->sort_info_size;
  743.   set_long(p+60, ip->type);
  744.   set_long(p+64, ip->creator);
  745.   set_long(p+68, pf->unique_id_seed);
  746.   set_long(p+72, pf->next_record_list_id);
  747.   set_short(p+76, pf->nentries);
  748.  
  749.   if (fwrite (buf, PI_HDR_SIZE, 1, f) != 1)
  750.     goto bad;
  751.  
  752.   for (i = 0, entp = pf->entries; i < pf->nentries; i++, entp++) {
  753.     entp->offset = offset;
  754.     
  755.     p = buf;
  756.     if (pf->resource_flag) {
  757.       set_long(p, entp->type);
  758.       set_short(p+4, entp->id);
  759.       set_long(p+6, entp->offset);
  760.     } else {
  761.       set_long(p, entp->offset);
  762.       set_byte(p+4, entp->attrs);
  763.       set_treble(p+5, entp->uid);
  764.     }
  765.  
  766.     if (fwrite (buf, pf->ent_hdr_size, 1, f) != 1)
  767.       goto bad;
  768.  
  769.     offset += entp->size;
  770.   }
  771.   
  772.   /* This may just be packing */
  773.   fwrite( "\0\0", 1, 2, f);
  774.   
  775.   if (pf->app_info && (fwrite (pf->app_info, 1, pf->app_info_size, f) != (size_t)pf->app_info_size))
  776.     goto bad;
  777.  
  778.   if (pf->sort_info && (fwrite (pf->sort_info, 1, pf->sort_info_size, f) != (size_t)pf->sort_info_size))
  779.     goto bad;
  780.     
  781.  
  782.   rewind (pf->tmpf);
  783.   while ((c = getc (pf->tmpf)) != EOF)
  784.     putc (c, f);
  785.  
  786.   fflush (f);
  787.  
  788.   if (ferror (f) || feof (f))
  789.     goto bad;
  790.  
  791.   fclose (f);
  792.   return (0);
  793.  
  794. bad:
  795.   fclose (f);
  796.   return (-1);
  797. }
  798.  
  799. int pi_file_retrieve(struct pi_file * pf, int socket, int cardno)
  800. {
  801.   int db;
  802.   int l,j;
  803.   unsigned char buffer[0xffff];
  804.   if(dlp_OpenDB(socket, cardno, dlpOpenRead, pf->info.name, &db)<0)
  805.     return -1;
  806.     
  807.   l = dlp_ReadAppBlock(socket, db, 0, buffer, 0xffff);
  808.   if(l>0)
  809.     pi_file_set_app_info(pf, buffer, l);
  810.  
  811.   if(dlp_ReadOpenDBInfo(socket, db, &l)<0)
  812.     return -1;
  813.       
  814.   if(pf->info.flags & dlpDBFlagResource)
  815.     for(j=0;j<l;j++) {
  816.       unsigned long type;
  817.       int id;
  818.       int size;
  819.       if( (dlp_ReadResourceByIndex(socket, db, j, buffer, &type, &id, &size)<0) ||
  820.         (pi_file_append_resource(pf, buffer, size, type, id)<0)) {
  821.         dlp_CloseDB(socket, db);
  822.         return -1;
  823.       }
  824.     }
  825.   else
  826.     for(j=0;j<l;j++) {
  827.         unsigned long id;
  828.         int size;
  829.         int attr;
  830.         int category;
  831.         if( (dlp_ReadRecordByIndex(socket, db, j, buffer, &id, &size, &attr, &category)<0)) {
  832.           dlp_CloseDB(socket,db);
  833.           return -1;
  834.         }
  835.         /* There is no way to restore records with these attributes, so there is no
  836.            use in backing them up */
  837.         if (attr & (dlpRecAttrArchived|dlpRecAttrDeleted))
  838.           continue;
  839.         if (pi_file_append_record(pf, buffer, size, attr, category, id)<0) {
  840.             dlp_CloseDB(socket, db);
  841.             return -1;
  842.           }
  843.       }
  844.       
  845.   return dlp_CloseDB(socket, db);
  846. }      
  847.  
  848. int pi_file_install(struct pi_file * pf, int socket, int cardno)
  849. {
  850.   int db;
  851.   int l,j;
  852.   int reset = 0;
  853.   int flags;
  854.   int version;
  855.   void * buffer;
  856.   int freeai = 0;
  857.   
  858.   version = pi_version(socket);
  859.   
  860.   /* Delete DB if it already exists */
  861.   dlp_DeleteDB(socket, cardno, pf->info.name);
  862.   
  863.   /* Set up DB flags */
  864.   flags = pf->info.flags;
  865.   
  866.   if (strcmp(pf->info.name, "Graffiti ShortCuts ")==0) {
  867.     flags |= 0x8000; /* Rewrite an open DB */
  868.     reset = 1; /* To be on the safe side */
  869.   }
  870. #ifdef DEBUG
  871.   printf("Flags = %8.8X, name = '%s'\n", flags, pf->info.name);
  872. #endif
  873.   
  874.   /* Create DB*/
  875.   if(dlp_CreateDB(socket, pf->info.creator, pf->info.type, cardno,
  876.                        flags, pf->info.version,
  877.                        pf->info.name, &db)<0)
  878.     return -1;
  879.     
  880.   
  881.   pi_file_get_app_info(pf, &buffer, &l);
  882.   
  883.   /* Compensate for bug in OS 2.x Memo */
  884.   if((version > 0x0100) && (strcmp(pf->info.name, "MemoDB")==0) && (l>0) && (l<282))
  885.   {
  886.       /* Justification: The appInfo structure was accidentally lengthend in OS 2.0,
  887.          but the Memo application does not check that it is long enough, hence the
  888.          shorter block from OS 1.x will cause the 2.0 Memo application to lock up
  889.          if the sort preferences are modified. This code detects the installation
  890.          of a short app info block on a 2.0 machine, and lengthens it. This 
  891.          transformation will never lose information. */
  892.  
  893.       void * b2 = calloc(1, 282);
  894.       memcpy(b2, buffer, l);
  895.       buffer = b2;
  896.       l = 282;
  897.       freeai = 1;
  898.   }
  899.   
  900.   /* All system updates seen to have the 'ptch' type, so trigger a reboot on those */
  901.   if (pf->info.creator == pi_mktag('p','t','c','h'))
  902.     reset = 1; 
  903.    
  904.   if (pf->info.flags & dlpDBFlagReset)
  905.     reset = 1;
  906.       
  907.   if(l>0)
  908.     dlp_WriteAppBlock(socket, db, buffer, l);
  909.   
  910.   if (freeai)
  911.     free(buffer);
  912.    
  913.   /* Resource or record? */
  914.   if(pf->info.flags & dlpDBFlagResource)
  915.     for(j=0;j<pf->nentries;j++) {
  916.       unsigned long type;
  917.       int id;
  918.       int size;
  919.       if( (pi_file_read_resource(pf, j, &buffer, &size, &type, &id)<0) ||
  920.           (dlp_WriteResource(socket, db, type, id, buffer, size)<0) ) {
  921.         goto fail;
  922.       }
  923.  
  924.       /* If we see a 'boot' section, regardless of file type, require reset */
  925.       if (type == pi_mktag ('b','o','o','t')) 
  926.         reset = 1;
  927.     }
  928.   else
  929.     for(j=0;j<pf->nentries;j++) {
  930.       unsigned long id;
  931.       int size;
  932.       int attr;
  933.       int category;
  934.       if(pi_file_read_record(pf, j, &buffer, &size, &attr, &category, &id)<0)
  935.         goto fail;
  936.       if ((attr & (dlpRecAttrArchived|dlpRecAttrDeleted)) &&
  937.          (version < 0x0101))
  938.          continue; /* Old OS cannot install deleted records, so don't try */
  939.       if(dlp_WriteRecord(socket, db, attr, id, category, buffer, size, 0)<0)
  940.         goto fail;
  941.     }
  942.   
  943.   if(reset)
  944.     dlp_ResetSystem(socket);
  945.       
  946.   return dlp_CloseDB(socket, db);
  947.  
  948. fail:
  949.   dlp_CloseDB(socket, db);
  950.   dlp_DeleteDB(socket, cardno, pf->info.name);
  951.   return -1;
  952. }      
  953.