source: vital-to8-sdk/sap/libsap.c @ 1

/*  LibSAP
 *  Version 0.9.4
 *  Copyright (C) 2000-2003 Eric Botcazou
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */


#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "libsap.h"


int sap_errno;


#define FILENAME_LENGTH 128
#define MAX_ARCHIVE       8

#define SAP_MAGIC_NUM  0xB3
#define SAP_HEADER_SIZE  66
static const char sap_header[]="\0SYSTEME D'ARCHIVAGE PUKALL S.A.P. "
                               "(c) Alexandre PUKALL Avril 1998";


static const int sap_format_table[][3] = {
   { SAP_NTRACKS1, SAP_SECTSIZE1, SAP_TRACKSIZE1 },
   { SAP_NTRACKS2, SAP_SECTSIZE2, SAP_TRACKSIZE2 }
};

#define SAP_NTRACKS(f)      sap_format_table[f-SAP_FORMAT1][0]
#define SAP_SECTSIZE(f)     sap_format_table[f-SAP_FORMAT1][1]
#define SAP_TRACKSIZE(f)    sap_format_table[f-SAP_FORMAT1][2]

#define SAP_EXTSECTSIZE(f)  (SAP_SECTSIZE(f) + sizeof(sapsector_t) - SAP_SECTSIZE1)


static short int crcpuk_temp;

static short int puktable[]={
   0x0000, 0x1081, 0x2102, 0x3183,
   0x4204, 0x5285, 0x6306, 0x7387,
   0x8408, 0x9489, 0xa50a, 0xb58b,
   0xc60c, 0xd68d, 0xe70e, 0xf78f
};


#define NO_ARCHIVE     0
#define EMPTY_ARCHIVE  1
#define FILLED_ARCHIVE 2
#define FULL_ARCHIVE   3

static struct {
   int format;
   int state;
   int ntracks;
   FILE *file;
} archive[MAX_ARCHIVE+1];

#define ID_FORMAT(id)   archive[id].format
#define ID_STATE(id)    archive[id].state
#define ID_NTRACKS(id)  archive[id].ntracks
#define ID_FILE(id)     archive[id].file


/* constants for the TO logical disk format */
#define TO_NSECTS                16
#define TO_SECTOR_PER_BLOCK      8

#define TO_SECTSIZE1             255  /* not 256 */
#define TO_FAT_START1            257
#define TO_NBLOCKS1              160
#define TO_BLOCKSIZE1            (TO_SECTOR_PER_BLOCK*TO_SECTSIZE1)
#define TO_FILESIZE_MAX1         (TO_NBLOCKS1-2)
#define TO_DIR_START1            512

#define TO_SECTSIZE2             127  /* not 128 */
#define TO_FAT_START2            129
#define TO_NBLOCKS2              80
#define TO_BLOCKSIZE2            (TO_SECTOR_PER_BLOCK*TO_SECTSIZE2)
#define TO_FILESIZE_MAX2         (TO_NBLOCKS2-2)
#define TO_DIR_START2            256

#define TO_FILLER_BYTE           0xE5
#define TO_TAG_RESERVED          0xFE
#define TO_TAG_FREE              0xFF
#define TO_END_BLOCK_OFFSET      0xC0

#define TO_DIRENTRY_LENGTH       32
#define TO_NAME                  0
#define TO_NAME_LENGTH           8
#define TO_EXT                   8
#define TO_EXT_LENGTH            3
#define TO_FILE_TYPE             11
#define TO_DATA_TYPE             12
#define TO_FIRST_BLOCK           13
#define TO_END_SIZE              14
#define TO_COMMENT               16
#define TO_COMMENT_LENGTH        8
#define TO_DATE_DAY              24
#define TO_DATE_MONTH            25
#define TO_DATE_YEAR             26
#define TO_CHG_MODE              30
#define TO_CHG_CHECKSUM          31

#define TO_DIRENTRY_PER_SECTOR1  8
#define TO_NDIRENTRIES1          (TO_NSECTS-2)*TO_DIRENTRY_PER_SECTOR1

#define TO_DIRENTRY_PER_SECTOR2  4
#define TO_NDIRENTRIES2          (TO_NSECTS-2)*TO_DIRENTRY_PER_SECTOR2

static const int to_format_table[][8] = {
   { TO_SECTSIZE1, TO_FAT_START1, TO_NBLOCKS1, TO_BLOCKSIZE1,
     TO_FILESIZE_MAX1, TO_DIR_START1, TO_DIRENTRY_PER_SECTOR1, TO_NDIRENTRIES1 },
   { TO_SECTSIZE2, TO_FAT_START2, TO_NBLOCKS2, TO_BLOCKSIZE2,
     TO_FILESIZE_MAX2, TO_DIR_START2, TO_DIRENTRY_PER_SECTOR2, TO_NDIRENTRIES2 }
};

#define TO_SECTSIZE(f)             to_format_table[f-SAP_FORMAT1][0]
#define TO_FAT_START(f)            to_format_table[f-SAP_FORMAT1][1]
#define TO_NBLOCKS(f)              to_format_table[f-SAP_FORMAT1][2]
#define TO_BLOCKSIZE(f)            to_format_table[f-SAP_FORMAT1][3]
#define TO_FILESIZE_MAX(f)         to_format_table[f-SAP_FORMAT1][4]
#define TO_DIR_START(f)            to_format_table[f-SAP_FORMAT1][5]
#define TO_DIRENTRY_PER_SECTOR(f)  to_format_table[f-SAP_FORMAT1][6]
#define TO_NDIRENTRIES(f)          to_format_table[f-SAP_FORMAT1][7]


/* constants for the TO memory layout */
#define TO_BANKSIZE             16384


/* file types */
enum {
   FTYPE_BASIC,
   FTYPE_DATA,
   FTYPE_MACHINE,
   FTYPE_ASM,
   FTYPE_OTHERS,
   FTYPE_PARAGRAPHE = 0xA
};

static char ftype_sym[5] = { 'B', 'D', 'M', 'A', '*' };

enum {
   DTYPE_BINARY,
   DTYPE_ASCII = 0xFF,
   DTYPE_OTHERS = 2
};

static char dtype_sym[3] = { 'B', 'A', '*' };

struct extension_t {
   char tag[TO_EXT_LENGTH+1];
   unsigned char ftype;
   unsigned char dtype;
};

enum {
   EXT_TYPE_BAS,
   EXT_TYPE_DAT,
   EXT_TYPE_ASC,
   EXT_TYPE_ASM,
   EXT_TYPE_BIN,
   EXT_TYPE_MAP,
   EXT_TYPE_CHG,
   EXT_TYPE_CFG,
   EXT_TYPE_BAT,
   EXT_TYPE_CAR,
   EXT_TYPE_PAR,
   EXT_TYPE_UNKNOWN,
   EXT_TYPE_MAX
};

