Xrdadler32.cc File Reference

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <cerrno>
#include <zlib.h>
#include "XrdPosix/XrdPosixXrootd.hh"
#include "XrdPosix/XrdPosixXrootdPath.hh"
#include "XrdOuc/XrdOucString.hh"
#include "XrdCks/XrdCksXAttr.hh"
#include "XrdOuc/XrdOucXAttr.hh"

Include dependency graph for Xrdadler32.cc:

Go to the source code of this file.

Macros
#define	_FILE_OFFSET_BITS   64
#define	N   1024*1024 /* reading block size */

Functions
int	fGetXattrAdler32 (const char *path, int fd, const char *attr, char *value)
int	fGetXattrAdler32 (int fd, const char *attr, char *value)
void	fSetXattrAdler32 (const char *path, int fd, const char *attr, char *value)
char	getchksum (const char *rooturl, char *chksum)
int	main (int argc, char *argv[])

Macro Definition Documentation

_FILE_OFFSET_BITS

#define _FILE_OFFSET_BITS   64

Definition at line 36 of file Xrdadler32.cc.

N

#define N   1024*1024 /* reading block size */

Definition at line 160 of file Xrdadler32.cc.

Function Documentation

fGetXattrAdler32() [1/2]

int fGetXattrAdler32	(	const char *	path,
		int	fd,
		const char *	attr,
		char *	value
	)

Definition at line 118 of file Xrdadler32.cc.

{
    XrdOucXAttr<XrdCksXAttr> xCS;
    struct stat st;
 
    if (!xCS.Attr.Cks.Set("adler32") || xCS.Get(path, fd) <= 0
    || strcmp(xCS.Attr.Cks.Name, "adler32"))
       {int rc = fGetXattrAdler32(fd, attr, value);
        if (rc == 8) fSetXattrAdler32(path, fd, attr, value);
        return rc;
       }
 
    if (fstat(fd, &st)
    ||  xCS.Attr.Cks.fmTime != static_cast<long long>(st.st_mtime)) return 0;
 
    xCS.Attr.Cks.Get(value, 9);
    return 8;
}

References fGetXattrAdler32(), fSetXattrAdler32(), fstat, stat, and xCS.

Here is the call graph for this function:

fGetXattrAdler32() [2/2]

int fGetXattrAdler32	(	int	fd,
		const char *	attr,
		char *	value
	)

Definition at line 84 of file Xrdadler32.cc.

{
    struct stat st;
    char mtime[12], attr_val[25], *p;
    int rc;
 
    if (fstat(fd, &st)) return 0;
    sprintf(mtime, "%lld", (long long) st.st_mtime);
 
#if defined(__linux__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
    rc = fgetxattr(fd, attr, attr_val, 25);
#elif defined(__solaris__)
    int attrfd;
    attrfd = openat(fd, attr, O_XATTR|O_RDONLY);
    if (attrfd < 0) return(0);
 
    rc = read(attrfd, attr_val, 25);
    close(attrfd);
#else
    return(0);
#endif
 
    if (rc == -1 || attr_val[8] != ':') return(0);
    attr_val[8] = '\0';
    attr_val[rc] = '\0';
    p = attr_val + 9;
     
    if (strcmp(p, mtime)) return(0);
 
    strcpy(value, attr_val);
 
    return(strlen(value));
}

References close, fstat, read, and stat.

Referenced by fGetXattrAdler32(), and main().

Here is the caller graph for this function:

fSetXattrAdler32()

void fSetXattrAdler32	(	const char *	path,
		int	fd,
		const char *	attr,
		char *	value
	)

Definition at line 58 of file Xrdadler32.cc.

{
    XrdOucXAttr<XrdCksXAttr> xCS;
    struct stat st;
    
    if (fstat(fd, &st) || strlen(value) != 8) return;
 
    if (!xCS.Attr.Cks.Set("adler32") || !xCS.Attr.Cks.Set(value,8)) return;
 
    xCS.Attr.Cks.fmTime = static_cast<long long>(st.st_mtime);
    xCS.Attr.Cks.csTime = static_cast<int>(time(0) - st.st_mtime);
 
    xCS.Set("", fd);
 
// Remove any old attribute at this point
//
#if defined(__linux__) || defined(__GNU__) || (defined(__FreeBSD_kernel__) && defined(__GLIBC__))
    fremovexattr(fd, attr);
#elif defined(__solaris__)
    int attrfd;
    attrfd = openat(fd, attr, O_XATTR|O_RDONLY);
    if (attrfd >= 0)
       {unlinkat(attrfd, attr, 0); close(attrfd);}
#endif
}

References XrdOucXAttr< T >::Attr, close, fstat, stat, and xCS.

