phatutil.c

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2006 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EGNITE
 * SOFTWARE GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 */

#include <fs/phatfs.h>
#include <fs/phatvol.h>
#include <fs/phatdir.h>
#include <fs/phatutil.h>

#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <errno.h>
#include <memdebug.h>

#if 0
/* Use for local debugging. */
#define NUTDEBUG
#include <stdio.h>
#include <fs/phatdbg.h>
#endif


void GetDosTimeStamp(uint16_t * dostim, uint16_t * dosdat)
{
    time_t now;
    struct _tm *gmt;

    time(&now);
    gmt = localtime(&now);

    if (dosdat) {
        *dosdat = (uint16_t) (gmt->tm_mday | ((gmt->tm_mon + 1) << 5) | ((gmt->tm_year - 80) << 9));
    }
    if (dostim) {
        *dostim = (uint16_t) ((gmt->tm_sec / 2) | (gmt->tm_min << 5) | (gmt->tm_hour << 11));
    }
}

int MakePhatName(CONST char *src, uint8_t * dst)
{
    int rc = 0;
    int i;

    /* Fill destination with spaces. */
    memset(dst, ' ', 11);

    /* Skip leading dots. */
    for (i = 0; src[i] == '.'; i++);
    /* Handle the special entries dot and double dot. */
    if (src[i] == 0 && (i == 1 || i == 2)) {
        while (i--) {
            *dst++ = '.';
        }
        return 0;
    }

    /* Convert the special token of removed entries. */
    if (*src == (char)PHAT_REM_DIRENT) {
        dst[0] = PHAT_REM_NAMENT;
        src++;
    } else {
        dst[0] = toupper((unsigned char)*src);
        src++;
    }

    /* Copy the rest of the base name upto the dot, 8 characters max. */
    for (i = 1; i < 8 && *src && *src != '.'; i++, src++) {
        dst[i] = toupper((unsigned char)*src);
    }

    /* More characters? */
    if (*src) {
        /* If we didn't reach a dot, then the base name is too long. */
        if (*src != '.') {
            return -1;
        }
        /* Skip the dot and copy the extension. */
        src++;
        for (i = 8; i < 11 && *src; i++, src++) {
            dst[i] = toupper((unsigned char)*src);
        }
        /* If more characters are available, then the extension is too long. */
        if (*src) {
            return -1;
        }
    }

    /* Finally check our result. */
    for (i = 0; i < 11; i++) {
        /* Reject control codes. */
        if (dst[i] < ' ') {
            return -1;
        }
        /* Reject illegal characters. */
        if (strchr("\"+,./:;<=>[\\]^", dst[i])) {
            return -1;
        }
        /* Wildcard found. */
        if (dst[i] == '?') {
            rc = 1;
        } else if (dst[i] == '*') {
            rc = 1;
            /* Stars in the name will fill the remaining name or
               extension part with '?'. */
            if (i < 8) {
                memset(&dst[i], '?', 8 - i);
            } else {
                memset(&dst[i], '?', 11 - i);
            }
        }
    }
    return rc;
}

void MakeVisibleName(CONST uint8_t * src, char *dst)
{
    int i;

    /* Replace the 0x05 cludge. */
    if (src[0] == PHAT_REM_NAMENT) {
        *dst++ = PHAT_REM_DIRENT;
    } else {
        *dst++ = src[0];
    }

    /* Copy the base name part up to the first space. */
    for (i = 1; i < 8 && src[i] != ' '; i++) {
        *dst++ = src[i];
    }

    /* Add the extension up to the first space. */
    for (i = 8; i < 11 && src[i] != ' '; i++) {
        if (i == 8) {
            *dst++ = '.';
        }
        *dst++ = src[i];
    }
    *dst = 0;
}

char *GetParentPath(CONST char *path, CONST char **comp)
{
    char *parent;
    int len;

    if ((*comp = strrchr(path, '/')) == NULL) {
        errno = EINVAL;
        return NULL;
    }

    (*comp)++;
    len = strlen(path) - strlen(*comp);
    if (len < 2) {
        len = 2;
    }
    if ((parent = malloc(len)) == NULL) {
        return NULL;
    }
    memcpy(parent, (void *)path, len - 1);
    parent[len - 1] = 0;

    return parent;
}