static struct extension_t ext_type[EXT_TYPE_MAX] = {
   { "BAS", FTYPE_BASIC,      DTYPE_BINARY },
   { "DAT", FTYPE_DATA,       DTYPE_ASCII  },
   { "ASC", FTYPE_DATA,       DTYPE_ASCII  },
   { "ASM", FTYPE_ASM,        DTYPE_ASCII  },
   { "BIN", FTYPE_MACHINE,    DTYPE_BINARY },
   { "MAP", FTYPE_MACHINE,    DTYPE_BINARY },
   { "CHG", FTYPE_DATA,       DTYPE_ASCII  },
   { "CFG", FTYPE_MACHINE,    DTYPE_BINARY },
   { "BAT", FTYPE_BASIC,      DTYPE_BINARY },
   { "CAR", FTYPE_DATA,       DTYPE_ASCII  },
   { "PAR", FTYPE_PARAGRAPHE, DTYPE_BINARY },
   { "???", FTYPE_MACHINE,    DTYPE_BINARY }
};


#define MIN(x,y)     (((x) < (y)) ? (x) : (y))



/************************************************/
/***    private functions: helper routines    ***/
/************************************************/


/* get_id:
 *  Finds the first empty id, returns 0 if has failed.
 */
static int get_id(void)
{
   int i;

   for (i=MAX_ARCHIVE; i>0; i--) {
      if (archive[i].state == NO_ARCHIVE)
         break;
   }

   return i;
}



/* clean_string:
 *  Helper function to clean up character strings.
 */
static inline void clean_string(unsigned char *str)
{
   while (*str) {
      if ((*str<32) || (*str>127))
         *str = '#';

      str++;
   }
}



/************************************************/
/***   private functions: SAP format support  ***/
/************************************************/


/* crc_pukall:
 *  Computes the new CRC from the c data.
 */
static void crc_pukall(short int c)
{
   short int index;

   index = (crcpuk_temp ^ c) & 0xf;
   crcpuk_temp = ((crcpuk_temp>>4) & 0xfff) ^ puktable[index];

   c >>= 4;

   index = (crcpuk_temp ^ c) & 0xf;
   crcpuk_temp = ((crcpuk_temp>>4) & 0xfff) ^ puktable[index];
}



/* do_crc:
 *  Computes the CRC for the specified SAP sector.
 */
static void do_crc(sapsector_t *sapsector, int format)
{
   int i;

   crcpuk_temp = 0xffff;

   crc_pukall(sapsector->format);
   crc_pukall(sapsector->protection);
   crc_pukall(sapsector->track);
   crc_pukall(sapsector->sector);

   for (i=0; i<SAP_SECTSIZE(format); i++)
      crc_pukall(sapsector->data[i]);
}



/* do_read_sector: 
 *  Performs the low-level read operation for the specified sector.
 */
static void do_read_sector(sapID id, sapsector_t *sapsector)
{
   unsigned char buffer[sizeof(sapsector_t)];
   int format = ID_FORMAT(id);
   int i;

   i=fread(buffer, sizeof(char), SAP_EXTSECTSIZE(format), ID_FILE(id));

   sapsector->format     = buffer[0];
   sapsector->protection = buffer[1];
   sapsector->track      = buffer[2];
   sapsector->sector     = buffer[3];

   for (i=0; i<SAP_SECTSIZE(format); i++)
       sapsector->data[i] = buffer[4+i]^SAP_MAGIC_NUM;

   sapsector->data[SAP_SECTSIZE(format)] = buffer[4+i];
   sapsector->data[SAP_SECTSIZE(format)+1] = buffer[4+i+1];
}



/* do_write_sector:
 *  Performs the low-level write operation for the specified sector.
 */
static void do_write_sector(sapID id, sapsector_t *sapsector)
{
   unsigned char buffer[sizeof(sapsector_t)];
   int format = ID_FORMAT(id);
   int i;

   /* fill in the write buffer */
   buffer[0] = sapsector->format;
   buffer[1] = sapsector->protection;
   buffer[2] = sapsector->track;
   buffer[3] = sapsector->sector;

   for (i=0; i<SAP_SECTSIZE(format); i++)
      buffer[4+i] = sapsector->data[i]^SAP_MAGIC_NUM;

   /* compute the CRC */
   do_crc(sapsector, format);
   buffer[4+i] = sapsector->data[SAP_SECTSIZE(format)] = (crcpuk_temp>>8)&0xff;
   buffer[4+i+1] = sapsector->data[SAP_SECTSIZE(format)+1] = crcpuk_temp&0xff;

   fwrite(buffer, sizeof(char), SAP_EXTSECTSIZE(format), ID_FILE(id));
}



/* seek_pos:
 *  Seeks the specified position in the SAP archive.
 */
static void seek_pos(sapID id, int track, int sect)
{
   int pos;

   pos = SAP_HEADER_SIZE + (track*SAP_NSECTS + sect-1) * SAP_EXTSECTSIZE(ID_FORMAT(id));

   fseek(ID_FILE(id), pos, SEEK_SET);
}



/************************************************/
/***  private functions: Thomson DOS support  ***/
/************************************************/



/* get_file_size:
 *  Returns the size in blocks of the specified file on disk.
 */
static int get_file_size(int format, int n, const unsigned char trk20_data[])
{
   const unsigned char *fat_data, *entry_data;
   int block, size = 0;

   fat_data = trk20_data + TO_FAT_START(format);
   entry_data = trk20_data + TO_DIR_START(format) + n*TO_DIRENTRY_LENGTH;

   block = entry_data[TO_FIRST_BLOCK];

   while ((block<TO_NBLOCKS(format)) && (size<TO_FILESIZE_MAX(format))) {
      size++;
      block = fat_data[block];
   }

   return size;
}



/* get_dskf:
 *  Returns the amount of free space in blocks on disk.
 */
static int get_dskf(int format, const unsigned char trk20_data[])
{
   const unsigned char *fat_data;
   int i, dskf = 0;

   fat_data = trk20_data + TO_FAT_START(format);

   for (i=0; i<TO_NBLOCKS(format); i++) {
      if (fat_data[i] == TO_TAG_FREE)
         dskf++;
   }

   return dskf;
}



/* extract_dir_entry:
 *  Extracts one dir entry and returns the number of characters.
 */
