clamav 0.2.2

data/ChangeLog

@@ -0,0 +1,8 @@
+ChangeLog
+
+Sar Sep 06 15:43:00 MSK 2008
+----------------------------
+  V 0.2.2
+  * Update to ClamAV-0.94
+  * Add ChangeLog
+  

data/README

@@ -0,0 +1,35 @@
+ClamAV Ruby binding gem. Based on project clamavr-0.2.0
+http://raa.ruby-lang.org/project/clamavr/
+Thanks to MoonWoolf <moonwolf@moonwolf.com>
+
+== INSTALL
+
+$ sudo gem install clamav
+or
+$ rake package && cd pkg && sudo gem install *.gem
+
+== REQUIREMENTS
+
+clamav >= 0.94
+libclamav5, libclamav-dev
+
+== USAGE
+ClamAV.new()
+  return:
+    ClamAV instance
+
+ClamAV#scanfile(filename, options)
+  filename => filename
+  options => CL_SCAN_STDOPT
+    
+  return:
+    virusname or ClamAV returncode(Fixnum)
+
+== LICENSE
+GPL
+
+= Clamav as gem
+Copyright(c) 2008 Alexander Oryol <eagle.alex@gmail.com>
+
+= ClamAV/R
+Copyright(c) 2003-2007 MoonWolf <moonwolf@moonwolf.com>

data/ext/clamav/clamav.c