int IsFixedRootDir(NUTFILE * ndp)
{
    NUTDEVICE *dev = ndp->nf_dev;
    PHATVOL *vol = (PHATVOL *) dev->dev_dcb;
    PHATFILE *fcb;

    /* PHAT32 root directories are expandable. */
    if (vol->vol_type == 32) {
        return 0;
    }

    /* Root directory cluster number is 0 per definition. */
    fcb = ndp->nf_fcb;
    if (fcb->f_de_sect || fcb->f_dirent.dent_clusthi || fcb->f_dirent.dent_clust) {
        return 0;
    }
    return 1;
}

void PhatFilePosRewind(PHATFILE * fcb)
{
    /* Reset current pointer into the file. */
    fcb->f_pos = 0;
    /* Reset current cluster to the first cluster. */
    fcb->f_clust = fcb->f_dirent.dent_clusthi;
    fcb->f_clust <<= 16;
    fcb->f_clust += fcb->f_dirent.dent_clust;
    /* Reset position (sector number) within the cluster. */
    fcb->f_clust_pos = 0;
    /* Reset current position into the current sector. */
    fcb->f_sect_pos = 0;
}

int PhatFilePosSet(NUTFILE * nfp, uint32_t pos)
{
    uint32_t dist;
    uint32_t step;
    uint32_t clust;
    PHATFILE *fcb = nfp->nf_fcb;
    NUTDEVICE *dev = nfp->nf_dev;
    PHATVOL *vol = (PHATVOL *) dev->dev_dcb;

    /* Simple case, rewind the file. */
    if (pos == 0) {
        PhatFilePosRewind(fcb);
        return 0;
    }

    /* We do not support seeking beyond the file size plus one. */
    if ((fcb->f_dirent.dent_attr & PHAT_FATTR_DIR) == 0 && pos > fcb->f_dirent.dent_fsize) {
        return -1;
    }

    /*
     * If the requested position is in front of the currect position,
     * then we start from the beginning.
     * TODO: Should check if we still are in the current cluster.
     */
    if (pos < fcb->f_pos) {
        PhatFilePosRewind(fcb);
        dist = pos;
    } else {
        dist = pos - fcb->f_pos;
    }

    for (;;) {
        if (fcb->f_sect_pos >= vol->vol_sectsz) {
            if (IsFixedRootDir(nfp)) {
                if (fcb->f_clust_pos + 1 >= vol->vol_rootsz) {
                    /* End of root directory, abort reading. */
                    break;
                }
                fcb->f_clust_pos++;
            }
            else {

                /*
                * We reached the end of the current sector. Move to the
                * next sector of the current cluster.
                */
                if (fcb->f_clust_pos + 1 >= vol->vol_clustsz) {
                    /*
                    * We reached the end of the current cluster. Move to
                    * the next cluster.
                    */
                    if (vol->vol_type == 32) {
                        if (Phat32GetClusterLink(dev, fcb->f_clust, &clust)) {
                            break;
                        }
                        if (clust >= (PHATEOC & PHAT32CMASK)) {
                            break;
                        }
                    } else if (vol->vol_type == 16) {
                        if (Phat16GetClusterLink(dev, fcb->f_clust, &clust)) {
                            break;
                        }
                        if (clust >= (PHATEOC & PHAT16CMASK)) {
                            break;
                        }
                    } else if (Phat12GetClusterLink(dev, fcb->f_clust, &clust)) {
                        break;
                    }
                    else if (clust >= (PHATEOC & PHAT12CMASK)) {
                        break;
                    }
                    fcb->f_clust_pos = 0;
                    fcb->f_clust_prv = fcb->f_clust;
                    fcb->f_clust = clust;
                } else {
                    fcb->f_clust_pos++;
                }
            }
            fcb->f_sect_pos = 0;
        }
        if (dist == 0) {
            break;
        }

        /* Calculate the number of bytes available in the current sector. */
        step = vol->vol_sectsz - fcb->f_sect_pos;
        if (step > dist) {
            step = dist;
        }
        fcb->f_sect_pos += step;
        fcb->f_pos += step;
        dist -= step;
    }
    return fcb->f_pos == pos ? 0 : -1;
}