static int extract_dir_entry(int format, char buffer[], int buffer_size, int n, const unsigned char trk20_data[])
{
   const unsigned char *entry_data;
   char name[TO_NAME_LENGTH+1], ext[TO_EXT_LENGTH+1], date[9], *comment;
   unsigned char ftype, dtype;
   int i, len, size;

   entry_data = trk20_data + TO_DIR_START(format) + n*TO_DIRENTRY_LENGTH;

   comment = malloc(TO_COMMENT_LENGTH+1);

   if ((entry_data[TO_NAME] == 0) || (entry_data[TO_NAME] == TO_TAG_FREE))
      return 0;

   if (entry_data[TO_NAME] == 1) {
      /* display only comment (if any) */
      if (entry_data[TO_COMMENT]) {
         comment[0] = '\0';
         strncat(comment,(char*)(entry_data+TO_COMMENT), TO_COMMENT_LENGTH);

         for (i=1; i<TO_COMMENT_LENGTH; i++) {
            if (comment[i] == 18) { /* DC2 (repetition) ? */
               len = strlen(comment);
               comment = realloc(comment, len + comment[i+1]);
               memmove(comment+i+comment[i+1], comment+i+2, len - (i+2) + 1);
               memset(comment+i, comment[i-1], comment[i+1]);
            }
         }

         return sprintf(buffer, "%30s%s\n", "", comment);
      }
      else {
         return 0;
      }
   }

   /* name */
   name[0] = 0;
   strncat(name,(char*)(entry_data+TO_NAME), TO_NAME_LENGTH);
   clean_string((unsigned char*)name);

   /* extension */
   ext[0] = 0;
   strncat(ext,(char*)(entry_data+TO_EXT), TO_EXT_LENGTH);
   clean_string((unsigned char *)ext);

   /* file type */
   ftype = entry_data[TO_FILE_TYPE];
   ftype = (ftype > 3 ? ftype_sym[4] : ftype_sym[ftype]);

   /* data type */
   dtype = entry_data[TO_DATA_TYPE];
   dtype = (dtype == 0 ? dtype_sym[0] : (dtype == 0xFF ? dtype_sym[1] : dtype_sym[2]));

   /* size */
   size = get_file_size(format, n, trk20_data) * ((TO_BLOCKSIZE(format) + 1024) / 1024);

   /* date */
   if ((entry_data[TO_DATE_DAY] >= 1) && (entry_data[TO_DATE_DAY] <= 31) &&
       (entry_data[TO_DATE_MONTH] >= 1) && (entry_data[TO_DATE_MONTH] <= 12) &&
       (entry_data[TO_DATE_YEAR] <= 99))
      sprintf(date, "%2d-%2d-%2d", entry_data[TO_DATE_DAY], entry_data[TO_DATE_MONTH], entry_data[TO_DATE_YEAR]);
   else
      date[0] = 0;

   /* comment */
   comment[0] = 0;
   if (entry_data[TO_COMMENT])
      strncat(comment,(char*)(entry_data+TO_COMMENT), TO_COMMENT_LENGTH);

   /* display the entry */
   i = sprintf(buffer, "%-8s %-3s %c %c %-3d %-8s %s\n", name, ext, ftype, dtype, size, date, comment);
   free(comment);

   return i;

   (void) buffer_size;  /* DJGPP 2.03 lacks snprintf() */
}



/* get_filename:
 *  Detects whether the file entry is valid and returns the filename if so.
 */
static int get_filename(char filename[], const unsigned char entry_data[])
{
   int i, j;

   if ((entry_data[TO_NAME] == 0) || (entry_data[TO_NAME] == TO_TAG_FREE))
      return -1;

   /* name */
   strncpy(filename,(char*)(entry_data+TO_NAME), TO_NAME_LENGTH);

   for (i=0; i<TO_NAME_LENGTH; i++) {
      if (filename[i] == 32)
         break;
   }

   filename[i++] = '.';
   filename[i] = 0;

   /* extension */
   strncat(filename,(char*)(entry_data+TO_EXT), TO_EXT_LENGTH);

   for (j=0; j<TO_EXT_LENGTH; j++) {
      if (filename[i+j] == 32)
         break;
   }

   if (filename[i+j-1] == '.')
      filename[i+j-1] = 0;
   else
      filename[i+j] = 0;

   return 0;
}



/* decode_filename:
 *  Decodes the specified raw filename into a valid dir entry.
 */
static void decode_filename(unsigned char entry_data[], const char filename[], int file_size)
{
   const char *p;
   char shortname[128];
   char ext[TO_EXT_LENGTH+1];
   int i, type, len, ext_len = 0;
   FILE *file;

   /* zero the entry data */
   memset(entry_data + TO_NAME, 32, TO_NAME_LENGTH + TO_EXT_LENGTH);
   entry_data[TO_COMMENT] = 0;
   memset(entry_data + TO_COMMENT+1, 32, TO_COMMENT_LENGTH-1);
   memset(entry_data + TO_DATE_DAY, 0, TO_DIRENTRY_LENGTH - TO_DATE_DAY);

   /* find short name */
   len = strlen(filename);
   p = filename + len - 1;   

   while ((p>=filename) && (*p != '/'))
      p--;

   shortname[0] = 0;
   strncat(shortname, p+1, sizeof(shortname) - 1);

   /* find extension */
   len = strlen(shortname);
   p = shortname + len - 1;

   while ((p>=shortname) && (*p != '.'))
      p--;

   if (p < shortname) {  /* no extension? */
      memcpy(entry_data+TO_NAME, shortname, MIN(TO_NAME_LENGTH, len));
      type = EXT_TYPE_MAX-1;
   }
   else {
      /* name */
      memcpy(entry_data+TO_NAME, shortname, MIN(TO_NAME_LENGTH, p - shortname));

      /* extension */
      ext_len = MIN(TO_EXT_LENGTH, shortname + len - 1 - p);
      memcpy(entry_data+TO_EXT, p+1, ext_len);

      /* build upper case extension */
      ext[0] = 0;
      strncat(ext, p+1, ext_len);
      for (i=0; i<ext_len; i++)
         ext[i] = toupper(ext[i]);

      /* search for a standard extension */
      for (type=0; type<EXT_TYPE_MAX-1; type++) {
         if (strcmp(ext_type[type].tag, ext) == 0)
            break;
      }
   }

   /* set file and data types */
   entry_data[TO_FILE_TYPE] = ext_type[type].ftype;
   entry_data[TO_DATA_TYPE] = ext_type[type].dtype;

   /* special treatment */
   switch (type) {

      case EXT_TYPE_BAS:
         /* differentiate ASCII from BINARY data */
         file = fopen(filename, "rb");
         if (file) {
            if ((fgetc(file) == '\r') && (fgetc(file) == '\n'))
               entry_data[TO_DATA_TYPE] = DTYPE_ASCII;
            fclose(file);
         }
         break;

      case EXT_TYPE_CHG:
         /* automatic launch + number of requested banks */
         entry_data[TO_CHG_MODE] = 0x80 | ((file_size/TO_BANKSIZE)&0x3F);

         /* 8-bit checksum */
         for (i=0; i<TO_NAME_LENGTH; i++)
            entry_data[TO_CHG_CHECKSUM] += entry_data[i];
         break;
   }
}



