BackupPC-XS

 view release on metacpan or  search on metacpan

BackupPC_XS.xs  view on Meta::CPAN

int
delete(info, d)
        BackupPC::XS::PoolRefCnt info;
        SV *d;
    CODE:
    {
        bpc_digest digest;
        char *str;
        STRLEN len;

        if ( !SvPOK(d) ) {
            XSRETURN_UNDEF;
        }
        str = SvPV(d, len);
        if ( 0 < len && len < sizeof(digest.digest) ) {
            memcpy(digest.digest, str, len);
            digest.len = len;
            if ( bpc_poolRefDelete(info, &digest) ) XSRETURN_UNDEF;
            RETVAL = 1;
        } else {
            XSRETURN_UNDEF;
        }
    }
    OUTPUT:
        RETVAL

int
incr(info, d, delta)
        BackupPC::XS::PoolRefCnt info;
        SV *d;
        int delta;
    CODE:
    {
        bpc_digest digest;
        char *str;
        STRLEN len;

        if ( !SvPOK(d) ) {
            XSRETURN_UNDEF;
        }
        str = SvPV(d, len);
        if ( 0 < len && len < sizeof(digest.digest) ) {
            memcpy(digest.digest, str, len);
            digest.len = len;
            RETVAL = bpc_poolRefIncr(info, &digest, delta);
        } else {
            XSRETURN_UNDEF;
        }
    }
    OUTPUT:
        RETVAL

void
iterate(info, idx)
        BackupPC::XS::PoolRefCnt info;
        unsigned int idx;
    PREINIT:
        bpc_digest digest;
        int count;
    PPCODE:
    {
        if ( !bpc_poolRefIterate(info, &digest, &count, &idx) ) {
            EXTEND(SP, 3);
            PUSHs(sv_2mortal(newSVpvn((char*)digest.digest, digest.len)));
            PUSHs(sv_2mortal(newSViv(count)));
            PUSHs(sv_2mortal(newSViv(idx)));
        }
    }

int
read(info, fileName)
        BackupPC::XS::PoolRefCnt info;
        char *fileName;
    CODE:
        RETVAL = bpc_poolRefFileRead(info, fileName);
    OUTPUT:
        RETVAL

int
write(info, fileName)
        BackupPC::XS::PoolRefCnt info;
        char *fileName;
    CODE:
        RETVAL = bpc_poolRefFileWrite(info, fileName);
    OUTPUT:
        RETVAL

void
print(info)
        BackupPC::XS::PoolRefCnt info;
    CODE:
        bpc_poolRefCountPrint(info);

void
DeltaFileInit(hostDir)
        char *hostDir;
    CODE:
        bpc_poolRefDeltaFileInitOld(hostDir);

unsigned int
DeltaFileFlush()
    CODE:
        RETVAL = bpc_poolRefDeltaFileFlushOld();
    OUTPUT:
        RETVAL

