fs.c

Go to the documentation of this file.

#include <string.h>
#include <3ds.h>

static Handle fsuHandle;

// used to determine whether or not we should do FSUSER_Initialize on fsuHandle
Handle __get_handle_from_list(char* name);

Result
fsInit(void)
{
    Result ret;
    if((ret=srvGetServiceHandle(&fsuHandle, "fs:USER"))!=0)return ret;
    if(__get_handle_from_list("fs:USER")==0)ret=FSUSER_Initialize(NULL);
    return ret;
}

Result
fsExit(void)
{
    return svcCloseHandle(fsuHandle);
}

Result
FSUSER_Initialize(Handle* handle)
{
    if(!handle)
    {
        // don't run command if we got handle from the list
        handle = &fsuHandle;
        if(fsuHandle != 0 && __get_handle_from_list("fs:USER")!=0)
            return 0;
    }

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08010002;
    cmdbuf[1] = 0x20;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    return cmdbuf[1];
}

Result
FSUSER_OpenFile(Handle     *handle,
                Handle     *out,
                FS_archive archive,
                FS_path    fileLowPath,
                u32        openFlags,
                u32        attributes)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x080201C2;
    cmdbuf[1] = 0;
    cmdbuf[2] = archive.handleLow;
    cmdbuf[3] = archive.handleHigh;
    cmdbuf[4] = fileLowPath.type;
    cmdbuf[5] = fileLowPath.size;
    cmdbuf[6] = openFlags;
    cmdbuf[7] = attributes;
    cmdbuf[8] = (fileLowPath.size << 14) | 0x2;
    cmdbuf[9] = (u32)fileLowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    if(out)
        *out = cmdbuf[3];

    return cmdbuf[1];
}

Result
FSUSER_OpenFileDirectly(Handle     *handle,
                        Handle     *out,
                        FS_archive archive,
                        FS_path    fileLowPath,
                        u32        openFlags,
                        u32        attributes)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[ 0] = 0x08030204;
    cmdbuf[ 1] = 0;
    cmdbuf[ 2] = archive.id;
    cmdbuf[ 3] = archive.lowPath.type;
    cmdbuf[ 4] = archive.lowPath.size;
    cmdbuf[ 5] = fileLowPath.type;
    cmdbuf[ 6] = fileLowPath.size;
    cmdbuf[ 7] = openFlags;
    cmdbuf[ 8] = attributes;
    cmdbuf[ 9] = (archive.lowPath.size << 14) | 0x802;
    cmdbuf[10] = (u32)archive.lowPath.data;
    cmdbuf[11] = (fileLowPath.size << 14) | 0x2;
    cmdbuf[12] = (u32)fileLowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    if(out)
        *out = cmdbuf[3];

    return cmdbuf[1];
}

Result
FSUSER_DeleteFile(Handle     *handle,
                  FS_archive archive,
                  FS_path    fileLowPath)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08040142;
    cmdbuf[1] = 0;
    cmdbuf[2] = archive.handleLow;
    cmdbuf[3] = archive.handleHigh;
    cmdbuf[4] = fileLowPath.type;
    cmdbuf[5] = fileLowPath.size;
    cmdbuf[6] = (fileLowPath.size << 14) | 0x2;
    cmdbuf[7] = (u32)fileLowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    return cmdbuf[1];
}

Result
FSUSER_RenameFile(Handle     *handle,
                  FS_archive srcArchive,
                  FS_path    srcFileLowPath,
                  FS_archive destArchive,
                  FS_path    destFileLowPath)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08050244;
    cmdbuf[1] = 0;
    cmdbuf[2] = srcArchive.handleLow;
    cmdbuf[3] = srcArchive.handleHigh;
    cmdbuf[4] = srcFileLowPath.type;
    cmdbuf[5] = srcFileLowPath.size;
    cmdbuf[6] = destArchive.handleLow;
    cmdbuf[7] = destArchive.handleHigh;
    cmdbuf[8] = destFileLowPath.type;
    cmdbuf[9] = destFileLowPath.size;
    cmdbuf[10] = (srcFileLowPath.size << 14) | 0x402;
    cmdbuf[11] = (u32)srcFileLowPath.data;
    cmdbuf[12] = (destFileLowPath.size << 14) | 0x802;
    cmdbuf[13] = (u32)destFileLowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    return cmdbuf[1];
}