/* seek_file:
 *  Seeks a file in the specified directory and returns its index number if found.
 */
static int seek_file(int format, const char filename[], const unsigned char dir_data[])
{
   char entry_name[TO_NAME_LENGTH + 1 + TO_EXT_LENGTH + 1];
   int i;

   for (i=0; i<TO_NDIRENTRIES(format); i++) {
      if ((get_filename(entry_name, dir_data+i*TO_DIRENTRY_LENGTH) == 0) && (strcmp(entry_name, filename) == 0))
         return i;
   }

   return -1;
}



/* wildcard handling code by Michael Bulkin (M.A.Bukin@inp.nsk.su) */
#define WCD_MATCH_TRY 0
#define WCD_MATCH_ONE 1
#define WCD_MATCH_ANY 2


struct WCD_MATCH_DATA
{
   int type;
   const char *s1;
   const char *s2;
};



/* wcdcmp:
 *  Compares two strings ('*' matches any number of characters,
 *  '?' matches any character).
 */
static int wcdcmp(const char *s1, const char *s2)
{
   static unsigned int size = 0;
   static struct WCD_MATCH_DATA *data = NULL;
   const char *s1end;
   int index, c1, c2;

   /* handle NULL arguments */
   if ((!s1) && (!s2)) {
      if (data) {
         free(data);
         data = NULL;
      }

      return 1;
   }

   s1end = s1 + strlen(s1);

   /* allocate larger working area if necessary */
   if (data && (size < strlen(s2))) {
      free(data);
      data = NULL;
   }

   if (!data) {
      size = strlen(s2);
      data = malloc(sizeof(struct WCD_MATCH_DATA) * size * 2 + 1);
      if (!data)
         return 1;
   }

   index = 0;
   data[0].s1 = s1;
   data[0].s2 = s2;
   data[0].type = WCD_MATCH_TRY;

   while (index >= 0) {
      s1 = data[index].s1;
      s2 = data[index].s2;
      c1 = *s1;
      c2 = *s2;

      switch (data[index].type) {

      case WCD_MATCH_TRY:
         if (c2 == 0) {
            /* pattern exhausted */
            if (c1 == 0)
               return 0;
            else
               index--;
         }
         else if (c1 == 0) {
            /* string exhausted */
            while (*s2 == '*')
               s2++;
            if (*s2 == 0)
               return 0;
            else
               index--;
         }
         else if (c2 == '*') {
            /* try to match the rest of pattern with empty string */
            data[index++].type = WCD_MATCH_ANY;
            data[index].s1 = s1end;
            data[index].s2 = s2 + 1;
            data[index].type = WCD_MATCH_TRY;
         }
         else if ((c2 == '?') || (c1 == c2)) {
            /* try to match the rest */
            data[index++].type = WCD_MATCH_ONE;
            data[index].s1 = s1 + 1;
            data[index].s2 = s2 + 1;
            data[index].type = WCD_MATCH_TRY;
         }
         else
            index--;
         break;

      case WCD_MATCH_ONE:
         /* the rest of string did not match, try earlier */
         index--;
         break;

      case WCD_MATCH_ANY:
         /* rest of string did not match, try add more chars to string tail */
         if (--data[index + 1].s1 >= s1) {
            data[index + 1].type = WCD_MATCH_TRY;
            index++;
         }
         else
            index--;
         break;

      default:
         /* this is a bird? This is a plane? No it's a bug!!! */
         return 1;
      }
   }

   return 1;
}



/* seek_wilcard:
 *  Seeks a wildcard in the specified directory and returns its index number if found.
 */
static int seek_wildcard(int format, char filename[], const char pattern[], const unsigned char dir_data[])
{
   char entry_name[TO_NAME_LENGTH + 1 + TO_EXT_LENGTH + 1];
   static int i = 0;
   int j;

   while (i<TO_NDIRENTRIES(format)) {
      j = i++;

      if ((get_filename(entry_name, dir_data+j*TO_DIRENTRY_LENGTH) == 0) && (wcdcmp(entry_name, pattern) == 0)) {
         strcpy(filename, entry_name);
         return j;
      }
   }

   i = 0;

   /* to avoid leaking memory */
   wcdcmp(NULL, NULL);

   return -1;
}



/* find_free_block_sym:
 *  Finds a free block using a symmetrical search.
 */
static int find_free_block_sym(int format, unsigned char fat_data[])
{
   int block;

   block = TO_NBLOCKS(format)/2 - 1;

   while (block < TO_NBLOCKS(format)) {
      if (fat_data[block] == TO_TAG_FREE)
         return block;

      if (fat_data[TO_NBLOCKS(format) - block - 2] == TO_TAG_FREE)  /* fat_data[-1] is always 0 */
         return TO_NBLOCKS(format) - block - 2;

      block++;
   }

   return -1;
}



/* find_free_block_rel:
 *  Finds a free block using a relative search.
 */
static int find_free_block_rel(int format, int block, unsigned char fat_data[])
{
   if (block < TO_NBLOCKS(format)/2) {
      while (block >= 0) {
         if (fat_data[block] == TO_TAG_FREE)
            break;

         block--;
      }
   }
   else {
      while (block < TO_NBLOCKS(format)) {
         if (fat_data[block] == TO_TAG_FREE)
            break;

         block++;
      }
   }

   if ((block<0) || (block>=TO_NBLOCKS(format)))
      block = find_free_block_sym(format, fat_data);

   return block;
}



/* do_add_file:
 *  Performs the low-level add operation for the specified file entry.
 */
