drobj.c

NUcleus plus 支持的文件系统。 是学习文件系统的很好参考资料。

            return(NUF_NO_DROBJ);
    }
    else    /* If doing a gnext don't get stuck in and endless loop */
    {
        if ( ++((*pobj)->blkinfo.my_index) >= INOPBLOCK )
        {
            ret_stat = pc_next_block(*pobj);
            if (ret_stat != NU_SUCCESS)
            {
                if (ret_stat == NUF_NOSPC)
                    ret_stat = NUF_NOFILE;

                return(ret_stat);
            }
            else
                (*pobj)->blkinfo.my_index = 0;
        }
    }

    /* Find the filename */
    ret_stat = pc_findin(*pobj, filename);
    if (ret_stat != NU_SUCCESS)
    {
        /* Mark the fname[0] == "\0" entry blocks and index */
        if (ret_stat == NUF_NOFILE)
        {
            pmom->blkinfo.end_block = (*pobj)->blkinfo.my_block;
            pmom->blkinfo.end_index = (*pobj)->blkinfo.my_index;
        }
        if (starting)
        {
            pc_freeobj(*pobj);
            *pobj = NULL;
        }
    }
    return(ret_stat);
}


/************************************************************************
* FUNCTION                                                              
*                                                                       
*       pc_next_inode                                                   
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       Next search the directory for the pattern or name in filename.  
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Kyoichiro Toda                             
*                                                                       
* INPUTS                                                                
*                                                                       
*       pobj                                Pobj must not NULL.         
*       *pmom                               Search the drive object     
*       *filename                           Search file name            
*       attrib                              File attributes             
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       NU_SUCCESS                          Search successful.          
*       NUF_ACCES                           Attempt to open a read only 
*                                            file or a special.         
*       NUF_NOFILE                          The specified file not      
*                                            found.                     
*       NUF_NO_FINODE                       No FINODE buffer available. 
*       NUF_IO_ERROR                        Driver IO error.            
*       NUF_INTERNAL                        Nucleus FILE internal error.
*                                                                       
*************************************************************************/
STATUS pc_next_inode(DROBJ *pobj, DROBJ *pmom, UINT8 *filename, INT attrib)
{
STATUS      ret_stat;
STATUS      ret_stat_w;


    ret_stat = NUF_NOFILE;

    while (pobj)
    {
        /* Now find the next file */
        ret_stat_w = pc_get_inode(&pobj, pmom, (UINT8 *)filename);
        if (ret_stat_w != NU_SUCCESS)
        {
            if (ret_stat != NUF_ACCES)
                ret_stat = ret_stat_w;
            break;
        }

        if (pobj->finode->fattribute & attrib)
        {
            if (! (pc_isdot(pobj->finode->fname, pobj->finode->fext)) &&
                ! (pc_isdotdot(pobj->finode->fname, pobj->finode->fext)) )
                ret_stat = NUF_ACCES;
        }
        else
        {
            ret_stat = NU_SUCCESS;
            break;
        }
    }
    return(ret_stat);
}


/************************************************************************
* FUNCTION                                                              
*                                                                       
*       chk_sum                                                         
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       Calculating Short File Name Check byte                          
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Koji Mugita                       
*                                                                       
* INPUTS                                                                
*                                                                       
*       *sname                              Short File Name String      
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       Check byte                                                      
*                                                                       
*************************************************************************/
UINT8 chk_sum(UINT8 *sname)
{
INT         i;
UINT8       aa,bb,cc,dd;


    dd = 0;
    for (i = 0; i< 10; i++)
    {
        aa = sname[i] + dd;
        bb = aa>>1;
        cc = bb + 0x80;
        if (aa % 2)
        {
            aa = cc;
        }
        else
        {
            aa = bb;
        }
        dd = aa;
    }
    return(dd + sname[i]);
}



/************************************************************************
* FUNCTION                                                              
*                                                                       
*       pc_cre_longlen                                                  
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       Create long-filename ascii strings from directory entry.        
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Takahiro Takahashi                         
*                                                                       
* INPUTS                                                                
*                                                                       
*       *filename                           Pointer to filename to write
*                                            filename                   
*       *info                               Long filename information   
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       Always YES                          Success compleate.          
*                                                                       
*************************************************************************/
INT pc_cre_longname(UINT8 *filename, LNAMINFO *linfo)
{
INT         i, ci;
INT         my_index;
BLKBUFF     *bbuf;
LNAMENT     *ent;


    if (linfo->lnamblk3)
    {
        /* Top entry is in rbuf */
        my_index = linfo->lnament - (INOPBLOCK - linfo->lnam_index) - 1 - INOPBLOCK;
        bbuf = linfo->lnamblk3;
    }
    else if (linfo->lnamblk2)
    {
        /* Top entry is in rbuf */
        my_index = linfo->lnament - (INOPBLOCK - linfo->lnam_index) - 1;
        bbuf =  linfo->lnamblk2;
    }
    else
    {
        /* Top entry is in the buf */
        my_index = linfo->lnam_index + linfo->lnament - 1;
        bbuf = linfo->lnamblk1;
    }

    for (i = 0; i< linfo->lnament; )
    {
        /* Long file name start block */
        ent = (LNAMENT *)bbuf->data;

        /* Long file name start entry */
        ent +=  my_index;

        for (; (my_index >= 0) && (i< linfo->lnament); my_index--, i++)
        {
            for (ci = 0; ci < 10; ci += 2)
            {
                /* Convert Unicode to ASCII */
                *filename++ = uni2asc(&ent->str1[ci]);
            }
            for (ci = 0; ci < 12; ci += 2)
            {
                /* Convert Unicode to ASCII */
                *filename++ = uni2asc(&ent->str2[ci]);
            }
            for (ci = 0; ci < 4; ci += 2)
            {
                /* Convert Unicode to ASCII */
                *filename++ = uni2asc(&ent->str3[ci]);
            }
            *filename = '\0';
            ent--;
        }
        my_index = INOPBLOCK - 1;
        /* Long file name block */
        if (bbuf == linfo->lnamblk3)
            bbuf = linfo->lnamblk2;
        else if (bbuf == linfo->lnamblk2)
            bbuf = linfo->lnamblk1;
    }
    return(YES);
}


/************************************************************************
* FUNCTION                                                              
*                                                                       
*       pc_cre_shortfilename                                            
*                                                                       
* DESCRIPTION                                                           
*                                                                       
*       Create short-filename ascii strings from directory entry.       
*                                                                       
* AUTHOR                                                                
*                                                                       
*       Kyoichiro Toda                             
*                                                                       
* INPUTS                                                                
*                                                                       
*       *filename                           Pointer to filename to write
*                                            filename                   
*       *dirent                             Pointer to directory entry  
*                                                                       
* OUTPUTS                                                               
*                                                                       
*       Short file name length                                          
*                                                                       
*************************************************************************/
INT pc_cre_shortname(UINT8 *filename, UINT8 *fname, UINT8 *fext)
{
INT16       i;
UINT8       *top = filename;
INT         len = 0;


    i = 0;

    if (*fname == 0x05)
    {
        *filename = 0xE5;
        filename++;
        fname++;
        i++;
    }

    /* Setup the file name. */
    while(*fname)
    {
        if (*fname == ' ')
            break;
        else
        {
            *filename++ = *fname++;
            i++;
        }
        if (i == 8)
            break;
    }

    /* save filename length */
    len = i;
    
    /* Setup the file extention. */
    i = 0;
    if ( (fext) && (*fext!= ' ') )