* * \note If this function is used for freeing just a part of a cluster *       chain, the new end of the chain is not correctly terminated *       within the FAT. Use fat16_terminate_clusters() instead. * * \param[in] fs The filesystem on which to operate. * \param[in] cluster_num The starting cluster of the chain which to free. * \returns 0 on failure, 1 on success. * \see fat16_terminate_clusters */uint8_t fat16_free_clusters(const struct fat16_fs_struct* fs, uint16_t cluster_num){#if FAT16_WRITE_SUPPORT    uint8_t buffer[2];
	uint32_t fat_offset;
    uint16_t cluster_num_next;
	if(!fs || cluster_num < 2)        return 0;    fat_offset = fs->header.fat_offset;        while(cluster_num)    {        if(!fs->partition->device_read(fat_offset + 2 * cluster_num, buffer, 2))            return 0;        /* get next cluster of current cluster before freeing current cluster */        cluster_num_next = ((uint16_t) buffer[0]) |                                    ((uint16_t) buffer[1] << 8);        if(cluster_num_next == FAT16_CLUSTER_FREE)            return 1;        if(cluster_num_next == FAT16_CLUSTER_BAD ||           (cluster_num_next >= FAT16_CLUSTER_RESERVED_MIN &&            cluster_num_next <= FAT16_CLUSTER_RESERVED_MAX           )          )            return 0;        if(cluster_num_next >= FAT16_CLUSTER_LAST_MIN && cluster_num_next <= FAT16_CLUSTER_LAST_MAX)            cluster_num_next = 0;        /* free cluster */        buffer[0] = FAT16_CLUSTER_FREE & 0xff;        buffer[1] = (FAT16_CLUSTER_FREE >> 8) & 0xff;        fs->partition->device_write(fat_offset + 2 * cluster_num, buffer, 2);        /* We continue in any case here, even if freeing the cluster failed.         * The cluster is lost, but maybe we can still free up some later ones.         */        cluster_num = cluster_num_next;    }    return 1;#else    return 0;#endif}/** * \ingroup fat16_fs * Frees a part of a cluster chain and correctly terminates the rest. * * Marks the specified cluster as the new end of a cluster chain and * frees all following clusters. * * \param[in] fs The filesystem on which to operate. * \param[in] cluster_num The new end of the cluster chain. * \returns 0 on failure, 1 on success. * \see fat16_free_clusters */uint8_t fat16_terminate_clusters(const struct fat16_fs_struct* fs, uint16_t cluster_num){#if FAT16_WRITE_SUPPORT

	uint16_t cluster_num_next;
	uint8_t buffer[2];

    if(!fs || cluster_num < 2)        return 0;    /* fetch next cluster before overwriting the cluster entry */    cluster_num_next = fat16_get_next_cluster(fs, cluster_num);    /* mark cluster as the last one */        buffer[0] = FAT16_CLUSTER_LAST_MAX & 0xff;    buffer[1] = (FAT16_CLUSTER_LAST_MAX >> 8) & 0xff;    if(!fs->partition->device_write(fs->header.fat_offset + 2 * cluster_num, buffer, 2))        return 0;    /* free remaining clusters */    if(cluster_num_next)        return fat16_free_clusters(fs, cluster_num_next);    else        return 1;#else    return 0;#endif}/** * \ingroup fat16_fs * Clears a single cluster. * * The complete cluster is filled with zeros. * * \param[in] fs The filesystem on which to operate. * \param[in] cluster_num The cluster to clear. * \returns 0 on failure, 1 on success. */uint8_t fat16_clear_cluster(const struct fat16_fs_struct* fs, uint16_t cluster_num){#if FAT16_WRITE_SUPPORT

    uint32_t cluster_offset;    uint8_t zero[16];
    if(cluster_num < 2)        return 0;    cluster_offset = fs->header.cluster_zero_offset +                              (uint32_t) (cluster_num - 2) * fs->header.cluster_size;    return fs->partition->device_write_interval(cluster_offset,                                                zero,                                                fs->header.cluster_size,                                                fat16_clear_cluster_callback,                                                0                                               );#else    return 0;#endif}/** * \ingroup fat16_fs * Callback function for clearing a cluster. */uint16_t fat16_clear_cluster_callback(uint8_t* buffer, uint32_t offset, void* p){#if FAT16_WRITE_SUPPORT    memset(buffer, 0, 16);    return 16;#else    return 0;#endif}/** * \ingroup fat16_file * Opens a file on a FAT16 filesystem. * * \param[in] fs The filesystem on which the file to open lies. * \param[in] dir_entry The directory entry of the file to open. * \returns The file handle, or 0 on failure. * \see fat16_close_file */struct fat16_file_struct* fat16_open_file(struct fat16_fs_struct* fs, const struct fat16_dir_entry_struct* dir_entry){
	struct fat16_file_struct* fd;
#if USE_DYNAMIC_MEMORY==0
	uint8_t i;
#endif    if(!fs || !dir_entry || (dir_entry->attributes & FAT16_ATTRIB_DIR))        return 0;#if USE_DYNAMIC_MEMORY    fd = malloc(sizeof(*fd));    if(!fd)        return 0;#else    fd = fat16_file_handlers;    for(i = 0; i < FAT16_FILE_COUNT; ++i)    {        if(!fd->fs)            break;        ++fd;    }    if(i >= FAT16_FILE_COUNT)        return 0;#endif        memcpy(&fd->dir_entry, dir_entry, sizeof(*dir_entry));    fd->fs = fs;    fd->pos = 0;    fd->pos_cluster = dir_entry->cluster;    return fd;}/** * \ingroup fat16_file * Closes a file. * * \param[in] fd The file handle of the file to close. * \see fat16_open_file */void fat16_close_file(struct fat16_file_struct* fd){    if(fd)#if USE_DYNAMIC_MEMORY        free(fd);#else        fd->fs = 0;#endif}/** * \ingroup fat16_file * Reads data from a file. *  * The data requested is read from the current file location. * * \param[in] fd The file handle of the file from which to read. * \param[out] buffer The buffer into which to write. * \param[in] buffer_len The amount of data to read. * \returns The number of bytes read, 0 on end of file, or -1 on failure. * \see fat16_write_file */int16_t fat16_read_file(struct fat16_file_struct* fd, uint8_t* buffer, uint16_t buffer_len){
    uint16_t cluster_size;    uint16_t cluster_num;    uint16_t buffer_left;    uint16_t first_cluster_offset;
    uint32_t cluster_offset;    uint16_t copy_length;

    /* check arguments */    if(!fd || !buffer || buffer_len < 1)        return -1;    /* determine number of bytes to read */    if(fd->pos + buffer_len > fd->dir_entry.file_size)        buffer_len = fd->dir_entry.file_size - fd->pos;    if(buffer_len == 0)        return 0;        cluster_size = fd->fs->header.cluster_size;    cluster_num = fd->pos_cluster;    buffer_left = buffer_len;    first_cluster_offset = fd->pos % cluster_size;    /* find cluster in which to start reading */    if(!cluster_num)    {        cluster_num = fd->dir_entry.cluster;                if(!cluster_num)        {            if(!fd->pos)                return 0;            else                return -1;        }        if(fd->pos)        {            uint32_t pos = fd->pos;            while(pos >= cluster_size)            {                pos -= cluster_size;                cluster_num = fat16_get_next_cluster(fd->fs, cluster_num);                if(!cluster_num)                    return -1;            }        }    }        /* read data */    do    {        /* calculate data size to copy from cluster */        cluster_offset = fd->fs->header.cluster_zero_offset +                                  (uint32_t) (cluster_num - 2) * cluster_size + first_cluster_offset;        copy_length = cluster_size - first_cluster_offset;        if(copy_length > buffer_left)            copy_length = buffer_left;        /* read data */        if(!fd->fs->partition->device_read(cluster_offset, buffer, copy_length))            return buffer_len - buffer_left;        /* calculate new file position */        buffer += copy_length;        buffer_left -= copy_length;        fd->pos += copy_length;        if(first_cluster_offset + copy_length >= cluster_size)        {            /* we are on a cluster boundary, so get the next cluster */
			cluster_num = fat16_get_next_cluster(fd->fs, cluster_num);            if(0!=cluster_num)            {                first_cluster_offset = 0;            }            else            {                fd->pos_cluster = 0;                return buffer_len - buffer_left;            }        }        fd->pos_cluster = cluster_num;    } while(buffer_left > 0); /* check if we are done */    return buffer_len;}/** * \ingroup fat16_file * Writes data to a file. *  * The data is written to the current file location. * * \param[in] fd The file handle of the file to which to write. * \param[in] buffer The buffer from which to read the data to be written. * \param[in] buffer_len The amount of data to write. * \returns The number of bytes written, 0 on disk full, or -1 on failure. * \see fat16_read_file */int16_t fat16_write_file(struct fat16_file_struct* fd, const uint8_t* buffer, uint16_t buffer_len){#if FAT16_WRITE_SUPPORT
    uint16_t cluster_size;    uint16_t cluster_num;    uint16_t buffer_left;    uint16_t first_cluster_offset;
            uint32_t pos;            uint16_t cluster_num_next;
       uint32_t cluster_offset;        uint16_t write_length;
	uint32_t size_old;
    /* check arguments */    if(!fd || !buffer || buffer_len < 1)        return -1;    if(fd->pos > fd->dir_entry.file_size)        return -1;    cluster_size = fd->fs->header.cluster_size;    cluster_num = fd->pos_cluster;    buffer_left = buffer_len;    first_cluster_offset = fd->pos % cluster_size;    /* find cluster in which to start writing */    if(!cluster_num)    {        cluster_num = fd->dir_entry.cluster;                if(!cluster_num)        {            if(!fd->pos)            {                /* empty file */                fd->dir_entry.cluster = cluster_num = fat16_append_clusters(fd->fs, 0, 1);                if(!cluster_num)                    return -1;            }            else            {                return -1;            }        }        if(fd->pos)        {            pos = fd->pos;            while(pos >= cluster_size)            {                pos -= cluster_size;                cluster_num_next = fat16_get_next_cluster(fd->fs, cluster_num);                if(!cluster_num_next && pos == 0)                    /* the file exactly ends on a cluster boundary, and we append to it */                    cluster_num_next = fat16_append_clusters(fd->fs, cluster_num, 1);                if(!cluster_num_next)                    return -1;                cluster_num = cluster_num_next;            }        }    }        /* write data */    do    {        /* calculate data size to write to cluster */        cluster_offset = fd->fs->header.cluster_zero_offset +                                  (uint32_t) (cluster_num - 2) * cluster_size + first_cluster_offset;        write_length = cluster_size - first_cluster_offset;        if(write_length > buffer_left)            write_length = buffer_left;        /* write data which fits into the current cluster */        if(!fd->fs->partition->device_write(cluster_offset, buffer, write_length))            break;        /* calculate new file position */        buffer += write_length;        buffer_left -= write_length;        fd->pos += write_length;        if(first_cluster_offset + write_length >= cluster_size)        {            /* we are on a cluster boundary, so get the next cluster */            uint16_t cluster_num_next = fat16_get_next_cluster(fd->fs, cluster_num);            if(!cluster_num_next && buffer_left > 0)                /* we reached the last cluster, append a new one */                cluster_num_next = fat16_append_clusters(fd->fs, cluster_num, 1);            if(!cluster_num_next)            {                fd->pos_cluster = 0;                break;            }            cluster_num = cluster_num_next;            first_cluster_offset = 0;        }        fd->pos_cluster = cluster_num;    } while(buffer_left > 0); /* check if we are done */    /* update directory entry */    if(fd->pos > fd->dir_entry.file_size)    {        size_old = fd->dir_entry.file_size;        /* update file size */        fd->dir_entry.file_size = fd->pos;        /* write directory entry */        if(!fat16_write_dir_entry(fd->fs, &fd->dir_entry))        {            /* We do not return an error here since we actually wrote             * some data to disk. So we calculate the amount of data             * we wrote to disk and which lies within the old file size.             */            buffer_left = fd->pos - size_old;            fd->pos = size_old;        }