static void do_add_file(sapID id, FILE *file, int file_size, unsigned char entry_data[], int n, unsigned char trk20_data[])
{
   sapsector_t sapsector;
   unsigned char *fat_data;
   unsigned int block, next_block;
   int sect;
   int dummy;

   /* find the first block */
   fat_data = trk20_data + TO_FAT_START(ID_FORMAT(id));

   block = find_free_block_sym(ID_FORMAT(id), fat_data);
   entry_data[TO_FIRST_BLOCK] = block;

   sapsector.format = 0;
   sapsector.protection = 0;

   /* write full blocks */
   while (file_size > TO_BLOCKSIZE(ID_FORMAT(id))) {
      sapsector.track =  block/2;
      sapsector.sector = 1 + (block%2 ? TO_SECTOR_PER_BLOCK : 0);
      seek_pos(id, sapsector.track, sapsector.sector);

      for (sect=0; sect<TO_SECTOR_PER_BLOCK; sect++) {
         dummy=fread(sapsector.data, sizeof(char), TO_SECTSIZE(ID_FORMAT(id)), file);
         do_write_sector(id, &sapsector);
         sapsector.sector++;
      }

      fat_data[block] = TO_TAG_RESERVED;  /* temporarily reserved */
      next_block = find_free_block_rel(ID_FORMAT(id), block, fat_data);

      fat_data[block] = next_block;
      block = next_block;

      file_size -= TO_BLOCKSIZE(ID_FORMAT(id));
   }

   /* write remaining full sectors */
   sapsector.track = block/2;
   sapsector.sector = 1 + (block%2 ? TO_SECTOR_PER_BLOCK : 0);
   seek_pos(id, sapsector.track, sapsector.sector);

   fat_data[block] = TO_END_BLOCK_OFFSET + 1;

   while (file_size > TO_SECTSIZE(ID_FORMAT(id))) {
      dummy=fread(sapsector.data, sizeof(char), TO_SECTSIZE(ID_FORMAT(id)), file);
      do_write_sector(id, &sapsector);
      sapsector.sector++;

      fat_data[block]++;
      file_size -= TO_SECTSIZE(ID_FORMAT(id));
   }

   /* write remaining individual bytes */
   dummy=fread(sapsector.data, sizeof(char), TO_SECTSIZE(ID_FORMAT(id)), file);
   do_write_sector(id, &sapsector);

   entry_data[TO_END_SIZE] = file_size>>8;
   entry_data[TO_END_SIZE+1] = file_size;

   /* write the new entry into the directory */
   memcpy(trk20_data + TO_DIR_START(ID_FORMAT(id)) + n*TO_DIRENTRY_LENGTH, entry_data, TO_DIRENTRY_LENGTH);
}



/* do_delete_file:
 *  Performs the low-level delete operation for the specified file entry and
 *  returns the size of file.
 */
static int do_delete_file(sapID id, const char filename[], int n, unsigned char trk20_data[])
{
   unsigned char *fat_data, *entry_data;
   int block, old_block, size = 0;

   (void) filename;

   fat_data = trk20_data + TO_FAT_START(ID_FORMAT(id));
   entry_data = trk20_data + TO_DIR_START(ID_FORMAT(id)) + n*TO_DIRENTRY_LENGTH;

   /* delete the file entry */
   entry_data[TO_NAME] = 0;

   /* read start block */
   block = entry_data[TO_FIRST_BLOCK];

   /* mark FAT entries with the TO_TAG_FREE tag */
   while ((block<TO_NBLOCKS(ID_FORMAT(id))) && (size<TO_FILESIZE_MAX(ID_FORMAT(id)))) {
      old_block = block;
      block = fat_data[block];
      fat_data[old_block] = TO_TAG_FREE;
      size++;
   }

   size *= TO_BLOCKSIZE(ID_FORMAT(id));

   if (block > TO_END_BLOCK_OFFSET+1)
      size += (block - TO_END_BLOCK_OFFSET - 1) * TO_SECTSIZE(ID_FORMAT(id));

   size += (entry_data[TO_END_SIZE]<<8) + entry_data[TO_END_SIZE+1];

   return size;
}



/* do_extract_file:
 *  Performs the low-level extract operation for the specified file entry and
 *  returns the size of file.
 */
static int do_extract_file(sapID id, const char filename[], int n, unsigned char trk20_data[])
{
   sapsector_t sapsector;
   unsigned char *fat_data, *entry_data;
   int sect, end_size, size = 0;
   unsigned int block;
   FILE *file;

   fat_data = trk20_data + TO_FAT_START(ID_FORMAT(id));
   entry_data = trk20_data + TO_DIR_START(ID_FORMAT(id)) + n*TO_DIRENTRY_LENGTH;

   /* read start block */
   block = entry_data[TO_FIRST_BLOCK];

   if ((file=fopen(filename, "wb")) == NULL) {
      sap_errno = SAP_EPERM;
      return 0;
   }

   /* extract full blocks */
   while ((fat_data[block]<TO_NBLOCKS(ID_FORMAT(id))) && (size<TO_FILESIZE_MAX(ID_FORMAT(id)))) {
      seek_pos(id, block/2, 1 + (block%2 ? TO_SECTOR_PER_BLOCK : 0));

      for (sect=0; sect<TO_SECTOR_PER_BLOCK; sect++) {
         do_read_sector(id, &sapsector);
         fwrite(sapsector.data, sizeof(char), TO_SECTSIZE(ID_FORMAT(id)), file);
      }

      block = fat_data[block];
      size++;
   }

   size *= TO_BLOCKSIZE(ID_FORMAT(id));

   /* extract remaining full sectors */
   seek_pos(id, block/2, 1 + (block%2 ? TO_SECTOR_PER_BLOCK : 0));

   for (sect=0; sect<(fat_data[block] - TO_END_BLOCK_OFFSET - 1); sect++) {
      do_read_sector(id, &sapsector);
      fwrite(sapsector.data, sizeof(char), TO_SECTSIZE(ID_FORMAT(id)), file);
      size += TO_SECTSIZE(ID_FORMAT(id));
   }

   /* extract remaining individual bytes */
   do_read_sector(id, &sapsector);
   end_size = (entry_data[TO_END_SIZE]<<8) + entry_data[TO_END_SIZE+1];
   fwrite(sapsector.data, sizeof(char), end_size, file);
   size += end_size;

   fclose(file);

   return size;
}



/************************************************/
/***       public low-level functions         ***/
/************************************************/


/* _ExtractDir:
 *  Extract the directory from track 20 and returns the number of lines.
 */
int _ExtractDir(char buffer[], int buffer_size, int drive, int density, const unsigned char trk20_data[])
{
   unsigned char disk_name[TO_NAME_LENGTH+1];
   int dskf, i, len, pos, lines = 0;
   int format = (density == 1 ? SAP_FORMAT2 : SAP_FORMAT1);

   /* name of the volume */
   strncpy((char*)disk_name, (char*)trk20_data, TO_NAME_LENGTH);

   if ((disk_name[0] == 0) || (disk_name[0] == TO_TAG_FREE)) {
      strcpy((char*)disk_name, "No Name ");
   }
   else {
      disk_name[TO_NAME_LENGTH] = 0;
      clean_string(disk_name);
   }

   /* dskf */
   dskf = get_dskf(format, trk20_data) * ((TO_BLOCKSIZE(format) + 1024) / 1024);

   /* header */
   pos = sprintf(buffer, "%s density   %d:%s DSKF = %d\n", (density == 1 ? "Single" : "Double"), drive, disk_name, dskf);
   lines++;

   /* directory entries */
   for (i=0; i<TO_NDIRENTRIES(format); i++) {
      len = extract_dir_entry(format, buffer+pos, buffer_size-pos, i, trk20_data);

      if (len>0) {
         pos += len;
         lines++;
      }
   }

   return lines;
}