void
DeltaUpdate(compress, d, count)
        int compress;
        SV *d;
        int count;
    CODE:
    {
        bpc_digest digest;
        char *str;
        STRLEN len;

        if ( SvPOK(d) ) {
            str = SvPV(d, len);
            if ( 0 < len && len < sizeof(digest.digest) ) {

BackupPC_XS.xs  view on Meta::CPAN

void
print(info)
        BackupPC::XS::DeltaRefCnt info;
    CODE:
        bpc_poolRefDeltaPrint(info);

MODULE = BackupPC::XS		PACKAGE = BackupPC::XS::PoolWrite

BackupPC::XS::PoolWrite
new(compressLevel, d = NULL)
        int  compressLevel;
        SV   *d;
    CODE:
    {
        int ret = 0;

        RETVAL = calloc(1, sizeof(bpc_poolWrite_info));
        if ( d && SvPOK(d) ) {
            bpc_digest digest;
            char *str;
            STRLEN len;

            str = SvPV(d, len);
            if ( 0 < len && len < sizeof(digest.digest) ) {
                memcpy(digest.digest, str, len);
                digest.len = len;
                ret = bpc_poolWrite_open(RETVAL, compressLevel, &digest);
            } else {
                ret = bpc_poolWrite_open(RETVAL, compressLevel, NULL);
            }
        } else {
            ret = bpc_poolWrite_open(RETVAL, compressLevel, NULL);
        }
        if ( ret ) {
            free(RETVAL);
            RETVAL = NULL;
        }
    }
    OUTPUT:
        RETVAL

void
DESTROY(info)
        BackupPC::XS::PoolWrite info;
    CODE:
    {
        bpc_poolWrite_cleanup(info);
        free(info);
    }

void
close(info)
        BackupPC::XS::PoolWrite info;
    PREINIT:
        int match;
        bpc_digest digest;
        off_t poolFileSize;
        int errorCnt;

    PPCODE:
    {
        bpc_poolWrite_close(info, &match, &digest, &poolFileSize, &errorCnt);
        EXTEND(SP, 4);
        PUSHs(sv_2mortal(newSViv(match)));
        PUSHs(sv_2mortal(newSVpvn((char*)digest.digest, digest.len)));
        PUSHs(sv_2mortal(newSViv(poolFileSize)));
        PUSHs(sv_2mortal(newSViv(errorCnt)));
    }

int
write(info, data)
        BackupPC::XS::PoolWrite info;
        SV *data;
    CODE:
    {
        char *str;
        STRLEN len;

        if ( SvROK(data) ) {
            str = SvPV(SvRV(data), len);
            RETVAL = bpc_poolWrite_write(info, (unsigned char*)str, len);
        } else {
            RETVAL = -1;
        }
    }
    OUTPUT:
        RETVAL

void
addToPool(info, fileName, v3PoolFile)
        BackupPC::XS::PoolWrite info;
        char *fileName;
        int v3PoolFile;
    CODE:
        bpc_poolWrite_addToPool(info, fileName, v3PoolFile);

MODULE = BackupPC::XS		PACKAGE = BackupPC::XS::Attrib

BackupPC::XS::Attrib
new(compressLevel)
        int compressLevel;
    CODE:
    {
        RETVAL = calloc(1, sizeof(bpc_attrib_dir));
        bpc_attrib_dirInit(RETVAL, compressLevel);
    }
    OUTPUT:
        RETVAL

void
DESTROY(dir)
        BackupPC::XS::Attrib dir;
    CODE:
    {
        bpc_attrib_dirDestroy(dir);
        free(dir);
    }

SV*
get(dir, fileName = NULL)
        BackupPC::XS::Attrib dir;
        char *fileName;
    CODE:
    {
        if ( fileName ) {
            bpc_attrib_file *file = bpc_attrib_fileGet(dir, fileName, 0);
            if ( !file ) XSRETURN_UNDEF;
            RETVAL = newRV_noinc((SV*)convert_file2hv(file, file->name));
        } else {
            ssize_t entrySize, i;

            RETVAL = NULL;
            if ( (entrySize = bpc_attrib_getEntries(dir, NULL, 0)) > 0 ) {
                char *entries = malloc(entrySize), *p;

                if ( entries && bpc_attrib_getEntries(dir, entries, entrySize) > 0 ) {
                    HV *rh = newHV();
                    for ( i = 0, p = entries ; i < entrySize ; ) {
                        int len = strlen(p);
                        bpc_attrib_file *file;

                        file = bpc_attrib_fileGet(dir, p, 0);
                        p += len + 1;
                        i += len + 1;
                        if ( !file ) continue;
                        (void)hv_store(rh, file->name, strlen(file->name), newRV_noinc((SV*)convert_file2hv(file, file->name)), 0);
                    }
                    RETVAL = newRV_noinc((SV*)rh);
                }
                if ( entries ) free(entries);
            }
            if ( !RETVAL ) XSRETURN_UNDEF;
        }
    }
    OUTPUT:
        RETVAL

int
set(dir, fileName, hv)
        BackupPC::XS::Attrib dir;
        char *fileName;
        HV *hv;
    CODE:
    {
        bpc_attrib_file *file = bpc_attrib_fileGet(dir, fileName, 0);

        RETVAL = file ? 1 : 0;
        if ( !file ) {
            file = bpc_attrib_fileGet(dir, fileName, 1);
            bpc_attrib_fileInit(file, fileName, 0);
        }
        convert_hv2file(hv, file);
    }
    OUTPUT:
        RETVAL

void
digest(dir)
        BackupPC::XS::Attrib dir;
    PREINIT:
    PPCODE:
    {
        bpc_digest *digest = bpc_attrib_dirDigestGet(dir);
        if ( digest && digest->len > 0 ) {
            EXTEND(SP, 1);
            PUSHs(sv_2mortal(newSVpvn((char*)digest->digest, digest->len)));
        }
    }

void
iterate(dir, idx)
        BackupPC::XS::Attrib dir;
        unsigned int idx;
    PREINIT:
        bpc_attrib_file *file;
    PPCODE:
    {
        if ( !bpc_attrib_fileIterate(dir, &file, &idx) && file ) {
            EXTEND(SP, 2);
            PUSHs(sv_2mortal(newRV_noinc((SV*)convert_file2hv(file, file->name))));
            PUSHs(sv_2mortal(newSViv(idx)));
        }
    }

char*
errStr(void)
    CODE:
        RETVAL = "TODO";
    OUTPUT:
        RETVAL

int
count(dir)
        BackupPC::XS::Attrib dir;
    CODE:
        RETVAL = bpc_attrib_fileCount(dir);
    OUTPUT:
        RETVAL

void
delete(dir, fileName)
        BackupPC::XS::Attrib dir;
        char *fileName;
    CODE:
        bpc_attrib_fileDeleteName(dir, fileName);

int
read(dir, dirPath, attribFileName = "attrib")
        BackupPC::XS::Attrib dir;
        char *dirPath;
        char *attribFileName;
    CODE:
        if ( !*dirPath ) dirPath = NULL;
        RETVAL = !bpc_attrib_dirRead(dir, dirPath, attribFileName, 0);
    OUTPUT:
        RETVAL

int
write(dir, dirPath, attribFileName, d = NULL, deltaInfo = NULL)
        BackupPC::XS::Attrib dir;
        char *dirPath;
        char *attribFileName;
        SV *d;
        BackupPC::XS::DeltaRefCnt deltaInfo;
    CODE:
        if ( !*dirPath ) dirPath = NULL;
        if ( d && SvPOK(d) ) {
            bpc_digest digest;
            char *str;
            STRLEN len;

            str = SvPV(d, len);
            if ( 0 < len && len < sizeof(digest.digest) ) {
                memcpy(digest.digest, str, len);
                digest.len = len;
                RETVAL = !bpc_attrib_dirWrite(deltaInfo, dir, dirPath, attribFileName, &digest);

BackupPC_XS.xs  view on Meta::CPAN

        char pathCopy[BPC_MAXPATHLEN];

        snprintf(pathCopy, sizeof(pathCopy), "%s", path);
        RETVAL = NULL;
        if ( (entrySize = bpc_attribCache_getDirEntries(ac, pathCopy, NULL, 0)) > 0 ) {
            char *entries = malloc(entrySize), *p;

            if ( entries && bpc_attribCache_getDirEntries(ac, pathCopy, entries, entrySize) > 0 ) {
                HV *rh = newHV();
                for ( i = 0, p = entries ; i < entrySize ; ) {
                    int len = strlen(p);
                    char *fileNameSave = p;
                    char filePath[BPC_MAXPATHLEN];
                    bpc_attrib_file *file;

                    snprintf(filePath, sizeof(filePath), "%s/%s", path, p);
                    file = bpc_attribCache_getFile(ac, filePath, 0, dontReadInode);
                    p += len + 1 + sizeof(ino_t);
                    i += len + 1 + sizeof(ino_t);
                    if ( !file ) continue;
                    /* printf("Storing file name %s for path %s\n", fileNameSave, path); */
                    (void)hv_store(rh, fileNameSave, strlen(fileNameSave), newRV_noinc((SV*)convert_file2hv(file, fileNameSave)), 0);
                }
                RETVAL = newRV_noinc((SV*)rh);
            }
            if ( entries ) free(entries);
        }
        if ( !RETVAL ) XSRETURN_UNDEF;
    }
    OUTPUT:
        RETVAL

void
flush(ac, all = 1, path = NULL)
        BackupPC::XS::AttribCache ac;
        int all
        char *path;
    CODE:
        bpc_attribCache_flush(ac, all, path);

SV*
getFullMangledPath(ac, dirName)
        BackupPC::XS::AttribCache ac;
        char *dirName;
    CODE:
    {
        char path[BPC_MAXPATHLEN];
        bpc_attribCache_getFullMangledPath(ac, path, dirName, -1);
        RETVAL = newSVpvn(path, strlen(path));
    }
    OUTPUT:
        RETVAL

MODULE = BackupPC::XS		PACKAGE = BackupPC::XS::FileDigest

void
digest(fileName, compress)
        char *fileName;
        int compress;
    PREINIT:
    PPCODE:
    {
        bpc_digest digest;
        if ( bpc_fileDigest(fileName, compress, &digest) == 0 ) {
            EXTEND(SP, 1);
            PUSHs(sv_2mortal(newSVpvn((char*)digest.digest, digest.len)));
        }
    }

MODULE = BackupPC::XS		PACKAGE = BackupPC::XS::DirOps

int
path_create(path)
        char *path;
    CODE:
        RETVAL = bpc_path_create(path);
    OUTPUT:
        RETVAL

int
path_remove(path, compress, deltaInfo = NULL)
        char *path;
        int compress;
        BackupPC::XS::DeltaRefCnt deltaInfo;
    CODE:
        RETVAL = bpc_path_remove(deltaInfo, path, compress);
    OUTPUT:
        RETVAL

int
refCountAll(path, compress, incr = 1, deltaInfo = NULL)
        char *path;
        int compress;
        int incr;
        BackupPC::XS::DeltaRefCnt deltaInfo;
    CODE:
        RETVAL = bpc_path_refCountAll(deltaInfo, path, compress, incr);
    OUTPUT:
        RETVAL

void
refCountAllInodeMax(path, compress, incr = 1, deltaInfo = NULL)
        char *path;
        int compress;
        int incr;
        BackupPC::XS::DeltaRefCnt deltaInfo;
    PREINIT:
        int retVal;
        unsigned int inodeMax = 0;
    PPCODE:
    {
        retVal = bpc_path_refCountAllInodeMax(deltaInfo, path, compress, incr, &inodeMax);
        EXTEND(SP, 2);
        PUSHs(sv_2mortal(newSViv(retVal)));
        PUSHs(sv_2mortal(newSViv(inodeMax)));
    }

int
lockRangeFd(fd, offset, len, block)
        int fd;
        unsigned int offset;
        unsigned int len;
        int block;
    CODE:
        RETVAL = bpc_lockRangeFd(fd, offset, len, block);
    OUTPUT:
        RETVAL

int
unlockRangeFd(fd, offset, len)
        int fd;
        unsigned int offset;
        unsigned int len;
    CODE:
        RETVAL = bpc_unlockRangeFd(fd, offset, len);
    OUTPUT:
        RETVAL

int
lockRangeFile(lockFile, offset, len, block)
        char *lockFile;
        unsigned int offset;
        unsigned int len;
        int block;
    CODE:
        RETVAL = bpc_lockRangeFile(lockFile, offset, len, block);
    OUTPUT:
        RETVAL

void
unlockRangeFile(lockFd)
        int lockFd;
    CODE:
        bpc_unlockRangeFile(lockFd);
        
MODULE = BackupPC::XS		PACKAGE = BackupPC::XS::Lib

void
ConfInit(topDir, hardLinkMax, poolV3Enabled, logLevel = 0)
        char *topDir;
        int hardLinkMax;
        int poolV3Enabled;
        int logLevel;
    CODE:
        bpc_lib_conf_init(topDir, hardLinkMax, poolV3Enabled, logLevel);

SV*
logMsgGet()
    CODE:
    {