@@ -0,0 +1,146 @@
+#include <clamav.h>
+#include <ruby.h>
+
+static VALUE cClamAV;
+
+struct ClamAV_R {
+    struct cl_engine *root;
+    struct cl_limits limits;
+    unsigned int signo;
+};
+
+static void clamavr_free(struct ClamAV_R *ptr) {
+    cl_free(ptr->root);
+    xfree(ptr);
+}
+
+static VALUE clamavr_s_allocate(VALUE klass) {
+    struct ClamAV_R *ptr = ALLOC(struct ClamAV_R);
+    int ret;
+
+    ptr->root = NULL;
+    ptr->signo = 0;
+    ret = cl_load(cl_retdbdir(), &ptr->root, &ptr->signo, CL_DB_STDOPT);
+    if(ret) {
+        rb_raise(rb_eRuntimeError, "cl_loaddbdir() error: %s\n", cl_strerror(ret));
+    }
+    cl_build(ptr->root);
+    
+    ptr->limits.maxscansize = 10 * 1024 * 1024;
+    ptr->limits.maxfilesize = 10 * 1024 * 1024;
+    ptr->limits.maxreclevel = 100;
+    ptr->limits.maxfiles    = 1024;
+    ptr->limits.archivememlim = 1;
+
+    return Data_Wrap_Struct(klass, 0, clamavr_free, ptr);
+}
+
+static VALUE clamavr_initialize(VALUE self) {
+    return self;
+}
+
+static VALUE clamavr_signo(VALUE self) {
+    struct ClamAV_R *ptr;
+    Data_Get_Struct(self, struct ClamAV_R, ptr);
+    return UINT2NUM(ptr->signo);
+}
+
+static VALUE clamavr_scanfile(VALUE self, VALUE v_fname, VALUE v_options) {
+    int ret;
+    const char *virname;
+    struct ClamAV_R *ptr;
+
+    Check_Type(v_fname, T_STRING);
+    Check_Type(v_options, T_FIXNUM);
+
+    Data_Get_Struct(self, struct ClamAV_R, ptr);
+
+    ret = cl_scanfile(RSTRING(v_fname)->ptr, &virname, NULL, ptr->root, &ptr->limits, FIX2INT(v_options));
+    if (ret == CL_VIRUS) {
+        return rb_str_new2(virname);
+    } else {
+        return INT2FIX(ret);
+    }
+}
+
+void Init_clamav() {
+    cClamAV =  rb_define_class("ClamAV", rb_cObject);
+    rb_define_alloc_func(cClamAV, clamavr_s_allocate);
+    rb_define_method(cClamAV, "initialize", clamavr_initialize, 0);
+
+    rb_define_method(cClamAV, "scanfile", clamavr_scanfile, 2);
+    rb_define_method(cClamAV, "signo", clamavr_signo, 0);
+
+    /* return codes */
+    rb_define_const(cClamAV, "CL_CLEAN", INT2FIX(CL_CLEAN));         /*  no virus found  */
+    rb_define_const(cClamAV, "CL_VIRUS", INT2FIX(CL_VIRUS));         /*  virus(es) found  */
+    rb_define_const(cClamAV, "CL_SUCCESS", INT2FIX(CL_SUCCESS));
+    rb_define_const(cClamAV, "CL_BREAK", INT2FIX(CL_BREAK));
+
+    rb_define_const(cClamAV, "CL_EMAXREC", INT2FIX(CL_EMAXREC));     /*  (internal) recursion limit exceeded  */
+    rb_define_const(cClamAV, "CL_EMAXSIZE", INT2FIX(CL_EMAXSIZE));   /*  (internal) size limit exceeded  */
+    rb_define_const(cClamAV, "CL_EMAXFILES", INT2FIX(CL_EMAXFILES)); /*  (internal) files limit exceeded  */
+    rb_define_const(cClamAV, "CL_ERAR", INT2FIX(CL_ERAR));           /*  rar handler error  */
+    rb_define_const(cClamAV, "CL_EZIP", INT2FIX(CL_EZIP));           /*  zip handler error  */
+    rb_define_const(cClamAV, "CL_EGZIP", INT2FIX(CL_EGZIP));         /*  gzip handler error  */
+    rb_define_const(cClamAV, "CL_EBZIP", INT2FIX(CL_EBZIP));         /*  bzip2 handler error  */
+    rb_define_const(cClamAV, "CL_EOLE2", INT2FIX(CL_EOLE2));         /*  OLE2 handler error  */
+    rb_define_const(cClamAV, "CL_EMSCOMP", INT2FIX(CL_EMSCOMP));     /*  MS Expand handler error  */
+    rb_define_const(cClamAV, "CL_EMSCAB", INT2FIX(CL_EMSCAB));       /*  MS CAB module error  */
+    rb_define_const(cClamAV, "CL_EACCES", INT2FIX(CL_EACCES));       /*  access denied  */
+    rb_define_const(cClamAV, "CL_ENULLARG", INT2FIX(CL_ENULLARG));   /*  null argument  */
+    rb_define_const(cClamAV, "CL_ETMPFILE", INT2FIX(CL_ETMPFILE));   /*  tmpfile() failed  */
+    rb_define_const(cClamAV, "CL_EMEM", INT2FIX(CL_EMEM));           /*  memory allocation error  */
+    rb_define_const(cClamAV, "CL_EOPEN", INT2FIX(CL_EOPEN));         /*  file open error  */
+    rb_define_const(cClamAV, "CL_EMALFDB", INT2FIX(CL_EMALFDB));     /*  malformed database  */
+    rb_define_const(cClamAV, "CL_EPATSHORT", INT2FIX(CL_EPATSHORT)); /*  pattern too short  */
+    rb_define_const(cClamAV, "CL_ETMPDIR", INT2FIX(CL_ETMPDIR));     /*  mkdir() failed  */
+    rb_define_const(cClamAV, "CL_ECVD", INT2FIX(CL_ECVD));           /*  not a CVD file (or broken)  */
+    rb_define_const(cClamAV, "CL_ECVDEXTR", INT2FIX(CL_ECVDEXTR));   /*  CVD extraction failure  */
+    rb_define_const(cClamAV, "CL_EMD5", INT2FIX(CL_EMD5));           /*  MD5 verification error  */
+    rb_define_const(cClamAV, "CL_EDSIG", INT2FIX(CL_EDSIG));         /*  digital signature verification error  */
+    rb_define_const(cClamAV, "CL_EIO", INT2FIX(CL_EIO));             /*  general I/O error  */
+    rb_define_const(cClamAV, "CL_EFORMAT", INT2FIX(CL_EFORMAT));     /*  (internal) bad format or broken file  */
+    rb_define_const(cClamAV, "CL_ESUPPORT", INT2FIX(CL_ESUPPORT));   /*  not supported data format  */
+    rb_define_const(cClamAV, "CL_EARJ", INT2FIX(CL_EARJ));           /*  ARJ handler error  */
+
+    /* db options */
+    rb_define_const(cClamAV, "CL_DB_PHISHING", INT2FIX(CL_DB_PHISHING));
+    rb_define_const(cClamAV, "CL_DB_ACONLY", INT2FIX(CL_DB_ACONLY)); /*  WARNING: only for developers  */
+    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_OFFICIAL", INT2FIX(CL_DB_OFFICIAL));
+    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));
+
+    /* recommended db settings */
+    rb_define_const(cClamAV, "CL_DB_STDOPT", INT2FIX(CL_DB_STDOPT));
+
+    /* scan options */
+    rb_define_const(cClamAV, "CL_SCAN_RAW", INT2FIX(CL_SCAN_RAW));
+    rb_define_const(cClamAV, "CL_SCAN_ARCHIVE", INT2FIX(CL_SCAN_ARCHIVE));
+    rb_define_const(cClamAV, "CL_SCAN_MAIL", INT2FIX(CL_SCAN_MAIL));
+    rb_define_const(cClamAV, "CL_SCAN_OLE2", INT2FIX(CL_SCAN_OLE2));
+    rb_define_const(cClamAV, "CL_SCAN_BLOCKENCRYPTED", INT2FIX(CL_SCAN_BLOCKENCRYPTED));
+    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_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 */
+    rb_define_const(cClamAV, "CL_SCAN_PHISHING_BLOCKCLOAK", INT2FIX(CL_SCAN_PHISHING_BLOCKCLOAK));
+    rb_define_const(cClamAV, "CL_SCAN_ELF", INT2FIX(CL_SCAN_ELF));
+    rb_define_const(cClamAV, "CL_SCAN_PDF", INT2FIX(CL_SCAN_PDF));
+    rb_define_const(cClamAV, "CL_SCAN_STRUCTURED", INT2FIX(CL_SCAN_STRUCTURED));
+    rb_define_const(cClamAV, "CL_SCAN_STRUCTURED_SSN_NORMAL", INT2FIX(CL_SCAN_STRUCTURED_SSN_NORMAL));
+    rb_define_const(cClamAV, "CL_SCAN_STRUCTURED_SSN_STRIPPED", INT2FIX(CL_SCAN_STRUCTURED_SSN_STRIPPED));
+    rb_define_const(cClamAV, "CL_SCAN_PARTIAL_MESSAGE", INT2FIX(CL_SCAN_PARTIAL_MESSAGE));
+    rb_define_const(cClamAV, "CL_SCAN_HEURISTIC_PRECEDENCE", INT2FIX(CL_SCAN_HEURISTIC_PRECEDENCE));
+
+    /* recommended scan settings */
+    rb_define_const(cClamAV, "CL_SCAN_STDOPT", INT2FIX(CL_SCAN_STDOPT));
+
+}