/* _ForEachFile:
 *  Executes the specified callback funtion on each file matching the pattern.
 */
int _ForEachFile(sapID id, const char pattern[], sapfilecb_t callback, int save_back)
{
   char filename[TO_NAME_LENGTH + 1 + TO_EXT_LENGTH + 1];
   unsigned char trk20_data[SAP_TRACKSIZE1], *dir_data;
   int n, ret = 0;

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return 0;

      case EMPTY_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return 0;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return 0;

      case FULL_ARCHIVE:
         break;
   }

   /* read track 20 */
   sap_ReadSectorEx(id, 20, 1, SAP_NSECTS, trk20_data);

   dir_data = trk20_data + TO_DIR_START(ID_FORMAT(id));

   if (strpbrk(pattern, "?*")) {  /* wildcards? */
      while ((n=seek_wildcard(ID_FORMAT(id), filename, pattern, dir_data)) >= 0)
         ret += callback(id, filename, n, trk20_data);
   }
   else {
      n = seek_file(ID_FORMAT(id), pattern, dir_data);

      if (n<0)
         sap_errno = SAP_ENOENT;
      else
         ret = callback(id, pattern, n, trk20_data);
   }

   if (save_back) {
      /* save track 20 */
      sap_WriteSectorEx(id, 20, 1, SAP_NSECTS, trk20_data);
   }

   return ret;
}



/************************************************/
/***  API functions: physical format support  ***/
/************************************************/


/* OpenArchive:
 *  Opens an existing archive,
 *  returns the sapID on success or SAP_ERROR on error.
 */
sapID sap_OpenArchive(const char filename[], int *format)
{
   char header[SAP_HEADER_SIZE];
   sapID id;
   int dummy;

   /* seek for an empty id */
   if (!(id=get_id())) {
      sap_errno = SAP_ETOOMANY;
      return SAP_ERROR;
   }

   if ((ID_FILE(id)=fopen(filename, "rb+")) == NULL) {
      sap_errno = SAP_ENOENT;
      return SAP_ERROR;
   }

   /* read the header */ 
   dummy=fread(header, sizeof(char), SAP_HEADER_SIZE, ID_FILE(id));

   /* find the format */
   if ((header[0] != SAP_FORMAT1) && (header[0] != SAP_FORMAT2)) {
      fclose(ID_FILE(id));
      sap_errno = SAP_EBADF;
      return SAP_ERROR;
   }

   *format = header[0];
   
   /* check the header */
   header[0] = 0;

   if (strncmp(header, sap_header, SAP_HEADER_SIZE) != 0) {
      fclose(ID_FILE(id));
      sap_errno = SAP_EBADF;
      return SAP_ERROR;
   }

   ID_FORMAT(id) = *format;
   ID_STATE(id) = FULL_ARCHIVE;
   ID_NTRACKS(id) = SAP_NTRACKS(*format);

   return id;
}



/* CreateArchive:
 *  Creates an archive skeleton and writes the header,
 *  returns the sapID on success or SAP_ERROR on error.
 */
sapID sap_CreateArchive(const char filename[], int format)
{
   char header[SAP_HEADER_SIZE];
   sapID id;

   if ((format != SAP_FORMAT1) && (format != SAP_FORMAT2)) {
      sap_errno = SAP_EINVAL;
      return SAP_ERROR;
   }

   /* seek for an empty id */
   if (!(id=get_id())) {
      sap_errno = SAP_ETOOMANY;
      return SAP_ERROR;
   }

   if ((ID_FILE(id)=fopen(filename, "wb")) == NULL) {
      sap_errno = SAP_EPERM;
      return SAP_ERROR;
   }

   /* write the header */
   memcpy(header, sap_header, SAP_HEADER_SIZE);
   header[0] = format;

   fwrite(header, sizeof(char), SAP_HEADER_SIZE, ID_FILE(id));

   ID_FILE(id) = freopen(filename, "rb+", ID_FILE(id));
   seek_pos(id, 0 ,1);

   ID_FORMAT(id) = format;
   ID_STATE(id) = EMPTY_ARCHIVE;
   ID_NTRACKS(id) = 0;

   return id;
}



/* CloseArchive:
 *  Closes the archive, filling it up with empty tracks if needed,
 *  returns SAP_OK on success or SAP_ERROR on error.
 */
int sap_CloseArchive(sapID id)
{
   sapsector_t sapsector;
   int format = ID_FORMAT(id);
   int track, sect;

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return SAP_ERROR;

      case EMPTY_ARCHIVE:
      case FILLED_ARCHIVE:
         sapsector.format = 0;
         sapsector.protection = 0;
         memset(sapsector.data, TO_FILLER_BYTE, SAP_SECTSIZE(format));

         for (track=ID_NTRACKS(id); track<SAP_NTRACKS(format); track++) {
            for (sect=1; sect<=SAP_NSECTS; sect++) {
               sapsector.track = track;
               sapsector.sector = sect;
               do_write_sector(id, &sapsector);
            }
         }
         break;

      case FULL_ARCHIVE:
         break;
   }

   fclose(ID_FILE(id));
   ID_STATE(id) = NO_ARCHIVE;

   return SAP_OK;
}



/* FillArchive:
 *  Fills an empty archive sector by sector, it's up to
 *  the user to call it the right number of times,
 *  returns SAP_OK on success or SAP_ERROR on error.
 */
int sap_FillArchive(sapID id, sapsector_t *sapsector)
{
   static int sect;

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return SAP_ERROR;

      case EMPTY_ARCHIVE:
         ID_STATE(id) = FILLED_ARCHIVE;
         sect = 1;
         /* no break */

      case FILLED_ARCHIVE:
         do_write_sector(id, sapsector);

         if (++sect == SAP_NSECTS+1) {
            sect = 1;

            if (++ID_NTRACKS(id) == SAP_NTRACKS(ID_FORMAT(id)))
               ID_STATE(id) = FULL_ARCHIVE;
         }
         break;

      case FULL_ARCHIVE:
         sap_errno = SAP_ENOSPC;
         return SAP_ERROR;
   } /* end of switch */

   return SAP_OK;
}



/* ReadSector:
 *  Reads the specified sector and returns SAP_OK or a flagged code:
 *    SAP_NO_STD_FMT: non standard format
 *    SAP_PROTECTED : protected sector
 *    SAP_BAD_SECTOR: bad sector identifiers
 *    SAP_CRC_ERROR : CRC error
 */