Result
FSUSER_DeleteDirectory(Handle     *handle,
                       FS_archive archive,
                       FS_path    dirLowPath)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08060142;
    cmdbuf[1] = 0;
    cmdbuf[2] = archive.handleLow;
    cmdbuf[3] = archive.handleHigh;
    cmdbuf[4] = dirLowPath.type;
    cmdbuf[5] = dirLowPath.size;
    cmdbuf[6] = (dirLowPath.size << 14) | 0x2;
    cmdbuf[7] = (u32)dirLowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    return cmdbuf[1];
}

/* stub */
Result
FSUSER_DeleteDirectoryRecursively(void)
{
    return -1;
}

/* stub */
Result
FSUSER_CreateFile(void)
{
    return -1;
}

Result
FSUSER_CreateDirectory(Handle     *handle,
                       FS_archive archive,
                       FS_path    dirLowPath)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08090182;
    cmdbuf[1] = 0;
    cmdbuf[2] = archive.handleLow;
    cmdbuf[3] = archive.handleHigh;
    cmdbuf[4] = dirLowPath.type;
    cmdbuf[5] = dirLowPath.size;
    cmdbuf[6] = 0;
    cmdbuf[7] = (dirLowPath.size << 14) | 0x2;
    cmdbuf[8] = (u32)dirLowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    return cmdbuf[1];
}

Result
FSUSER_RenameDirectory(Handle     *handle,
                       FS_archive srcArchive,
                       FS_path    srcDirLowPath,
                       FS_archive destArchive,
                       FS_path    destDirLowPath)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x080A0244;
    cmdbuf[1] = 0;
    cmdbuf[2] = srcArchive.handleLow;
    cmdbuf[3] = srcArchive.handleHigh;
    cmdbuf[4] = srcDirLowPath.type;
    cmdbuf[5] = srcDirLowPath.size;
    cmdbuf[6] = destArchive.handleLow;
    cmdbuf[7] = destArchive.handleHigh;
    cmdbuf[8] = destDirLowPath.type;
    cmdbuf[9] = destDirLowPath.size;
    cmdbuf[10] = (srcDirLowPath.size << 14) | 0x402;
    cmdbuf[11] = (u32)srcDirLowPath.data;
    cmdbuf[12] = (destDirLowPath.size << 14) | 0x802;
    cmdbuf[13] = (u32)destDirLowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    return cmdbuf[1];
}

Result
FSUSER_OpenDirectory(Handle     *handle,
                     Handle     *out,
                     FS_archive archive,
                     FS_path    dirLowPath)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x080B0102;
    cmdbuf[1] = archive.handleLow;
    cmdbuf[2] = archive.handleHigh;
    cmdbuf[3] = dirLowPath.type;
    cmdbuf[4] = dirLowPath.size;
    cmdbuf[5] = (dirLowPath.size << 14) | 0x2;
    cmdbuf[6] = (u32)dirLowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    if(out)
        *out = cmdbuf[3];

    return cmdbuf[1];
}

Result
FSUSER_OpenArchive(Handle     *handle,
                   FS_archive *archive)
{
    if(!archive)
        return -2;

    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x080C00C2;
    cmdbuf[1] = archive->id;
    cmdbuf[2] = archive->lowPath.type;
    cmdbuf[3] = archive->lowPath.size;
    cmdbuf[4] = (archive->lowPath.size << 14) | 0x2;
    cmdbuf[5] = (u32)archive->lowPath.data;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    archive->handleLow  = cmdbuf[2];
    archive->handleHigh = cmdbuf[3];

    return cmdbuf[1];
}


Result
FSUSER_CloseArchive(Handle     *handle,
                    FS_archive *archive)
{
    if(!archive)
        return -2;

    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x080E0080;
    cmdbuf[1] = archive->handleLow;
    cmdbuf[2] = archive->handleHigh;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    return cmdbuf[1];
}