data/ext/clamav/extconf.rb

@@ -0,0 +1,9 @@
+#!/usr/local/bin/ruby -Ks
+
+require "mkmf"
+
+dir_config("clamav")
+
+if have_header("clamav.h") && have_library('clamav', 'cl_loaddbdir')
+  create_makefile("clamav")
+end

data/rakefile

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'tools/rakehelp'
+require 'spec/rake/spectask'
+
+GEM_VERSION="0.2.2"
+
+setup_extension('clamav', 'clamav')
+
+desc "Compile native extension"
+task :compile => [:clamav]
+
+task :default => [:compile, :spec]
+
+Spec::Rake::SpecTask.new do |task|
+  task.libs << 'spec'
+  task.spec_files = Dir.glob( 'spec/**/*_spec.rb' )
+  task.verbose = true
+end
+
+gemspec = Gem::Specification.new do |gemspec|
+  gemspec.name = "clamav"
+  gemspec.version = GEM_VERSION
+  gemspec.author = "Alexander Oryol"
+  gemspec.email =  "eagle.alex@gmail.com"
+  gemspec.summary = "ClamAV Ruby binding"
+  gemspec.description = <<-EOF
+    ClamAV Ruby binding. Based on project clamavr-0.2.0
+    http://raa.ruby-lang.org/project/clamavr/
+    Thanks to MoonWoolf <moonwolf@moonwolf.com>
+  EOF
+  gemspec.files = %w( rakefile README ChangeLog ) +
+                  Dir.glob( 'lib/*.rb' ) +
+                  Dir.glob( 'spec/*.rb' ) +
+                  Dir.glob( 'spec/unit/*.rb' ) +
+                  Dir.glob( 'ext/**/*.{c,rb}' ) +
+		  Dir.glob( 'tools/*.rb' )
+  gemspec.autorequire = 'clamav'
+  gemspec.require_path = 'lib'
+#  gemspec.add_dependency('builder')
+
+  if RUBY_PLATFORM.match("win32")
+    gemspec.platform = Gem::Platform::WIN32
+    gemspec.files += []
+  else
+    gemspec.platform = Gem::Platform::RUBY
+    gemspec.extensions = Dir.glob( 'ext/**/extconf.rb' )
+  end
+end
+
+task :package => [:clean, :compile, :spec]
+Rake::GemPackageTask.new( gemspec ) do |task|
+  task.gem_spec = gemspec
+  task.need_tar = true
+end
+
+setup_clean ["ext/clamav/*.{so,o}", "ext/clamav/Makefile", "lib/clamav.so", "pkg", "*.gem"]
+
+task :install => [:default, :package] do
+  sh %{ sudo gem install pkg/clamav-#{GEM_VERSION}.gem }
+end
+
+task :uninstall do
+  sh %{ sudo gem uninstall clamav }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'test/unit'
+require 'spec'
+require File.dirname(__FILE__) + '/../lib/clamav'

data/spec/unit/clamav_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class ClamAV
+
+  describe "class" do
+
+    before(:each) do                                                                                                   
+      @clam = ClamAV.new()
+    end
+
+    it "should be instance of Clamav" do
+      @clam.should be_instance_of(ClamAV)
+    end
+
+    FILES = {
+      'robots.txt' => CL_CLEAN,
+      'eicar.com'  => 'Eicar-Test-Signature', # EICAR
+      'test.txt'   => 'Eicar-Test-Signature', # EICAR in text/plain
+      'clam.cab'      => 'ClamAV-Test-File',
+      'clam.exe'      => 'ClamAV-Test-File',
+      'clam.exe.bz2'  => 'ClamAV-Test-File',
+      'clam.zip'      => 'ClamAV-Test-File',
+      'clam-v2.rar'   => 'ClamAV-Test-File',
+      'clam-v3.rar'   => 'ClamAV-Test-File',
+      'clam-p.rar'    => 'Encrypted.RAR',  # encripted RAR
+      # Bug in ClamAV https://wwws.clamav.net/bugzilla/show_bug.cgi?id=1134
+      # Fixed in 0.94
+      'clam-ph.rar'    => 'Encrypted.RAR', # encripted RAR with encrypted both file data and headers
+      'program.doc'   => 'W97M.Class.EB',
+      'Программа.doc' => 'W97M.Class.EB', # filename in UTF-8
+    }
+
+    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), 
+          CL_SCAN_STDOPT | CL_SCAN_BLOCKENCRYPTED).should == result
+      end
+    end
+
+  end
+end