int sap_ReadSector(sapID id, int track, int sect, sapsector_t *sapsector)
{
   int flag = SAP_OK;
   int format = ID_FORMAT(id);

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return SAP_ERROR;

      case EMPTY_ARCHIVE:
         sap_errno = SAP_EEMPTY;
         return SAP_ERROR;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return SAP_ERROR;

      case FULL_ARCHIVE:
         break;
   }

   seek_pos(id, track, sect);
   do_read_sector(id, sapsector);

   if (sapsector->format != 0)
      flag |= SAP_NO_STD_FMT;

   if (sapsector->protection != 0)
      flag |= SAP_PROTECTED;

   if ((sapsector->track != track) || (sapsector->sector != sect))
      flag |= SAP_BAD_SECTOR;

   do_crc(sapsector, format);

   if ((sapsector->data[SAP_SECTSIZE(format)] != ((crcpuk_temp>>8)&0xff))
        || (sapsector->data[SAP_SECTSIZE(format)] != (crcpuk_temp&0xff)))
      flag |= SAP_CRC_ERROR;

   return flag;
}



/* ReadSectorEx:
 *  Reads one or more sectors from the same track,
 *  returns SAP_OK on success or SAP_ERROR on error.
 */
int sap_ReadSectorEx(sapID id, int track, int sect, int nsects, unsigned char data[])
{
   sapsector_t sapsector;
   int format = ID_FORMAT(id);
   int i;

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return SAP_ERROR;

      case EMPTY_ARCHIVE:
         sap_errno = SAP_EEMPTY;
         return SAP_ERROR;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return SAP_ERROR;

      case FULL_ARCHIVE:
         break;
   }

   seek_pos(id, track, sect);

   for (i=0; i<nsects; i++) {
      do_read_sector(id, &sapsector);
      memcpy(data + i*SAP_SECTSIZE(format), sapsector.data, SAP_SECTSIZE(format));
   }

   return SAP_OK;
}



/* WriteSector:
 *  Writes the specified sector and
 *  returns SAP_OK on success or SAP_ERROR on error.
 */
int sap_WriteSector(sapID id, int track, int sect, sapsector_t *sapsector)
{
   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return SAP_ERROR;

      case EMPTY_ARCHIVE:
         sap_errno = SAP_EEMPTY;
         return SAP_ERROR;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return SAP_ERROR;

      case FULL_ARCHIVE:
         break;
   }

   seek_pos(id, track, sect);
   do_write_sector(id, sapsector);

   return SAP_OK;
}



/* WriteSectorEx:
 *  Writes one or more sectors into the same track,
 *  returns SAP_OK on success or SAP_ERROR on error.
 */
int sap_WriteSectorEx(sapID id, int track, int sect, int nsects, const unsigned char data[])
{
   sapsector_t sapsector;
   int format = ID_FORMAT(id);
   int i;

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return SAP_ERROR;

      case EMPTY_ARCHIVE:
         sap_errno = SAP_EEMPTY;
         return SAP_ERROR;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return SAP_ERROR;

      case FULL_ARCHIVE:
         break;
   }

   seek_pos(id, track, sect);

   sapsector.format = 0;
   sapsector.protection = 0;
   sapsector.track = track;

   for (i=0; i<nsects; i++) {
      memcpy(sapsector.data, data + i*SAP_SECTSIZE(format), SAP_SECTSIZE(format));
      sapsector.sector = sect + i;
      do_write_sector(id, &sapsector);
   }

   return SAP_OK;
}



/************************************************/
/***  API functions: logical format support   ***/
/************************************************/


/* FormatArchive:
 *  Formats an archive using the Thomson BASIC DOS format,
 *  returns SAP_OK on success or SAP_ERROR on error.
 */
int sap_FormatArchive(sapID id, int capacity)
{
   int format = ID_FORMAT(id);
   int track, sect;

   sapsector_t sapsector;

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return SAP_ERROR;

      case EMPTY_ARCHIVE:
         break;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return SAP_ERROR;

      case FULL_ARCHIVE:
         seek_pos(id, 0, 1);
         break;
   }

   if (!(capacity == SAP_TRK40) && !(capacity == SAP_TRK80)) {
      sap_errno = SAP_EINVAL;
      return SAP_ERROR;
   }

   sapsector.format = 0;
   sapsector.protection = 0;
   memset(sapsector.data, TO_FILLER_BYTE, SAP_SECTSIZE(format));

   for (track=0; track<SAP_NTRACKS(format); track++) {
      for (sect=1; sect<SAP_NSECTS+1; sect++) {
         sapsector.track = track;
         sapsector.sector = sect;
         do_write_sector(id, &sapsector);
      }
   }

   /* write track 20 */
   sapsector.track = 20;
   memset(sapsector.data, TO_TAG_FREE, SAP_SECTSIZE(format));
   seek_pos(id, 20, 1);

   for (sect=1; sect<SAP_NSECTS+1; sect++) {
      sapsector.sector = sect;
      do_write_sector(id, &sapsector);
   }

   /* FAT */
   sapsector.track = 20;
   sapsector.sector = 2;
   memset(sapsector.data, TO_TAG_RESERVED, SAP_SECTSIZE(format));

   /* first byte */
   sapsector.data[0] = 0;

   /* lower zone */
   memset(sapsector.data + 1, TO_TAG_FREE, 40);

   /* upper zone */
   if (capacity == SAP_TRK80)  /* not (format == SAP_FORMAT1) */
      memset(sapsector.data + 43, TO_TAG_FREE, TO_NBLOCKS1 - 43 + 1);
   else
      memset(sapsector.data + 43, TO_TAG_FREE, TO_NBLOCKS2 - 43 + 1);

   seek_pos(id, 20, 2);
   do_write_sector(id, &sapsector);

   ID_STATE(id) = FULL_ARCHIVE;
   ID_NTRACKS(id) = SAP_NTRACKS(format);

   return SAP_OK;
}



/* ListArchive:
 *  Builds a list of files contained in the archive,
 *  returns the number of lines on success or 0 on error.
 */
int sap_ListArchive(sapID id, char buffer[], int buffer_size)
{
   unsigned char trk20_data[SAP_TRACKSIZE1];

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return 0;

      case EMPTY_ARCHIVE:
         sap_errno = SAP_EEMPTY;
         return 0;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return 0;

      case FULL_ARCHIVE:
         break;
   }

   /* read track 20 */
   sap_ReadSectorEx(id, 20, 1, SAP_NSECTS, trk20_data);

   return _ExtractDir(buffer, buffer_size, 0, ID_FORMAT(id) == SAP_FORMAT1 ? 2 : 1, trk20_data);
}



/* AddFile:
 *  Adds the specified file to the archive,
 *  returns the size of the file in bytes on success or 0 on error.
 */
int sap_AddFile(sapID id, const char filename[])
{
   unsigned char entry_data[TO_DIRENTRY_LENGTH];
   unsigned char trk20_data[SAP_TRACKSIZE1], *fat_data, *dir_data;
   int free_n=-1, prev_n=-1;
   int i, dskf, file_size = 0;
   FILE *file;

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return 0;

      case EMPTY_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return 0;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return 0;

      case FULL_ARCHIVE:
         break;
   }

   /* open the file */
   if ((file=fopen(filename, "rb")) == NULL) {
      sap_errno = SAP_ENOENT;
      return 0;
   }

   /* find size of the file */
   while (fgetc(file) != EOF)
      file_size++;

   if (file_size == 0) {
      fclose(file);
      sap_errno = SAP_ENFILE;
      return 0;
   }

   fseek(file, 0, SEEK_SET);

   /* decode the filename */
   decode_filename(entry_data, filename, file_size);

   /* read track 20 */
   sap_ReadSectorEx(id, 20, 1, SAP_NSECTS, trk20_data);

   fat_data = trk20_data + TO_FAT_START(ID_FORMAT(id));
   dir_data = trk20_data + TO_DIR_START(ID_FORMAT(id));

   /* simultaneously seek already free entry and previous entry */
   for (i=0; i<TO_NDIRENTRIES(ID_FORMAT(id)); i++) {
      if ((dir_data[i*TO_DIRENTRY_LENGTH] == 0) || (dir_data[i*TO_DIRENTRY_LENGTH] == TO_TAG_FREE)) {
         if (free_n<0)
            free_n = i;
      }
      else {
         if (strncmp((char*)(dir_data+i*TO_DIRENTRY_LENGTH),(char*) entry_data, TO_NAME_LENGTH + TO_EXT_LENGTH) == 0) {
            prev_n = i;
            break;
         }
      }
   }

   if ((free_n<0) && (prev_n<0)) {
      fclose(file);
      sap_errno = SAP_ENOSPC;
      return 0;
   }

   /* test for enough free disk space */
   dskf = get_dskf(ID_FORMAT(id), trk20_data);

   if (prev_n >=0)
      dskf += get_file_size(ID_FORMAT(id), prev_n, trk20_data);

   if ((dskf*TO_BLOCKSIZE(ID_FORMAT(id))) < file_size) {
      sap_errno = SAP_EFBIG;
      fclose(file);
      return 0;
   }

   /* delete previous entry */
   if (prev_n >= 0) {
      do_delete_file(id, filename, prev_n, trk20_data);
      free_n = prev_n;
   }

   /* phew! we can finally add the file... */
   do_add_file(id, file, file_size, entry_data, free_n, trk20_data);

   /* update directory and FAT */
   sap_WriteSectorEx(id, 20, 1, SAP_NSECTS, trk20_data);

   fclose(file);

   return file_size;
}



/* DeleteFile:
 *  Deletes the specified files from the archive,
 *  returns the total size of the files in bytes on success or 0 on error.
 */
int sap_DeleteFile(sapID id, const char pattern[])
{
   return _ForEachFile(id, pattern, do_delete_file, 1);
}



/* ExtractFile:
 *  Extracts the specified files from the archive,
 *  returns the total size of the files in bytes on success or 0 on error.
 */
int sap_ExtractFile(sapID id, const char pattern[])
{
   return _ForEachFile(id, pattern, do_extract_file, 0);
}



/* GetFileInfo:
 *  Fills in a structure with the info for the specified file
 *  returns SAP_OK on success or SAP_ERROR on error.
 */
int sap_GetFileInfo(sapID id, const char filename[], sapfileinfo_t *info)
{
   unsigned char trk20_data[SAP_TRACKSIZE1], *dir_data, *fat_data, *entry_data;
   struct tm tim;
   int n, block, i=0;

   switch (ID_STATE(id)) {

      case NO_ARCHIVE:
         sap_errno = SAP_EINVAL;
         return 0;

      case EMPTY_ARCHIVE:
         sap_errno = SAP_EEMPTY;
         return 0;

      case FILLED_ARCHIVE:
         sap_errno = SAP_EBUSY;
         return 0;

      case FULL_ARCHIVE:
         break;
   }

   /* read track 20 */
   sap_ReadSectorEx(id, 20, 1, SAP_NSECTS, trk20_data);

   dir_data = trk20_data + TO_DIR_START(ID_FORMAT(id));

   n = seek_file(ID_FORMAT(id), filename, dir_data);

   if (n<0) {
      sap_errno = SAP_ENOENT;
      return SAP_ERROR;
   }

   fat_data = trk20_data + TO_FAT_START(ID_FORMAT(id));
   entry_data = trk20_data + TO_DIR_START(ID_FORMAT(id)) + n*TO_DIRENTRY_LENGTH;

   /* block chain */
   info->nblocks = get_file_size(ID_FORMAT(id), n, trk20_data);
   info->block = malloc(info->nblocks*sizeof(int));

   block = entry_data[TO_FIRST_BLOCK];

   while ((block<TO_NBLOCKS(ID_FORMAT(id))) && (i<TO_FILESIZE_MAX(ID_FORMAT(id)))) {
      info->block[i++] = block;
      block = fat_data[block];
   }

   /* common attributes */
   info->size = info->nblocks*TO_BLOCKSIZE(ID_FORMAT(id)) + entry_data[TO_END_SIZE];
   info->file_type = entry_data[TO_FILE_TYPE];
   info->data_type = entry_data[TO_DATA_TYPE];

   /* date */
   if ((entry_data[TO_DATE_DAY] >= 1) && (entry_data[TO_DATE_DAY] <= 31) &&
       (entry_data[TO_DATE_MONTH] >= 1) && (entry_data[TO_DATE_MONTH] <= 12) &&
       (entry_data[TO_DATE_YEAR] <= 99)) {
      memset(&tim, 0, sizeof(struct tm));
      tim.tm_mday = entry_data[TO_DATE_DAY];
      tim.tm_mon = entry_data[TO_DATE_MONTH];
      tim.tm_year = entry_data[TO_DATE_YEAR];
      info->date = mktime(&tim);
   }
   else {
      info->date = 0;
   }

   /* comment */
   info->comment[0] = '\0';
   if (entry_data[TO_COMMENT])
      strncat(info->comment,(char*)( entry_data+TO_COMMENT), TO_COMMENT_LENGTH);

   return SAP_OK;
}