diff --git a/fsarchiver/src/archwriter.c b/fsarchiver/src/archwriter.c

index b9a8d55..2d47e25 100644

--- a/fsarchiver/src/archwriter.c

+++ b/fsarchiver/src/archwriter.c

@@ -190,8 +190,8 @@ int archwriter_write_buffer(carchwriter *ai, struct s_writebuf *wb)

     assert(ai);

     assert(wb);

-    if (wb->size <=0)

-    {   errprintf("wb->size=%ld\n", (long)wb->size);

+    if ( wb->size ==0)

+    {   errprintf("wb=size=%ld\n", (long)wb->size);

         return -1;

     }

diff --git a/fsarchiver/src/devinfo.c b/fsarchiver/src/devinfo.c

index 9c95265..d2c8af1 100644

--- a/fsarchiver/src/devinfo.c

+++ b/fsarchiver/src/devinfo.c

@@ -88,7 +88,7 @@ int get_devinfo(struct s_devinfo *outdev, char *indevname, int min, int maj)

     // get device basic info (size, major, minor)

     if (((fd=open64(outdev->longname, O_RDONLY|O_LARGEFILE))<0) || 

-        ((outdev->devsize=lseek64(fd, 0, SEEK_END))<0) ||

+        ((outdev->devsize=lseek64(fd, 0, SEEK_END))==(u64) -1 ) ||

         (fstat64(fd, &statbuf)!=0) ||

         (!S_ISBLK(statbuf.st_mode)) ||

         (close(fd)<0))

@@ -102,7 +102,7 @@ int get_devinfo(struct s_devinfo *outdev, char *indevname, int min, int maj)

     // devname shown in /sys/block (eg for HP-cciss: "cciss/c0d0" -> "cciss!c0d0")

     snprintf(sysblkdevname, sizeof(sysblkdevname), "%s", outdev->devname);

-    for (i=0; (sysblkdevname[i]!=0) && (i<sizeof(sysblkdevname)); i++)

+    for (i=0; (i<sizeof(sysblkdevname) && (sysblkdevname[i]!=0) ); i++)

         if (sysblkdevname[i]=='/')

             sysblkdevname[i]='!';

diff --git a/fsarchiver/src/filesys.c b/fsarchiver/src/filesys.c

index 6be555e..caa43c5 100644

--- a/fsarchiver/src/filesys.c

+++ b/fsarchiver/src/filesys.c

@@ -330,7 +330,7 @@ int generic_umount(char *mntbuf)

     }

     msgprintf(MSG_DEBUG1, "unmount_partition(%s)\n", mntbuf);

-    for (i=0, errno=0 ; (i < 4) && (res=umount2(mntbuf, 0)!=0) && (errno==EBUSY) ; i++)

+    for (i=0, errno=0 ; (i < 4) && ((res=umount2(mntbuf, 0))!=0) && (errno==EBUSY) ; i++)

     {   sync();

         sleep(i+1);

     }

diff --git a/fsarchiver/src/fs_reiser4.c b/fsarchiver/src/fs_reiser4.c

index 42993d5..8c1cb61 100644

--- a/fsarchiver/src/fs_reiser4.c

+++ b/fsarchiver/src/fs_reiser4.c

@@ -126,8 +126,8 @@ int reiser4_getinfo(cdico *d, char *devname)

     temp16=le16_to_cpu(sb.blocksize);

     if (temp16!=4096)

     {   ret=-5;

-        goto reiser4_get_specific_close;

         errprintf("invalid reiser4 block-size: %ld, it should be 4096\n", (long)temp16);

+        goto reiser4_get_specific_close;

     }

     else

     {   dico_add_u64(d, 0, FSYSHEADKEY_FSREISER4BLOCKSIZE, temp16);

diff --git a/fsarchiver/src/oper_probe.c b/fsarchiver/src/oper_probe.c

index a8f15c4..d3c4991 100644

--- a/fsarchiver/src/oper_probe.c

+++ b/fsarchiver/src/oper_probe.c

@@ -108,7 +108,7 @@ int partlist_getlist(struct s_devinfo *blkdev, int maxblkdev, int *diskcount, in

     for (pos=0, i=0; i<count; i++)

     {

         // set best to the first available item in the old array

-        for (j=0, best=-1; (j<count) && (best==-1); j++)

+        for (j=0, best=-1; (j<256) && (j<count) && (best==-1); j++)

             if (blkdev1[j].rdev!=0)

                 best=j;

         // find the index of the best item in the old array

diff --git a/fsarchiver/src/oper_save.c b/fsarchiver/src/oper_save.c

index dfa0c6d..973fc6a 100644

--- a/fsarchiver/src/oper_save.c

+++ b/fsarchiver/src/oper_save.c

@@ -279,7 +279,7 @@ int createar_item_xattr(csavear *save, char *root, char *relpath, struct stat64

         len=strlen(buffer+pos)+1;

         attrsize=lgetxattr(fullpath, buffer+pos, NULL, 0);

         msgprintf(MSG_VERB2, "            xattr:file=[%s], attrid=%d, name=[%s], size=%ld\n", relpath, (int)attrcnt, buffer+pos, (long)attrsize);

-        if ((attrsize>0) && (attrsize>65535LL))

+        if (attrsize>65535LL)

         {   errprintf("file [%s] has an xattr [%s] with data too big (size=%ld, maxsize=64k)\n", relpath, buffer+pos, (long)attrsize);

             ret=-1;

             continue; // copy the next xattr

diff --git a/fsarchiver/src/strdico.c b/fsarchiver/src/strdico.c

index d5e38eb..bf0ff59 100644

--- a/fsarchiver/src/strdico.c

+++ b/fsarchiver/src/strdico.c

@@ -117,7 +117,7 @@ int strdico_parse_string(cstrdico *d, const char *strdefs)

         memset(key, 0, sizeof(key));

         memset(value, 0, sizeof(value));

-        for (i=0; (result[i]!=0) && (result[i]!='=') && (i<sizeof(key)-1); i++)

+        for (i=0; (i<sizeof(key)-1) && (result[i]!=0) && (result[i]!='='); i++)

         {

             key[i]=result[i];

         }

diff --git a/fsarchiver/src/thread_comp.c b/fsarchiver/src/thread_comp.c

index 8827d0f..c6ad4f1 100644

--- a/fsarchiver/src/thread_comp.c

+++ b/fsarchiver/src/thread_comp.c

@@ -146,14 +146,15 @@ int compress_block_generic(struct s_blockinfo *blkinfo)

     return 0;

 }

+char *dbufcomp=NULL;

+

 int decompress_block_generic(struct s_blockinfo *blkinfo)

 {

     u64 checkorigsize;

-    char *bufcomp=NULL;

     int res;

     // allocate memory for uncompressed data

-    if ((bufcomp=malloc(blkinfo->blkrealsize))==NULL)

+    if ((dbufcomp=malloc(blkinfo->blkrealsize))==NULL)

     {   errprintf("malloc(%ld) failed: cannot allocate memory for compressed block\n", (long)blkinfo->blkrealsize);

         return -1;

     }

@@ -161,14 +162,14 @@ int decompress_block_generic(struct s_blockinfo *blkinfo)

     // check the block checksum

     if (fletcher32((u8*)blkinfo->blkdata, blkinfo->blkarsize)!=(blkinfo->blkarcsum))

     {   errprintf("block is corrupt at blockoffset=%ld, blksize=%ld\n", (long)blkinfo->blkoffset, (long)blkinfo->blkrealsize);

-        memset(bufcomp, 0, blkinfo->blkrealsize);

+        memset(dbufcomp, 0, blkinfo->blkrealsize);

     }

     else // data not corrupted, decompresses the block

     {

         if ((blkinfo->blkcryptalgo!=ENCRYPT_NONE) && (g_options.encryptalgo!=ENCRYPT_BLOWFISH))

         {   msgprintf(MSG_DEBUG1, "this archive has been encrypted, you have to provide a password "

                 "on the command line using option '-c'\n");

-            free (bufcomp);

+            free (dbufcomp);

             return -1;

         }

@@ -178,19 +179,19 @@ int decompress_block_generic(struct s_blockinfo *blkinfo)

         {

             if ((bufcrypt=malloc(blkinfo->blkrealsize+8))==NULL)

             {   errprintf("malloc(%ld) failed: out of memory\n", (long)blkinfo->blkrealsize+8);

-                free(bufcomp);

+                free(dbufcomp);

                 return -1;

             }

             if ((res=crypto_blowfish(blkinfo->blkarsize, &clearsize, (u8*)blkinfo->blkdata, (u8*)bufcrypt, 

                 g_options.encryptpass, strlen((char*)g_options.encryptpass), 0))!=0)

             {   errprintf("crypt_block_blowfish() failed\n");

-                free(bufcomp);

+                free(dbufcomp);

                 return -1;

             }

             if (clearsize!=blkinfo->blkcompsize)

             {   errprintf("clearsize does not match blkcompsize: clearsize=%ld and blkcompsize=%ld\n", 

                     (long)clearsize, (long)blkinfo->blkcompsize);

-                free(bufcomp);

+                free(dbufcomp);

                 return -1;

             }

             free(blkinfo->blkdata);

@@ -200,41 +201,41 @@ int decompress_block_generic(struct s_blockinfo *blkinfo)

         switch (blkinfo->blkcompalgo)

         {

             case COMPRESS_NONE:

-                memcpy(bufcomp, blkinfo->blkdata, blkinfo->blkarsize);

+                memcpy(dbufcomp, blkinfo->blkdata, blkinfo->blkarsize);

                 res=0;

                 break;

 #ifdef OPTION_LZO_SUPPORT

             case COMPRESS_LZO:

-                if ((res=uncompress_block_lzo(blkinfo->blkcompsize, &checkorigsize, (void*)bufcomp, blkinfo->blkrealsize, (u8*)blkinfo->blkdata))!=0)

+                if ((res=uncompress_block_lzo(blkinfo->blkcompsize, &checkorigsize, (void*)dbufcomp, blkinfo->blkrealsize, (u8*)blkinfo->blkdata))!=0)

                 {   errprintf("uncompress_block_lzo()=%d failed: finalsize=%ld and checkorigsize=%ld\n", 

                         res, (long)blkinfo->blkarsize, (long)checkorigsize);

-                    memset(bufcomp, 0, blkinfo->blkrealsize);

+                    memset(dbufcomp, 0, blkinfo->blkrealsize);

                     // TODO: inc(error_counter);

                 }

                 break;

 #endif // OPTION_LZO_SUPPORT

             case COMPRESS_GZIP:

-                if ((res=uncompress_block_gzip(blkinfo->blkcompsize, &checkorigsize, (void*)bufcomp, blkinfo->blkrealsize, (u8*)blkinfo->blkdata))!=0)

+                if ((res=uncompress_block_gzip(blkinfo->blkcompsize, &checkorigsize, (void*)dbufcomp, blkinfo->blkrealsize, (u8*)blkinfo->blkdata))!=0)

                 {   errprintf("uncompress_block_gzip()=%d failed: finalsize=%ld and checkorigsize=%ld\n", 

                         res, (long)blkinfo->blkarsize, (long)checkorigsize);

-                    memset(bufcomp, 0, blkinfo->blkrealsize);

+                    memset(dbufcomp, 0, blkinfo->blkrealsize);

                     // TODO: inc(error_counter);

                 }

                 break;

             case COMPRESS_BZIP2:

-                if ((res=uncompress_block_bzip2(blkinfo->blkcompsize, &checkorigsize, (void*)bufcomp, blkinfo->blkrealsize, (u8*)blkinfo->blkdata))!=0)

+                if ((res=uncompress_block_bzip2(blkinfo->blkcompsize, &checkorigsize, (void*)dbufcomp, blkinfo->blkrealsize, (u8*)blkinfo->blkdata))!=0)

                 {   errprintf("uncompress_block_bzip2()=%d failed: finalsize=%ld and checkorigsize=%ld\n", 

                         res, (long)blkinfo->blkarsize, (long)checkorigsize);

-                    memset(bufcomp, 0, blkinfo->blkrealsize);

+                    memset(dbufcomp, 0, blkinfo->blkrealsize);

                     // TODO: inc(error_counter);

                 }

                 break;

 #ifdef OPTION_LZMA_SUPPORT

             case COMPRESS_LZMA:

-                if ((res=uncompress_block_lzma(blkinfo->blkcompsize, &checkorigsize, (void*)bufcomp, blkinfo->blkrealsize, (u8*)blkinfo->blkdata))!=0)

+                if ((res=uncompress_block_lzma(blkinfo->blkcompsize, &checkorigsize, (void*)dbufcomp, blkinfo->blkrealsize, (u8*)blkinfo->blkdata))!=0)

                 {   errprintf("uncompress_block_lzma()=%d failed: finalsize=%ld and checkorigsize=%ld\n", 

                         res, (long)blkinfo->blkarsize, (long)checkorigsize);

-                    memset(bufcomp, 0, blkinfo->blkrealsize);

+                    memset(dbufcomp, 0, blkinfo->blkrealsize);

                     // TODO: inc(error_counter);

                 }

                 break;

@@ -243,10 +244,10 @@ int decompress_block_generic(struct s_blockinfo *blkinfo)

                 errprintf("unsupported compression algorithm: %ld\n", (long)blkinfo->blkcompalgo);

                 return -1;

         }

-        free(blkinfo->blkdata); // free old buffer (with compressed data)

-        blkinfo->blkdata=bufcomp; // pointer to new buffer with uncompressed data

+        free(dbufcomp); // free old buffer (with compressed data)

+        blkinfo->blkdata=dbufcomp; // pointer to new buffer with uncompressed data

     }

-    return 0;

+   return 0;

 }

 int compression_function(int oper)