data/tools/rakehelp.rb

@@ -0,0 +1,117 @@
+def make(makedir)
+  Dir.chdir(makedir) do
+    sh(PLATFORM =~ /win32/ ? 'nmake' : 'make')
+  end
+end
+
+
+def extconf(dir)
+  Dir.chdir(dir) do ruby "extconf.rb" end
+end
+
+
+def setup_tests
+  Rake::TestTask.new do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/test*.rb']
+    t.verbose = true
+  end
+end
+
+
+def setup_clean otherfiles
+  files = ['build/*', '**/*.o', '**/*.so', '**/*.a', 'lib/*-*', '**/*.log'] + otherfiles
+  CLEAN.include(files)
+end
+
+
+def setup_rdoc files
+  Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_dir = 'doc/rdoc'
+    rdoc.options << '--line-numbers'
+    rdoc.rdoc_files.add(files)
+  end
+end
+
+
+def setup_extension(dir, extension)
+  ext = "ext/#{dir}"
+  ext_so = "#{ext}/#{extension}.#{Config::CONFIG['DLEXT']}"
+  ext_files = FileList[
+    "#{ext}/*.cpp",
+    "#{ext}/*.h",
+    "#{ext}/extconf.rb",
+    "#{ext}/Makefile",
+    "lib"
+  ] 
+
+  task "lib" do
+    directory "lib"
+  end
+
+  desc "Builds just the #{extension} extension"
+  task extension.to_sym => ["#{ext}/Makefile", ext_so ]
+
+  file "#{ext}/Makefile" => ["#{ext}/extconf.rb"] do
+    extconf "#{ext}"
+  end
+
+  file ext_so => ext_files do
+    make "#{ext}"
+    cp ext_so, "lib"
+  end
+end
+
+
+def base_gem_spec(pkg_name, pkg_version)
+  rm_rf "test/coverage"
+  pkg_version = pkg_version
+  pkg_name    = pkg_name
+  pkg_file_name = "#{pkg_name}-#{pkg_version}"
+  Gem::Specification.new do |s|
+    s.name = pkg_name
+    s.version = pkg_version
+    s.platform = Gem::Platform::RUBY
+    s.has_rdoc = true
+    s.extra_rdoc_files = [ "README" ]
+
+    s.files = %w(COPYING LICENSE README Rakefile) +
+      Dir.glob("{bin,doc/rdoc,test}/**/*") + 
+      Dir.glob("ext/**/*.{h,cpp,rb,rl}") +
+      Dir.glob("{examples,tools,lib}/**/*.rb")
+
+    s.require_path = "lib"
+    s.extensions = FileList["ext/**/extconf.rb"].to_a
+    s.bindir = "bin"
+  end
+end
+
+def setup_gem(pkg_name, pkg_version)
+  spec = base_gem_spec(pkg_name, pkg_version)
+  yield spec if block_given?
+
+  Rake::GemPackageTask.new(spec) do |p|
+    p.gem_spec = spec
+    p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+  end
+end
+
+def sub_project(project, *targets)
+  targets.each do |target|
+    Dir.chdir "projects/#{project}" do
+      sh %{rake --trace #{target.to_s} }
+    end
+  end
+end
+
+# Conditional require rcov/rcovtask if present
+begin
+  require 'rcov/rcovtask'
+  
+  Rcov::RcovTask.new do |t|
+    t.test_files = FileList['test/test*.rb']
+    t.rcov_opts << "-x /usr"
+    t.output_dir = "test/coverage"
+  end
+rescue Object
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+name: clamav
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+platform: ruby
+authors: 
+- Alexander Oryol
+autorequire: clamav
+bindir: bin
+cert_chain: []
+
+date: 2008-09-08 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: ClamAV Ruby binding. Based on project clamavr-0.2.0 http://raa.ruby-lang.org/project/clamavr/ Thanks to MoonWoolf <moonwolf@moonwolf.com>
+email: eagle.alex@gmail.com
+executables: []
+
+extensions: 
+- ext/clamav/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- rakefile
+- README
+- ChangeLog
+- spec/spec_helper.rb
+- spec/unit/clamav_spec.rb
+- ext/clamav/clamav.c
+- ext/clamav/extconf.rb
+- tools/rakehelp.rb
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ClamAV Ruby binding
+test_files: []
+