Referenced by fGetXattrAdler32(), and main().

Here is the caller graph for this function:

getchksum()

char getchksum	(	const char *	rooturl,
		char *	chksum
	)

Definition at line 138 of file Xrdadler32.cc.

{
    char csBuff[256];
    int  csLen;
 
// Obtain the checksum (this is the default checksum)
//
   csLen = XrdPosixXrootd::Getxattr(rooturl, "xroot.cksum",
                                    csBuff,  sizeof(csBuff));
   if (csLen <  0) return -1;
   if (csLen == 0) return  0; // Server doesn't have the checksum
 
// Verify that the checksum returned is "adler32"
//
   if (strncmp("adler32 ", csBuff, 8)) return 0;
 
// Return the checksum value (this is really bad code)
//
   strcpy(chksum, csBuff+8);
   return strlen(csBuff+8);
}

References XrdPosixXrootd::Getxattr().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[]
	)

!! TO DO: Remove testing of totbytes once XrdClEC read regression is fixed

Definition at line 162 of file Xrdadler32.cc.

{
    char path[2048], chksum[128], buf[N], adler_str[9];
    const char attr[] = "user.checksum.adler32";
    struct stat stbuf;
    int fd, len, rc;
    uLong adler;
    adler = adler32(0L, Z_NULL, 0);
 
    if (argc == 2 && ! strcmp(argv[1], "-h"))
    {
        printf("Usage: %s file. Calculating adler32 checksum of a given file.\n", argv[0]);
        printf("A file can be local file, stdin (if omitted), or root URL (including via XROOTD_VMP)\n");
        return 0;
    }
 
    path[0] = '\0';
    if (argc > 1)  /* trying to convert to root URL */
    {
        if (!strncmp(argv[1], "root://", 7))
            strcpy(path, argv[1]);
        else {XrdPosixXrootPath xrdPath;
              xrdPath.URL(argv[1], path, sizeof(path));
             }
    }
    if (argc == 1 || path[0] == '\0')
    {                        /* this is a local file */
        if (argc > 1)
        {
            strcpy(path, argv[1]);
            if ((fd = open(path, O_RDONLY)) < 0 || fstat(fd, &stbuf) != 0 || !S_ISREG(stbuf.st_mode))
            {
                if (fd != -1)
                  close(fd);
                printf("Error opening %s: %s\n", path, strerror(errno));
                return 1;
            }
            else  /* see if the adler32 is saved in attribute already */
                if (fGetXattrAdler32(path, fd, attr, adler_str) == 8)
                {
                    printf("%s %s\n", adler_str, path);
                    return 0;
                }
        }
        else 
        {
            fd = STDIN_FILENO;
            strcpy(path, "-");
        }
        while ( (len = read(fd, buf, N)) > 0 )
            adler = adler32(adler, (const Bytef*)buf, len);
 
        if (fd != STDIN_FILENO) 
        {   /* try saving adler32 to attribute before close() */
            sprintf(adler_str, "%08lx", adler);
            fSetXattrAdler32(path, fd, attr, adler_str);
            close(fd);
        }
        printf("%08lx %s\n", adler, path);
        return 0;
    }
    else
    {                       /* this is a Xrootd file */
        if (getchksum(path, chksum) > 0) 
        {                   /* server implements checksum */
             printf("%s %s\n", chksum, argv[1]);
             return (strcmp(chksum, "Error_accessing:") ? 0 : 1);
        }
        else
        {                   /* need to read the file and calculate */
            XrdPosixXrootd myPFS(-8, 8, 1);
            rc = XrdPosixXrootd::Stat(path, &stbuf);
            if (rc != 0 || ! S_ISREG(stbuf.st_mode) ||
                (fd = XrdPosixXrootd::Open(path, O_RDONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
            {
                printf("Error_accessing: %s\n", argv[1]);
                return 1;
            }
            off_t totbytes = 0;
            while ( totbytes < stbuf.st_size && (len = XrdPosixXrootd::Read(fd, buf, N)) > 0 )
            {
                adler = adler32(adler, 
                                (const Bytef*)buf, 
                                (len < (stbuf.st_size - totbytes)? len : stbuf.st_size - totbytes ));
                totbytes += len;
            }
 
            XrdPosixXrootd::Close(fd);
            printf("%08lx %s\n", adler, argv[1]);
            return 0;
        }
    }
}

References close, XrdPosixXrootd::Close(), fGetXattrAdler32(), fSetXattrAdler32(), fstat, getchksum(), N, open, XrdPosixXrootd::Open(), read, XrdPosixXrootd::Read(), stat, XrdPosixXrootd::Stat(), and XrdPosixXrootPath::URL().

Here is the call graph for this function: