clamav 0.3.2 → 0.4.0

data/ChangeLog

@@ -1,6 +1,15 @@
 ChangeLog
 
-Thu Feb 25 20:1:00 MSK 2010
+Fri Apr 23 19:31:00 MSK 2010
+----------------------------
+  V 0.4.0
+  * Clamav-0.96 compatible now
+  * Changes: ClamAV is a singleton (Use ClamAV.instance instead ClamAV.new)
+    You should call ClamAV#loaddb([options]) after first call ClamAV.instance
+  + ClamAV#version get Clamav engine version string
+  + ClamaAV#countsigs get loaded signatures count with options
+
+Thu Feb 25 20:01:00 MSK 2010
 ----------------------------
   V 0.3.2
   * Fix to compile on ruby-1.9

data/README.rdoc

@@ -9,32 +9,24 @@ $ sudo gem install clamav
 == REQUIREMENTS:
 
 clamav >= 0.95.3, libclamav6, libclamav-dev
+clamav >= 0.96 is recommended
 
 == SYNOPSIS:
 
-== ClamAV.new([options[, db_options]])
+  *Changes*: Now ClamAV is a singleton. Use ClamAV.instance instead ClamAV.new.
+  You should call ClamAV#loaddb([options]) after first call ClamAV.instance.
+  Next run ClamAV#loaddb with another options will recreate/recompile clamav engine/database.
+
+== ClamAV.instance
 
   return:
     ClamAV instance
 
-Options:
-
-* CL_SCAN_STDOPT (default) equal CL_SCAN_ARCHIVE | CL_SCAN_MAIL | CL_SCAN_OLE2 | CL_SCAN_PDF | CL_SCAN_HTML | CL_SCAN_PE | CL_SCAN_ALGORITHMIC | CL_SCAN_ELF
-* CL_SCAN_RAW
-* CL_SCAN_BLOCKENCRYPTED
-* CL_SCAN_BLOCKBROKEN
-* CL_SCAN_MAILURL
-* CL_SCAN_PHISHING_BLOCKSSL
-* CL_SCAN_PHISHING_BLOCKCLOAK
-* CL_SCAN_STRUCTURED
-* CL_SCAN_STRUCTURED_SSN_NORMAL
-* CL_SCAN_STRUCTURED_SSN_STRIPPED
-* CL_SCAN_PARTIAL_MESSAGE
-* CL_SCAN_HEURISTIC_PRECEDENCE
+== ClamAV#loaddb([db_options])
 
 DB options:
 
-* CL_DB_STDOPT (default) equal CL_DB_PHISHING | CL_DB_PHISHING_URLS
+* CL_DB_STDOPT (default) equal CL_DB_PHISHING | CL_DB_PHISHING_URLS | CL_DB_BYTECODE
 * CL_DB_PUA
 * CL_DB_CVDNOTMP
 * CL_DB_PUA_MODE
@@ -44,24 +36,35 @@ DB options:
 See ClamAV documentation and sources for details.
 
 
-
 == ClamAV#scanfile(filename[, options])
   options default CL_SCAN_STDOPT
-    
+
+Options:
+
+* CL_SCAN_STDOPT (default) equal CL_SCAN_ARCHIVE | CL_SCAN_MAIL | CL_SCAN_OLE2 | CL_SCAN_PDF | CL_SCAN_HTML | CL_SCAN_PE | CL_SCAN_ALGORITHMIC | CL_SCAN_ELF
+* CL_SCAN_RAW
+* CL_SCAN_BLOCKENCRYPTED
+* CL_SCAN_BLOCKBROKEN
+* CL_SCAN_PHISHING_BLOCKSSL
+* CL_SCAN_PHISHING_BLOCKCLOAK
+* CL_SCAN_STRUCTURED
+* CL_SCAN_STRUCTURED_SSN_NORMAL
+* CL_SCAN_STRUCTURED_SSN_STRIPPED
+* CL_SCAN_PARTIAL_MESSAGE
+* CL_SCAN_HEURISTIC_PRECEDENCE
+
   return:
     virusname or ClamAV returncode(Fixnum)
 
 
-
 == ClamAV#reload()
-  reload virus db if changed
+  reload virus database if changed
 
   return:
     1 - reload successful
     0 - reload unnecessary
 
 
-
 == ClamAV#setlimit(param, value)
 
 == ClamAV#getlimit(param)
@@ -96,6 +99,17 @@ See ClamAV documentation and sources for details.
 == ClamaAV#signo()
   get loaded signatures count
 
+== ClamaAV#countsigs([options])
+  get loaded signatures count (since 0.96 engine version)
+
+Options:
+* CL_COUNTSIGS_ALL (default)
+* CL_COUNTSIGS_OFFICIAL
+* CL_COUNTSIGS_UNOFFICIAL
+
+
+== ClamaAV#version()
+  get Clamav engine version string
 
 
 == LICENSE:

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.4.0

data/clamav.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{clamav}
-  s.version = "0.3.2"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alexander Oryol"]
-  s.date = %q{2010-02-25}
+  s.date = %q{2010-04-23}
   s.description = %q{ClamAV Ruby bindings}
   s.email = %q{eagle.alex@gmail.com}
   s.extensions = ["ext/clamav/extconf.rb"]
@@ -52,7 +52,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{clamav}
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{ClamAV Ruby bindings}
   s.test_files = [
     "spec/unit/clamav_spec.rb",

data/ext/clamav/clamav.c

@@ -20,21 +20,14 @@ static void clamavr_free(struct ClamAV_R *ptr) {
     xfree(ptr);
 }
 
-static VALUE clamavr_new(argc, argv, klass)
-    int argc;
-    VALUE *argv;
-    VALUE klass;
-{
-    const char *v_fname;
+static VALUE clamavr_initialize(VALUE self) {
+    return self;
+}
+
+static VALUE clamavr_new(VALUE klass) {
+
     VALUE v_options;
-    VALUE v_db_options;
-    rb_scan_args(argc, argv, "02", &v_options, &v_db_options);
-    if(NIL_P(v_options)){
-      v_options = INT2FIX(CL_SCAN_STDOPT); /* default value */
-    }
-    if(NIL_P(v_db_options)){
-      v_db_options = INT2FIX(CL_DB_STDOPT); /* default value */
-    }
+    v_options = INT2FIX(CL_SCAN_STDOPT); /* default value */
 
     int ret;
     ret = cl_init(FIX2INT(v_options));
@@ -42,21 +35,30 @@ static VALUE clamavr_new(argc, argv, klass)
         rb_raise(rb_eRuntimeError, "cl_init() error: %s\n", cl_strerror(ret));
     }
     struct ClamAV_R *ptr = ALLOC(struct ClamAV_R);
-    ptr->root = cl_engine_new();
-    if(ptr->root == NULL) {
-        rb_raise(rb_eRuntimeError, "cl_engine_new() error: %s\n", cl_strerror(ret));
-    };
 
     /* save options */
     ptr->options = v_options;
-    ptr->db_options = v_db_options;
+
+    ptr->root = NULL;
+
+    return Data_Wrap_Struct(klass, 0, clamavr_free, ptr);
+}
+
+static void clamavr_build(VALUE db_options, struct ClamAV_R *ptr) {
+
+    ptr->root = cl_engine_new();
+
+    /* save options */
+    ptr->db_options = db_options;
 
     ptr->signo = 0;
 
     const char *dbdir;
     dbdir = cl_retdbdir();
 
-    ret = cl_load(dbdir, ptr->root, &ptr->signo, FIX2INT(v_db_options));
+    int ret;
+
+    ret = cl_load(dbdir, ptr->root, &ptr->signo, FIX2INT(db_options));
     if(ret != CL_SUCCESS) {
         rb_raise(rb_eRuntimeError, "cl_load() error: %s\n", cl_strerror(ret));
     }
@@ -67,12 +69,47 @@ static VALUE clamavr_new(argc, argv, klass)
     ret = cl_engine_compile(ptr->root);
     if(ret != CL_SUCCESS) {
         rb_raise(rb_eRuntimeError, "cl_engine_compile() error: %s\n", cl_strerror(ret));
+        cl_engine_free(ptr->root);
     }
-    return Data_Wrap_Struct(klass, 0, clamavr_free, ptr);
 }
 
-static VALUE clamavr_initialize(VALUE self) {
-    return self;
+static VALUE clamavr_loaddb(int argc, VALUE *argv, VALUE self) {
+    struct ClamAV_R *ptr;
+    Data_Get_Struct(self, struct ClamAV_R, ptr);
+
+    VALUE v_db_options;
+    rb_scan_args(argc, argv, "01", &v_db_options);
+
+    if(NIL_P(v_db_options)){
+      v_db_options = INT2FIX(CL_DB_STDOPT); /* default value */
+    }
+
+    if(ptr->root != NULL) {
+        cl_engine_free(ptr->root);
+    }
+
+    clamavr_build(v_db_options, ptr);
+    return CL_SUCCESS;
+}
+
+static VALUE clamavr_reload(VALUE self) {
+    struct ClamAV_R *ptr;
+    Data_Get_Struct(self, struct ClamAV_R, ptr);
+
+    int state;
+    state = cl_statchkdir(&ptr->dbstat);
+    if(state == 1) {
+        const char *dbdir;
+        dbdir = cl_retdbdir();
+        int ret;
+        ret = cl_load(dbdir, ptr->root, &ptr->signo, FIX2INT(ptr->db_options));
+        if(ret != CL_SUCCESS) {
+            rb_raise(rb_eRuntimeError, "cl_load() error: %s\n", cl_strerror(ret));
+        }
+        cl_statfree(&ptr->dbstat);
+        cl_statinidir(dbdir, &ptr->dbstat);
+    }
+    return INT2FIX(state);
 }
 
 static VALUE clamavr_setlimit(VALUE self, VALUE v_limit, VALUE v_value) {
@@ -142,19 +179,37 @@ static VALUE clamavr_signo(VALUE self) {
     return UINT2NUM(ptr->signo);
 }
 
-static VALUE clamavr_scanfile(argc, argv, klass)
-    int argc;
-    VALUE *argv;
-    VALUE klass;
-{
+#ifdef CL_COUNTSIGS_OFFICIAL
+static VALUE clamavr_countsigs(int argc, VALUE *argv, VALUE self) {
+    VALUE v_options;
+    rb_scan_args(argc, argv, "01", &v_options);
+    if(NIL_P(v_options)){
+      v_options = CL_COUNTSIGS_ALL; /* all signatures count */
+    }
+
+    const char *dbdir;
+    dbdir = cl_retdbdir();
+
+    int ret;
+    int signo = 0;
+    ret = cl_countsigs(dbdir, FIX2INT(v_options), &signo);
+    if(ret != CL_SUCCESS) {
+        rb_raise(rb_eRuntimeError, "cl_countsigs() error: %s\n", cl_strerror(ret));
+    }
+    return INT2NUM(signo);
+}
+#endif
+
+static VALUE clamavr_scanfile(int argc, VALUE *argv, VALUE klass) {
     struct ClamAV_R *ptr;
     Data_Get_Struct(klass, struct ClamAV_R, ptr);
 
     const char *v_fname;
     VALUE v_options;
     rb_scan_args(argc, argv, "11", &v_fname, &v_options);
+
     if(NIL_P(v_options)){
-      v_options = ptr->options; /* stored value */
+        v_options = ptr->options; /* stored value */
     }
 
     Check_Type(v_fname, T_STRING);
@@ -171,37 +226,32 @@ static VALUE clamavr_scanfile(argc, argv, klass)
     }
 }
 
-static VALUE clamavr_dbreload(VALUE self) {
-    struct ClamAV_R *ptr;
-    Data_Get_Struct(self, struct ClamAV_R, ptr);
-
-    int state;
-    state = cl_statchkdir(&ptr->dbstat);
-    if(state == 1) {
-        const char *dbdir;
-        dbdir = cl_retdbdir();
-        int ret;
-        ret = cl_load(dbdir, ptr->root, &ptr->signo, FIX2INT(ptr->db_options));
-        if(ret != CL_SUCCESS) {
-            rb_raise(rb_eRuntimeError, "cl_load() error: %s\n", cl_strerror(ret));
-        }
-        cl_statfree(&ptr->dbstat);
-        cl_statinidir(dbdir, &ptr->dbstat);
-    }
-    return INT2FIX(state);
+static VALUE clamavr_retver(VALUE self) {
+    const char *res;
+    res = cl_retver();
+    return rb_str_new2(res);
 }
 
 void Init_clamav() {
     cClamAV =  rb_define_class("ClamAV", rb_cObject);
-    rb_define_singleton_method(cClamAV, "new", clamavr_new, -1);
+
+    rb_require("singleton");
+    rb_include_module(cClamAV, rb_const_get(rb_cObject, rb_intern("Singleton")));
+    rb_funcall(rb_const_get(rb_cObject, rb_intern("Singleton")), rb_intern("included"), 1, cClamAV);
+
     rb_define_method(cClamAV, "initialize", clamavr_initialize, 0);
+    rb_define_singleton_method(cClamAV, "new", clamavr_new, 0);
+    rb_define_method(cClamAV, "loaddb", clamavr_loaddb, -1);
+    rb_define_method(cClamAV, "reload", clamavr_reload, 0);
     rb_define_method(cClamAV, "scanfile", clamavr_scanfile, -1);
     rb_define_method(cClamAV, "signo", clamavr_signo, 0);
+#ifdef CL_COUNTSIGS_OFFICIAL
+    rb_define_method(cClamAV, "countsigs", clamavr_countsigs, -1);
+#endif
     rb_define_method(cClamAV, "setlimit", clamavr_setlimit, 2);
     rb_define_method(cClamAV, "getlimit", clamavr_getlimit, 1);
     rb_define_method(cClamAV, "setstring", clamavr_setstring, 2);
     rb_define_method(cClamAV, "getstring", clamavr_getstring, 1);
-    rb_define_method(cClamAV, "reload", clamavr_dbreload, 0);
-
+    rb_define_method(cClamAV, "version", clamavr_retver, 0);
 #include <const.h>
 }

data/ext/clamav/const.h

@@ -33,18 +33,26 @@
     rb_define_const(cClamAV, "CL_EMAXSIZE", INT2FIX(CL_EMAXSIZE));
     rb_define_const(cClamAV, "CL_EMAXFILES", INT2FIX(CL_EMAXFILES));
     rb_define_const(cClamAV, "CL_EFORMAT", INT2FIX(CL_EFORMAT));
+#ifdef CL_EBYTECODE
+    rb_define_const(cClamAV, "CL_EBYTECODE", INT2FIX(CL_EBYTECODE));
+#endif
 
     /* db options */
     rb_define_const(cClamAV, "CL_DB_PHISHING", INT2FIX(CL_DB_PHISHING));
     rb_define_const(cClamAV, "CL_DB_PHISHING_URLS", INT2FIX(CL_DB_PHISHING_URLS));
     rb_define_const(cClamAV, "CL_DB_PUA", INT2FIX(CL_DB_PUA));
-    rb_define_const(cClamAV, "CL_DB_CVDNOTMP", INT2FIX(CL_DB_CVDNOTMP));
+    rb_define_const(cClamAV, "CL_DB_CVDNOTMP", INT2FIX(CL_DB_CVDNOTMP)); /*  obsolete  */
     rb_define_const(cClamAV, "CL_DB_OFFICIAL", INT2FIX(CL_DB_OFFICIAL)); /*  internal  */
     rb_define_const(cClamAV, "CL_DB_PUA_MODE", INT2FIX(CL_DB_PUA_MODE));
     rb_define_const(cClamAV, "CL_DB_PUA_INCLUDE", INT2FIX(CL_DB_PUA_INCLUDE));
     rb_define_const(cClamAV, "CL_DB_PUA_EXCLUDE", INT2FIX(CL_DB_PUA_EXCLUDE));
     rb_define_const(cClamAV, "CL_DB_COMPILED", INT2FIX(CL_DB_COMPILED)); /*  internal  */
     rb_define_const(cClamAV, "CL_DB_DIRECTORY", INT2FIX(CL_DB_DIRECTORY)); /*  internal  */
+#ifdef CL_DB_BYTECODE
+    rb_define_const(cClamAV, "CL_DB_OFFICIAL_ONLY", INT2FIX(CL_DB_OFFICIAL_ONLY));
+    rb_define_const(cClamAV, "CL_DB_BYTECODE", INT2FIX(CL_DB_BYTECODE));
+    rb_define_const(cClamAV, "CL_DB_SIGNED", INT2FIX(CL_DB_SIGNED)); /*  internal  */
+#endif
 
     /* recommended db settings */
     rb_define_const(cClamAV, "CL_DB_STDOPT", INT2FIX(CL_DB_STDOPT));
@@ -58,7 +66,7 @@
     rb_define_const(cClamAV, "CL_SCAN_HTML", INT2FIX(CL_SCAN_HTML));
     rb_define_const(cClamAV, "CL_SCAN_PE", INT2FIX(CL_SCAN_PE));
     rb_define_const(cClamAV, "CL_SCAN_BLOCKBROKEN", INT2FIX(CL_SCAN_BLOCKBROKEN));
-    rb_define_const(cClamAV, "CL_SCAN_MAILURL", INT2FIX(CL_SCAN_MAILURL));
+    rb_define_const(cClamAV, "CL_SCAN_MAILURL", INT2FIX(CL_SCAN_MAILURL)); /*  ignored  */
     rb_define_const(cClamAV, "CL_SCAN_BLOCKMAX", INT2FIX(CL_SCAN_BLOCKMAX)); /*  ignored  */
     rb_define_const(cClamAV, "CL_SCAN_ALGORITHMIC", INT2FIX(CL_SCAN_ALGORITHMIC));
     rb_define_const(cClamAV, "CL_SCAN_PHISHING_BLOCKSSL", INT2FIX(CL_SCAN_PHISHING_BLOCKSSL)); /*  ssl mismatches, not ssl by itself */
@@ -74,6 +82,13 @@
     /* recommended scan settings */
     rb_define_const(cClamAV, "CL_SCAN_STDOPT", INT2FIX(CL_SCAN_STDOPT));
 
+    /* cl_countsigs options */
+#ifdef CL_COUNTSIGS_OFFICIAL
+    rb_define_const(cClamAV, "CL_COUNTSIGS_OFFICIAL", INT2FIX(CL_COUNTSIGS_OFFICIAL));
+    rb_define_const(cClamAV, "CL_COUNTSIGS_UNOFFICIAL", INT2FIX(CL_COUNTSIGS_UNOFFICIAL));
+    rb_define_const(cClamAV, "CL_COUNTSIGS_ALL", INT2FIX(CL_COUNTSIGS_ALL));
+#endif
+
     rb_define_const(cClamAV, "CL_INIT_DEFAULT", INT2FIX(CL_INIT_DEFAULT));
 
     rb_define_const(cClamAV, "CL_ENGINE_MAX_SCANSIZE", INT2FIX(CL_ENGINE_MAX_SCANSIZE));        /*  uint64_t  */
@@ -91,4 +106,11 @@
     rb_define_const(cClamAV, "CL_ENGINE_AC_MAXDEPTH", INT2FIX(CL_ENGINE_AC_MAXDEPTH));          /*  uint32_t  */
     rb_define_const(cClamAV, "CL_ENGINE_TMPDIR", INT2FIX(CL_ENGINE_TMPDIR));                    /*  (char *)  */
     rb_define_const(cClamAV, "CL_ENGINE_KEEPTMP", INT2FIX(CL_ENGINE_KEEPTMP));                  /*  uint32_t  */
+#ifdef CL_DB_BYTECODE
+    rb_define_const(cClamAV, "CL_ENGINE_BYTECODE_SECURITY", INT2FIX(CL_ENGINE_BYTECODE_SECURITY)); /*  uint32_t  */
+    rb_define_const(cClamAV, "CL_ENGINE_BYTECODE_TIMEOUT", INT2FIX(CL_ENGINE_BYTECODE_TIMEOUT)); /*  uint32_t  */
 
+    rb_define_const(cClamAV, "CL_BYTECODE_TRUST_ALL", INT2FIX(CL_BYTECODE_TRUST_ALL));          /*  insecure, debug setting  */
+    rb_define_const(cClamAV, "CL_BYTECODE_TRUST_SIGNED", INT2FIX(CL_BYTECODE_TRUST_SIGNED));    /*  default  */
+    rb_define_const(cClamAV, "CL_BYTECODE_TRUST_NOTHING", INT2FIX(CL_BYTECODE_TRUST_NOTHING));  /*  paranoid setting  */
+#endif

data/spec/unit/clamav_spec.rb

@@ -4,6 +4,11 @@ class ClamAV
 
   describe "ClamAV" do
 
+    before(:all) do
+      @clam = ClamAV.instance
+      @clam.loaddb
+    end
+
     FILES = {
       'robots.txt' => CL_CLEAN,
       'eicar.com'  => 'Eicar-Test-Signature', # EICAR
@@ -22,34 +27,37 @@ class ClamAV
 
     FILES_ENCRYPTED = {
       'clam-p.rar'    => 'Encrypted.RAR',  # encripted RAR
-      'clam-ph.rar'    => 'Encrypted.RAR', # encripted RAR with encrypted both file data and headers
+      'clam-ph.rar'   => 'Encrypted.RAR', # encripted RAR with encrypted both file data and headers
+      'clam-v3.rar'   => 'ClamAV-Test-File'
     }
 
-    describe "with default options" do
-      before(:all) do
-        @clam = ClamAV.new
-      end
+    context "with default options" do
 
       it "should be instance of Clamav" do
         @clam.should be_instance_of(ClamAV)
       end
 
+      it "should return engine version" do
+        @clam.version.should >= '0.95'
+      end
 
       FILES.each do |file, result|
         it "should scan #{file} with result #{result.to_s}" do
-           @clam.scanfile(File.join(File.dirname(__FILE__), "../clamav-testfiles/", file)).should == result
+          @clam.scanfile(File.join(File.dirname(__FILE__), "../clamav-testfiles/", file)).should == result
         end
       end
 
-      FILES_ENCRYPTED.each do |file, result|
-        it "should scan encrypted #{file} with result #{result.to_s}" do
-          @clam.scanfile(File.join(File.dirname(__FILE__), "../clamav-testfiles/", file),
-            CL_SCAN_STDOPT | CL_SCAN_BLOCKENCRYPTED).should == result
-        end
+      it "should return signatures count" do
+        # strange, why not 757156? bug?
+        @clam.signo.should >= 756450 # on 17/04/10
       end
 
-      it "should return signatures count" do
-        @clam.signo.should >= 538736 # on 7/04/09
+      if ClamAV.instance.version >= '0.96'
+        it "should return all signatures count" do
+          (default = @clam.countsigs).should >= 757156 # on 17/04/10
+          (all = @clam.countsigs(CL_COUNTSIGS_ALL)).should >= 757156
+          default.should == all
+        end
       end
 
       it "should not reload db when fresh" do
@@ -58,15 +66,13 @@ class ClamAV
 
     end
 
-    describe "with custom options" do
+    context "scan with custom options" do
 
-      before(:all) do
-        @clam = ClamAV.new(CL_SCAN_STDOPT | CL_SCAN_BLOCKENCRYPTED)
-      end
-
-      it "should scan encrypted file with detect" do
-        @clam.scanfile(File.join(File.dirname(__FILE__), "../clamav-testfiles/",
-            'clam-v3.rar')).should == 'ClamAV-Test-File'
+      FILES_ENCRYPTED.each do |file, result|
+        it "should scan encrypted #{file} with result #{result.to_s}" do
+          @clam.scanfile(File.join(File.dirname(__FILE__), "../clamav-testfiles/", file),
+            CL_SCAN_STDOPT | CL_SCAN_BLOCKENCRYPTED).should match(/#{result}$/)
+        end
       end
 
       it "should scan OLE2 file with not detect" do
@@ -76,10 +82,14 @@ class ClamAV
 
     end
 
-    describe "with custom db options" do
+    context "with custom db options" do
 
       before(:all) do
-        @clam = ClamAV.new(CL_SCAN_STDOPT, CL_DB_STDOPT | CL_DB_PUA)
+        @clam.loaddb(CL_DB_STDOPT | CL_DB_PUA)
+      end
+
+      after(:all) do
+        @clam.loaddb
       end
 
       it "should detect PUA" do
@@ -89,10 +99,20 @@ class ClamAV
 
     end
 
+    context "limit CL_ENGINE_MAX_FILES" do
+
+      before(:all) do
+        # save default
+        @mem = @clam.getlimit(CL_ENGINE_MAX_FILES)
+      end
+
+      after(:each) do
+        # restore default
+        @clam.setlimit(CL_ENGINE_MAX_FILES, @mem)
+      end
 
-    describe "limits" do
-      before(:each) do
-        @clam = ClamAV.new
+      it "should get default limit" do
+        @clam.getlimit(CL_ENGINE_MAX_FILES).should == 10000
       end
 
       it "should set limit" do
@@ -105,9 +125,9 @@ class ClamAV
           should == CL_CLEAN
       end
 
-      it "should get limit" do
-        @clam.getlimit(CL_ENGINE_MAX_FILES).should == 10000
-      end
+    end
+
+    context "get/set" do
 
       it "should get db time" do
         Time.at(@clam.getlimit(CL_ENGINE_DB_TIME)).should >= Time.now - 60*60*24 # 1 day

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: clamav
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Alexander Oryol
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-25 00:00:00 +03:00
+date: 2010-04-23 00:00:00 +04:00
 default_executable: 
 dependencies: []
 
@@ -67,18 +72,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: clamav
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: ClamAV Ruby bindings