Result
FSUSER_GetSdmcArchiveResource(Handle *handle,
                              u32    *sectorSize,
                              u32    *clusterSize,
                              u32    *numClusters,
                              u32    *freeClusters)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08140000;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    if(sectorSize)
        *sectorSize = cmdbuf[2];

    if(clusterSize)
        *clusterSize = cmdbuf[3];

    if(numClusters)
        *numClusters = cmdbuf[4];

    if(freeClusters)
        *freeClusters = cmdbuf[5];

    return cmdbuf[1];
}

Result
FSUSER_IsSdmcDetected(Handle *handle,
                      u32    *detected)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08170000;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    if(detected)
        *detected = cmdbuf[2];

    return cmdbuf[1];
}

Result
FSUSER_IsSdmcWritable(Handle *handle,
                      u32    *writable)
{
    if(!handle)
        handle = &fsuHandle;

    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08180000;

    Result ret = 0;
    if((ret = svcSendSyncRequest(*handle)))
        return ret;

    if(writable)
        *writable = cmdbuf[2];

    return cmdbuf[1];
}

Result
FSFILE_Close(Handle handle)
{
    u32* cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08080000;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;

    ret = cmdbuf[1];
    if(!ret)ret = svcCloseHandle(handle);

    return ret;
}

Result
FSFILE_Read(Handle handle,
            u32    *bytesRead,
            u64    offset,
            void   *buffer,
            u32    size)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x080200C2;
    cmdbuf[1] = (u32)offset;
    cmdbuf[2] = (u32)(offset >> 32);
    cmdbuf[3] = size;
    cmdbuf[4] = (size << 4) | 0xC;
    cmdbuf[5] = (u32)buffer;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;

    if(bytesRead)
        *bytesRead = cmdbuf[2];

    return cmdbuf[1];
}

Result
FSFILE_Write(Handle     handle,
             u32        *bytesWritten,
             u64        offset,
             const void *buffer,
             u32        size,
             u32        flushFlags)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08030102;
    cmdbuf[1] = (u32)offset;
    cmdbuf[2] = (u32)(offset >> 32);
    cmdbuf[3] = size;
    cmdbuf[4] = flushFlags;
    cmdbuf[5] = (size << 4) | 0xA;
    cmdbuf[6] = (u32)buffer;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;

    if(bytesWritten)
        *bytesWritten = cmdbuf[2];

    return cmdbuf[1];
}

Result
FSFILE_GetSize(Handle handle,
               u64    *size)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08040000;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;

    if(size)
        *size = (u64)cmdbuf[2] | ((u64)cmdbuf[3] << 32);

    return cmdbuf[1];
}

Result
FSFILE_SetSize(Handle handle,
               u64    size)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08050080;
    cmdbuf[1] = (u32)size;
    cmdbuf[2] = (u32)(size >> 32);

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;


    return cmdbuf[1];
}

Result
FSFILE_GetAttributes(Handle handle,
                     u32    *attributes)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08060000;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;

    if(attributes)
        *attributes = cmdbuf[2];

    return cmdbuf[1];
}

Result
FSFILE_SetAttributes(Handle handle,
                     u32    attributes)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08070040;
    cmdbuf[1] = attributes;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;

    return cmdbuf[1];
}

Result
FSFILE_Flush(Handle handle)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08090000;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;

    return cmdbuf[1];
}

Result
FSDIR_Read(Handle    handle,
           u32       *entriesRead,
           u32       entryCount,
           FS_dirent *buffer)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08010042;
    cmdbuf[1] = entryCount;
    cmdbuf[2] = ((entryCount*0x228) << 4) | 0xC;
    cmdbuf[3] = (u32)buffer;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;

    if(entriesRead)
        *entriesRead = cmdbuf[2];

    return cmdbuf[1];
}

Result
FSDIR_Close(Handle handle)
{
    u32 *cmdbuf = getThreadCommandBuffer();

    cmdbuf[0] = 0x08020000;

    Result ret = 0;
    if((ret = svcSendSyncRequest(handle)))
        return ret;
    ret = cmdbuf[1];
    if(!ret)ret = svcCloseHandle(handle);
    return ret;
}