Update Changelog

Bump up version
fix typo (#394 )
2017-03-24 14:55:28 +09:00 · 2017-03-24 14:37:48 +09:00 · 2017-03-24 00:25:23 +09:00 · 2017-03-23 23:58:05 +09:00 · 2017-03-23 20:52:25 +09:00 · 2017-03-21 10:47:19 +09:00
55 changed files with 5446 additions and 1778 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,24 @@
+## What did you implement:
+
+Closes #XXXXX
+
+## How did you implement it:
+
+
+## How can we verify it:
+
+
+## Todos:
+You don't have to satisfy all of the following.
+
+- [ ] Write tests
+- [ ] Write documentation
+- [ ] Check that there aren't other open pull requests for the same issue/feature
+- [ ] Format your source code by `make fmt`
+- [ ] Pass the test by `make test`
+- [ ] Provide verification config / commands
+- [ ] Enable "Allow edits from maintainers" for this PR
+- [ ] Update the messages below
+
+***Is this ready for review?:*** NO  
+***Is it a breaking change?:*** NO
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,6 @@
+language: go
+
+go:
+  - 1.7
+  - 1.8
+
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,153 @@
 # Change Log

+## [v0.3.0](https://github.com/future-architect/vuls/tree/v0.3.0) (2017-03-24)
+[Full Changelog](https://github.com/future-architect/vuls/compare/v0.2.0...v0.3.0)
+
+**Implemented enhancements:**
+
+- Changelog parsing fails when package maintainers aren't consistent regarding versions [\#327](https://github.com/future-architect/vuls/issues/327)
+- Docker scan doesn't report image name [\#325](https://github.com/future-architect/vuls/issues/325)
+- vuls report -to-email only one E-Mail [\#295](https://github.com/future-architect/vuls/issues/295)
+- Support RHEL5 [\#286](https://github.com/future-architect/vuls/issues/286)
+- Continue scanning even when some hosts have tech issues? [\#264](https://github.com/future-architect/vuls/issues/264)
+- Normalization of JSON output [\#259](https://github.com/future-architect/vuls/issues/259)
+- Add report subcommand, change scan subcommand options [\#239](https://github.com/future-architect/vuls/issues/239)
+- scan localhost? [\#210](https://github.com/future-architect/vuls/issues/210)
+- Can Vuls show details about updateable packages [\#341](https://github.com/future-architect/vuls/issues/341)
+- Scan all containers except [\#285](https://github.com/future-architect/vuls/issues/285)
+- Notify the difference from the previous scan result [\#255](https://github.com/future-architect/vuls/issues/255)
+- EC2RoleCreds support? [\#250](https://github.com/future-architect/vuls/issues/250)
+- Output confidence score of detection accuracy and detection method to JSON or Reporting [\#350](https://github.com/future-architect/vuls/pull/350) ([kotakanbe](https://github.com/kotakanbe))
+- Avoid null slice being null in JSON [\#345](https://github.com/future-architect/vuls/pull/345) ([kotakanbe](https://github.com/kotakanbe))
+- Add -format-one-email option [\#331](https://github.com/future-architect/vuls/pull/331) ([knqyf263](https://github.com/knqyf263))
+- Support Raspbian [\#330](https://github.com/future-architect/vuls/pull/330) ([knqyf263](https://github.com/knqyf263))
+- Add leniancy to the version matching for debian to account for versio… [\#328](https://github.com/future-architect/vuls/pull/328) ([jsulinski](https://github.com/jsulinski))
+- Add image information for docker containers [\#326](https://github.com/future-architect/vuls/pull/326) ([jsulinski](https://github.com/jsulinski))
+- Continue scanning even when some hosts have tech issues [\#309](https://github.com/future-architect/vuls/pull/309) ([kotakanbe](https://github.com/kotakanbe))
+- Add -log-dir option [\#301](https://github.com/future-architect/vuls/pull/301) ([knqyf263](https://github.com/knqyf263))
+- Use --assumeno option [\#300](https://github.com/future-architect/vuls/pull/300) ([knqyf263](https://github.com/knqyf263))
+- Add local scan mode\(Scan without SSH when target server is localhost\) [\#291](https://github.com/future-architect/vuls/pull/291) ([kotakanbe](https://github.com/kotakanbe))
+- Support RHEL5 [\#289](https://github.com/future-architect/vuls/pull/289) ([kotakanbe](https://github.com/kotakanbe))
+- Add LXD support [\#288](https://github.com/future-architect/vuls/pull/288) ([jiazio](https://github.com/jiazio))
+- Add timeout option to configtest [\#400](https://github.com/future-architect/vuls/pull/400) ([kotakanbe](https://github.com/kotakanbe))
+- Notify the difference from the previous scan result [\#392](https://github.com/future-architect/vuls/pull/392) ([knqyf263](https://github.com/knqyf263))
+- Add Oracle Linux support [\#386](https://github.com/future-architect/vuls/pull/386) ([Djelibeybi](https://github.com/Djelibeybi))
+- Change container scan format in config.toml [\#381](https://github.com/future-architect/vuls/pull/381) ([kotakanbe](https://github.com/kotakanbe))
+- Obsolete CentOS5 support [\#378](https://github.com/future-architect/vuls/pull/378) ([kotakanbe](https://github.com/kotakanbe))
+- Deprecate prepare subcommand to minimize the root authority defined by /etc/sudoers [\#375](https://github.com/future-architect/vuls/pull/375) ([kotakanbe](https://github.com/kotakanbe))
+- Support IAM role for report to S3. [\#370](https://github.com/future-architect/vuls/pull/370) ([ohsawa0515](https://github.com/ohsawa0515))
+- Add .travis.yml [\#363](https://github.com/future-architect/vuls/pull/363) ([knqyf263](https://github.com/knqyf263))
+- Output changelog in report, TUI and JSON for Ubuntu/Debian/CentOS [\#356](https://github.com/future-architect/vuls/pull/356) ([kotakanbe](https://github.com/kotakanbe))
+
+**Fixed bugs:**
+
+- Debian scans failing in docker [\#323](https://github.com/future-architect/vuls/issues/323)
+- Local CVE DB is still checked, even if a CVE Dictionary URL is defined [\#316](https://github.com/future-architect/vuls/issues/316)
+- vuls needs gmake. [\#313](https://github.com/future-architect/vuls/issues/313)
+- patch request for FreeBSD [\#312](https://github.com/future-architect/vuls/issues/312)
+- Report: failed to read from json \(Docker\) [\#294](https://github.com/future-architect/vuls/issues/294)
+- -report-mail option does not output required mail header [\#282](https://github.com/future-architect/vuls/issues/282)
+- PackInfo not found error when vuls scan. [\#281](https://github.com/future-architect/vuls/issues/281)
+- Normalize character set [\#279](https://github.com/future-architect/vuls/issues/279)
+- The number of Updatable Packages is different from the number of yum check-update [\#373](https://github.com/future-architect/vuls/issues/373)
+- sudo is needed when exec yum check-update on RHEL7 [\#371](https://github.com/future-architect/vuls/issues/371)
+- `123-3ubuntu4` should be marked as ChangelogLenientMatch [\#362](https://github.com/future-architect/vuls/issues/362)
+- CentOS  multi package invalid result [\#360](https://github.com/future-architect/vuls/issues/360)
+- Parse error after check-update. \(Unknown format\) [\#359](https://github.com/future-architect/vuls/issues/359)
+- Fix candidate to confidence. [\#354](https://github.com/future-architect/vuls/pull/354) ([kotakanbe](https://github.com/kotakanbe))
+- Bug fix: not send e-mail to cc address [\#346](https://github.com/future-architect/vuls/pull/346) ([knqyf263](https://github.com/knqyf263))
+- Change the command used for os detection from uname to freebsd-version [\#340](https://github.com/future-architect/vuls/pull/340) ([kotakanbe](https://github.com/kotakanbe))
+- Fix error handling of detectOS [\#337](https://github.com/future-architect/vuls/pull/337) ([kotakanbe](https://github.com/kotakanbe))
+- Fix infinite retry at size overrun error in Slack report [\#329](https://github.com/future-architect/vuls/pull/329) ([kotakanbe](https://github.com/kotakanbe))
+- aptitude changelog defaults to using more, which is not interactive a… [\#324](https://github.com/future-architect/vuls/pull/324) ([jsulinski](https://github.com/jsulinski))
+- Do not use sudo when echo [\#322](https://github.com/future-architect/vuls/pull/322) ([knqyf263](https://github.com/knqyf263))
+- Reduce privilege requirements for commands that don't need sudo on Ubuntu/Debian [\#319](https://github.com/future-architect/vuls/pull/319) ([jsulinski](https://github.com/jsulinski))
+- Don't check for a CVE DB when CVE Dictionary URL is defined [\#317](https://github.com/future-architect/vuls/pull/317) ([jsulinski](https://github.com/jsulinski))
+- Fix typo contianer -\> container [\#314](https://github.com/future-architect/vuls/pull/314) ([justyns](https://github.com/justyns))
+- Fix the changelog cache logic for ubuntu/debian [\#305](https://github.com/future-architect/vuls/pull/305) ([kotakanbe](https://github.com/kotakanbe))
+- Fix yum updateinfo options [\#304](https://github.com/future-architect/vuls/pull/304) ([kotakanbe](https://github.com/kotakanbe))
+- Update glide.lock to fix create-log-dir error. [\#303](https://github.com/future-architect/vuls/pull/303) ([kotakanbe](https://github.com/kotakanbe))
+- Fix a bug in logging \(file output\) at scan command [\#302](https://github.com/future-architect/vuls/pull/302) ([kotakanbe](https://github.com/kotakanbe))
+- Add -pipe flag \#294 [\#299](https://github.com/future-architect/vuls/pull/299) ([kotakanbe](https://github.com/kotakanbe))
+- Fix RHEL5 scan stopped halfway [\#293](https://github.com/future-architect/vuls/pull/293) ([kotakanbe](https://github.com/kotakanbe))
+- Fix amazon linux scan stopped halfway [\#292](https://github.com/future-architect/vuls/pull/292) ([kotakanbe](https://github.com/kotakanbe))
+- Fix nil-ponter in TUI [\#388](https://github.com/future-architect/vuls/pull/388) ([kotakanbe](https://github.com/kotakanbe))
+- Fix Bug of Mysql Backend [\#384](https://github.com/future-architect/vuls/pull/384) ([kotakanbe](https://github.com/kotakanbe))
+- Fix scan confidence on Ubuntu/Debian/Raspbian \#362 [\#379](https://github.com/future-architect/vuls/pull/379) ([kotakanbe](https://github.com/kotakanbe))
+- Fix updatalbe packages count \#373 [\#374](https://github.com/future-architect/vuls/pull/374) ([kotakanbe](https://github.com/kotakanbe))
+- sudo yum check-update on RHEL [\#372](https://github.com/future-architect/vuls/pull/372) ([kotakanbe](https://github.com/kotakanbe))
+- Change ssh option from -t to -tt [\#369](https://github.com/future-architect/vuls/pull/369) ([knqyf263](https://github.com/knqyf263))
+- Increase the width of RequestPty [\#364](https://github.com/future-architect/vuls/pull/364) ([knqyf263](https://github.com/knqyf263))
+
+**Closed issues:**
+
+-  vuls configtest --debugがsudoのチェックで止まってしまう [\#395](https://github.com/future-architect/vuls/issues/395)
+- Add support for Oracle Linux [\#385](https://github.com/future-architect/vuls/issues/385)
+- error on install - Ubuntu 16.04 [\#376](https://github.com/future-architect/vuls/issues/376)
+- Unknown OS Type [\#335](https://github.com/future-architect/vuls/issues/335)
+- mac os 10.12.3 make install error [\#334](https://github.com/future-architect/vuls/issues/334)
+- assumeYes doesn't work because there is no else condition [\#320](https://github.com/future-architect/vuls/issues/320)
+- Debian scan uses sudo where unnecessary [\#318](https://github.com/future-architect/vuls/issues/318)
+- Add FreeBSD 11 to supported OS on documents. [\#311](https://github.com/future-architect/vuls/issues/311)
+- docker fetchnvd failing [\#274](https://github.com/future-architect/vuls/issues/274)
+- Latest version of labstack echo breaks installation [\#268](https://github.com/future-architect/vuls/issues/268)
+- fetchnvd Fails using example loop [\#267](https://github.com/future-architect/vuls/issues/267)
+
+**Merged pull requests:**
+
+- fix typo in README.ja.md [\#394](https://github.com/future-architect/vuls/pull/394) ([lv7777](https://github.com/lv7777))
+- Update Tutorial in README [\#387](https://github.com/future-architect/vuls/pull/387) ([kotakanbe](https://github.com/kotakanbe))
+- Fix README [\#383](https://github.com/future-architect/vuls/pull/383) ([usiusi360](https://github.com/usiusi360))
+- s/dictinary/dictionary typo [\#382](https://github.com/future-architect/vuls/pull/382) ([beuno](https://github.com/beuno))
+- Fix Japanese typo [\#377](https://github.com/future-architect/vuls/pull/377) ([IMAI-Yuji](https://github.com/IMAI-Yuji))
+- Improve kanji character [\#351](https://github.com/future-architect/vuls/pull/351) ([hasegawa-tomoki](https://github.com/hasegawa-tomoki))
+- Add PULL\_REQUEST\_TEMPLATE.md [\#348](https://github.com/future-architect/vuls/pull/348) ([knqyf263](https://github.com/knqyf263))
+- Update README [\#347](https://github.com/future-architect/vuls/pull/347) ([knqyf263](https://github.com/knqyf263))
+- Fix test case [\#344](https://github.com/future-architect/vuls/pull/344) ([kotakanbe](https://github.com/kotakanbe))
+- Fix typo [\#343](https://github.com/future-architect/vuls/pull/343) ([knqyf263](https://github.com/knqyf263))
+- Rename Makefile to GNUmakefile \#313 [\#339](https://github.com/future-architect/vuls/pull/339) ([kotakanbe](https://github.com/kotakanbe))
+- Update README [\#338](https://github.com/future-architect/vuls/pull/338) ([kotakanbe](https://github.com/kotakanbe))
+- add error handling [\#332](https://github.com/future-architect/vuls/pull/332) ([kazuminn](https://github.com/kazuminn))
+- Update readme [\#308](https://github.com/future-architect/vuls/pull/308) ([lapthorn](https://github.com/lapthorn))
+- Update glide.lock to fix import error [\#306](https://github.com/future-architect/vuls/pull/306) ([knqyf263](https://github.com/knqyf263))
+- Check whether echo is executable with nopasswd [\#298](https://github.com/future-architect/vuls/pull/298) ([knqyf263](https://github.com/knqyf263))
+- Update docker README [\#297](https://github.com/future-architect/vuls/pull/297) ([knqyf263](https://github.com/knqyf263))
+- update readme [\#296](https://github.com/future-architect/vuls/pull/296) ([galigalikun](https://github.com/galigalikun))
+- remove unused import line. [\#358](https://github.com/future-architect/vuls/pull/358) ([ymomoi](https://github.com/ymomoi))
+
+## [v0.2.0](https://github.com/future-architect/vuls/tree/v0.2.0) (2017-01-10)
+[Full Changelog](https://github.com/future-architect/vuls/compare/v0.1.7...v0.2.0)
+
+**Implemented enhancements:**
+
+- Add report subcommand, change scan options. \#239 [\#270](https://github.com/future-architect/vuls/pull/270) ([kotakanbe](https://github.com/kotakanbe))
+- Add --assume-yes to prepare \#260 [\#266](https://github.com/future-architect/vuls/pull/266) ([Code0x58](https://github.com/Code0x58))
+- Use RFC3339 timestamps in the results [\#265](https://github.com/future-architect/vuls/pull/265) ([Code0x58](https://github.com/Code0x58))
+
+**Fixed bugs:**
+
+- vuls prepare failed to centos7 [\#275](https://github.com/future-architect/vuls/issues/275)
+- Failed to scan on RHEL5 [\#94](https://github.com/future-architect/vuls/issues/94)
+- Fix container os detection [\#287](https://github.com/future-architect/vuls/pull/287) ([jiazio](https://github.com/jiazio))
+- Add date header to report mail. [\#283](https://github.com/future-architect/vuls/pull/283) ([ymomoi](https://github.com/ymomoi))
+- Add Content-Type header to report/mail.go . [\#280](https://github.com/future-architect/vuls/pull/280) ([hogehogehugahuga](https://github.com/hogehogehugahuga))
+- Keep output of "vuls scan -report-\*" to be same every times [\#272](https://github.com/future-architect/vuls/pull/272) ([yoheimuta](https://github.com/yoheimuta))
+- Fix JSON-dir regex pattern \#265 [\#271](https://github.com/future-architect/vuls/pull/271) ([kotakanbe](https://github.com/kotakanbe))
+- Stop quietly ignoring `--ssh-external` on Windows [\#263](https://github.com/future-architect/vuls/pull/263) ([Code0x58](https://github.com/Code0x58))
+- Fix non-interactive `apt-get install` \#251 [\#253](https://github.com/future-architect/vuls/pull/253) ([Code0x58](https://github.com/Code0x58))
+
+**Closed issues:**
+
+- gocui.NewGui now takes a parameter [\#261](https://github.com/future-architect/vuls/issues/261)
+- Add a `--yes` flag to bypass interactive prompt for `vuls prepare` [\#260](https://github.com/future-architect/vuls/issues/260)
+- `vuls prepare` doesn't work on Debian host due to apt-get confirmation prompt [\#251](https://github.com/future-architect/vuls/issues/251)
+
+**Merged pull requests:**
+
+- Fix gocui.NewGui after signature change \#261 [\#262](https://github.com/future-architect/vuls/pull/262) ([Code0x58](https://github.com/Code0x58))
+- Replace inconsistent tabs with spaces [\#254](https://github.com/future-architect/vuls/pull/254) ([Code0x58](https://github.com/Code0x58))
+- Fix README [\#249](https://github.com/future-architect/vuls/pull/249) ([usiusi360](https://github.com/usiusi360))
+
 ## [v0.1.7](https://github.com/future-architect/vuls/tree/v0.1.7) (2016-11-08)
 [Full Changelog](https://github.com/future-architect/vuls/compare/v0.1.6...v0.1.7)

@@ -48,6 +196,8 @@

 **Closed issues:**

+- --enable-repos of yum option [\#246](https://github.com/future-architect/vuls/issues/246)
+- --skip-broken at yum option [\#245](https://github.com/future-architect/vuls/issues/245)
 - Recent changes to gobui cause build failures [\#228](https://github.com/future-architect/vuls/issues/228)
 - https://hub.docker.com/r/vuls/go-cve-dictionary/ is empty [\#208](https://github.com/future-architect/vuls/issues/208)
 - Not able to install gomail fails [\#202](https://github.com/future-architect/vuls/issues/202)
@@ -59,6 +209,7 @@
 - vuls configtest -ssh-external doesnt work [\#178](https://github.com/future-architect/vuls/issues/178)
 - apt-get update: time out [\#175](https://github.com/future-architect/vuls/issues/175)
 - scanning on Centos6, but vuls recognizes debian. [\#174](https://github.com/future-architect/vuls/issues/174)
+- Fix READMEja  \#164  [\#173](https://github.com/future-architect/vuls/issues/173)

 **Merged pull requests:**

@@ -258,7 +409,7 @@
 - Maximum 6 nodes available to scan [\#12](https://github.com/future-architect/vuls/issues/12)
 - panic: runtime error: index out of range [\#5](https://github.com/future-architect/vuls/issues/5)
 - Fix sudo option on RedHat like Linux and change some messages. [\#20](https://github.com/future-architect/vuls/pull/20) ([kotakanbe](https://github.com/kotakanbe))
- Typo fix and updated readme [\#19](https://github.com/future-architect/vuls/pull/19) ([Euan-Kerr](https://github.com/Euan-Kerr))
+- Typo fix and updated readme [\#19](https://github.com/future-architect/vuls/pull/19) ([EuanKerr](https://github.com/EuanKerr))
 - remove a period at the end of error messages. [\#18](https://github.com/future-architect/vuls/pull/18) ([kotakanbe](https://github.com/kotakanbe))
 - fix error while yum updateinfo --security update on rhel@aws [\#17](https://github.com/future-architect/vuls/pull/17) ([kotakanbe](https://github.com/kotakanbe))
 - Fixed typos [\#15](https://github.com/future-architect/vuls/pull/15) ([radarhere](https://github.com/radarhere))
--- a/3
+++ b/3
@@ -22,6 +22,8 @@ REVISION := $(shell git rev-parse --short HEAD)
 LDFLAGS := -X 'main.version=$(VERSION)' \
 	-X 'main.revision=$(REVISION)'

+all: glide deps build test
+
 glide:
 	go get github.com/Masterminds/glide

@@ -37,7 +39,6 @@ build: main.go deps
 install: main.go deps
 	go install -ldflags "$(LDFLAGS)"

-all: test

 lint:
 	@ go get -v github.com/golang/lint/golint
--- a/README.fr.md
+++ b/README.fr.md
@@ -40,7 +40,7 @@ Vuls est un outil crée pour palier aux problèmes listés ci-dessus. Voici ses
 # Caractéristiques principales

 - Recherche de vulnérabilités sur des serveurs Linux
-    - Supporte Ubuntu, Debian, CentOS, Amazon Linux, RHEL
+    - Supporte Ubuntu, Debian, CentOS, Amazon Linux, RHEL, Raspbian
    - Cloud, auto-hébergement, Docker
 - Scan d'intergiciels non inclus dans le gestionnaire de paquets de l'OS
    - Scan d'intergiciels, de libraries de language de programmation et framework pour des vulnérabilités
--- a/README.ja.md
+++ b/README.ja.md
--- a/README.md
+++ b/README.md
--- a/cache/bolt.go
+++ b/cache/bolt.go
@@ -20,6 +20,7 @@ package cache
 import (
 	"encoding/json"
 	"fmt"
+	"time"

 	"github.com/Sirupsen/logrus"
 	"github.com/boltdb/bolt"
@@ -92,6 +93,23 @@ func (b Bolt) GetMeta(serverName string) (meta Meta, found bool, err error) {
 	return
 }

+// RefreshMeta gets a Meta Information os the servername to boltdb.
+func (b Bolt) RefreshMeta(meta Meta) error {
+	meta.CreatedAt = time.Now()
+	jsonBytes, err := json.Marshal(meta)
+	if err != nil {
+		return fmt.Errorf("Failed to marshal to JSON: %s", err)
+	}
+	return b.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket([]byte(metabucket))
+		if err := bkt.Put([]byte(meta.Name), jsonBytes); err != nil {
+			return err
+		}
+		b.Log.Debugf("Refreshed Meta: %s", meta.Name)
+		return nil
+	})
+}
+
 // EnsureBuckets puts a Meta information and create a buket that holds changelogs.
 func (b Bolt) EnsureBuckets(meta Meta) error {
 	jsonBytes, err := json.Marshal(meta)
@@ -123,12 +141,12 @@ func (b Bolt) EnsureBuckets(meta Meta) error {
 	})
 }

-// PrettyPrint is for debuging
+// PrettyPrint is for debug
 func (b Bolt) PrettyPrint(meta Meta) error {
 	return b.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket([]byte(metabucket))
 		v := bkt.Get([]byte(meta.Name))
-		b.Log.Debugf("key:%s, value:%s", meta.Name, v)
+		b.Log.Debugf("Meta: key:%s, value:%s", meta.Name, v)

 		bkt = tx.Bucket([]byte(meta.Name))
 		c := bkt.Cursor()
--- a/cache/bolt_test.go
+++ b/cache/bolt_test.go
@@ -90,9 +90,12 @@ func TestEnsureBuckets(t *testing.T) {
 	if !found {
 		t.Errorf("Not Found in meta")
 	}
-	if !reflect.DeepEqual(meta, m) {
+	if meta.Name != m.Name || meta.Distro != m.Distro {
 		t.Errorf("expected %v, actual %v", meta, m)
 	}
+	if !reflect.DeepEqual(meta.Packs, m.Packs) {
+		t.Errorf("expected %v, actual %v", meta.Packs, m.Packs)
+	}
 	if err := DB.Close(); err != nil {
 		t.Errorf("Failed to close bolt: %s", err)
 	}
--- a/cache/db.go
+++ b/cache/db.go
@@ -18,6 +18,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package cache

 import (
+	"time"
+
 	"github.com/future-architect/vuls/config"
 	"github.com/future-architect/vuls/models"
 )
@@ -31,6 +33,7 @@ const metabucket = "changelog-meta"
 type Cache interface {
 	Close() error
 	GetMeta(string) (Meta, bool, error)
+	RefreshMeta(Meta) error
 	EnsureBuckets(Meta) error
 	PrettyPrint(Meta) error
 	GetChangelog(string, string) (string, error)
@@ -40,9 +43,10 @@ type Cache interface {
 // Meta holds a server name, distro information of the scanned server and
 // package information that was collected at the last scan.
 type Meta struct {
-	Name   string
-	Distro config.Distro
-	Packs  []models.PackageInfo
+	Name      string
+	Distro    config.Distro
+	Packs     []models.PackageInfo
+	CreatedAt time.Time
 }

 // FindPack search a PackageInfo
--- a/commands/configtest.go
+++ b/commands/configtest.go
@@ -20,12 +20,9 @@ package commands
 import (
 	"context"
 	"flag"
-	"io/ioutil"
 	"os"
 	"path/filepath"
-	"strings"

-	"github.com/Sirupsen/logrus"
 	"github.com/google/subcommands"

 	c "github.com/future-architect/vuls/config"
@@ -36,8 +33,11 @@ import (
 // ConfigtestCmd is Subcommand
 type ConfigtestCmd struct {
 	configPath     string
+	logDir         string
 	askKeyPassword bool
 	sshExternal    bool
+	httpProxy      string
+	timeoutSec     int

 	debug bool
 }
@@ -52,12 +52,15 @@ func (*ConfigtestCmd) Synopsis() string { return "Test configuration" }
 func (*ConfigtestCmd) Usage() string {
 	return `configtest:
 	configtest
-		        [-config=/path/to/config.toml]
-	        	[-ask-key-password]
-	        	[-ssh-external]
-		        [-debug]
+			[-config=/path/to/config.toml]
+			[-log-dir=/path/to/log]
+			[-ask-key-password]
+			[-timeout=300]
+			[-ssh-external]
+			[-http-proxy=http://192.168.0.1:8080]
+			[-debug]

-		        [SERVER]...
+			[SERVER]...
 `
 }

@@ -67,8 +70,13 @@ func (p *ConfigtestCmd) SetFlags(f *flag.FlagSet) {
 	defaultConfPath := filepath.Join(wd, "config.toml")
 	f.StringVar(&p.configPath, "config", defaultConfPath, "/path/to/toml")

+	defaultLogDir := util.GetDefaultLogDir()
+	f.StringVar(&p.logDir, "log-dir", defaultLogDir, "/path/to/log")
+
 	f.BoolVar(&p.debug, "debug", false, "debug mode")

+	f.IntVar(&p.timeoutSec, "timeout", 5*60, "Timeout(Sec)")
+
 	f.BoolVar(
 		&p.askKeyPassword,
 		"ask-key-password",
@@ -76,6 +84,13 @@ func (p *ConfigtestCmd) SetFlags(f *flag.FlagSet) {
 		"Ask ssh privatekey password before scanning",
 	)

+	f.StringVar(
+		&p.httpProxy,
+		"http-proxy",
+		"",
+		"http://proxy-url:port (default: empty)",
+	)
+
 	f.BoolVar(
 		&p.sshExternal,
 		"ssh-external",
@@ -85,42 +100,34 @@ func (p *ConfigtestCmd) SetFlags(f *flag.FlagSet) {

 // Execute execute
 func (p *ConfigtestCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
+	// Setup Logger
+	c.Conf.Debug = p.debug
+	c.Conf.LogDir = p.logDir
+	util.Log = util.NewCustomLogger(c.ServerInfo{})

 	var keyPass string
 	var err error
 	if p.askKeyPassword {
 		prompt := "SSH key password: "
 		if keyPass, err = getPasswd(prompt); err != nil {
-			logrus.Error(err)
+			util.Log.Error(err)
 			return subcommands.ExitFailure
 		}
 	}

-	c.Conf.Debug = p.debug
-	c.Conf.SSHExternal = p.sshExternal
-
 	err = c.Load(p.configPath, keyPass)
 	if err != nil {
-		logrus.Errorf("Error loading %s, %s", p.configPath, err)
+		util.Log.Errorf("Error loading %s, %s", p.configPath, err)
+		util.Log.Errorf("If you update Vuls and get this error, there may be incompatible changes in config.toml")
+		util.Log.Errorf("Please check README: https://github.com/future-architect/vuls#configuration")
 		return subcommands.ExitUsageError
 	}
+	c.Conf.SSHExternal = p.sshExternal
+	c.Conf.HTTPProxy = p.httpProxy

 	var servernames []string
 	if 0 < len(f.Args()) {
 		servernames = f.Args()
-	} else {
-		stat, _ := os.Stdin.Stat()
-		if (stat.Mode() & os.ModeCharDevice) == 0 {
-			bytes, err := ioutil.ReadAll(os.Stdin)
-			if err != nil {
-				logrus.Errorf("Failed to read stdin: %s", err)
-				return subcommands.ExitFailure
-			}
-			fields := strings.Fields(string(bytes))
-			if 0 < len(fields) {
-				servernames = fields
-			}
-		}
 	}

 	target := make(map[string]c.ServerInfo)
@@ -134,7 +141,7 @@ func (p *ConfigtestCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interfa
 			}
 		}
 		if !found {
-			logrus.Errorf("%s is not in config", arg)
+			util.Log.Errorf("%s is not in config", arg)
 			return subcommands.ExitUsageError
 		}
 	}
@@ -142,25 +149,23 @@ func (p *ConfigtestCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interfa
 		c.Conf.Servers = target
 	}

-	// logger
-	Log := util.NewCustomLogger(c.ServerInfo{})
-
-	Log.Info("Validating Config...")
+	util.Log.Info("Validating config...")
 	if !c.Conf.ValidateOnConfigtest() {
 		return subcommands.ExitUsageError
 	}

-	Log.Info("Detecting Server/Contianer OS... ")
-	if err := scan.InitServers(Log); err != nil {
-		Log.Errorf("Failed to init servers: %s", err)
+	util.Log.Info("Detecting Server/Container OS... ")
+	if err := scan.InitServers(); err != nil {
+		util.Log.Errorf("Failed to init servers: %s", err)
 		return subcommands.ExitFailure
 	}

-	Log.Info("Checking sudo configuration... ")
-	if err := scan.CheckIfSudoNoPasswd(Log); err != nil {
-		Log.Errorf("Failed to sudo with nopassword via SSH. Define NOPASSWD in /etc/sudoers on target servers. err: %s", err)
-		return subcommands.ExitFailure
-	}
+	util.Log.Info("Checking dependendies...")
+	scan.CheckDependencies(p.timeoutSec)
+
+	util.Log.Info("Checking sudo settings...")
+	scan.CheckIfSudoNoPasswd(p.timeoutSec)
+
 	scan.PrintSSHableServerNames()
 	return subcommands.ExitSuccess
 }
--- a/commands/discover.go
+++ b/commands/discover.go
@@ -116,11 +116,12 @@ subjectPrefix = "[vuls]"
 #  "cpe:/a:rubyonrails:ruby_on_rails:4.2.1",
 #]
 #dependencyCheckXMLPath = "/tmp/dependency-check-report.xml"
-#containers = ["${running}"]
 #ignoreCves = ["CVE-2014-6271"]
 #optional = [
 #    ["key", "value"],
 #]
+#containers = ["${running}"]
+

 [servers]
 {{- $names:=  .Names}}
@@ -134,11 +135,16 @@ host         = "{{$ip}}"
 #  "cpe:/a:rubyonrails:ruby_on_rails:4.2.1",
 #]
 #dependencyCheckXMLPath = "/tmp/dependency-check-report.xml"
-#containers = ["${running}"]
 #ignoreCves = ["CVE-2014-0160"]
 #optional = [
 #    ["key", "value"],
 #]
+#[servers.{{index $names $i}}.containers]
+#type = "docker" #or "lxd" defualt: docker
+#includes = ["${running}"]
+#excludes = ["container_name_a", "4aa37a8b63b9"]
+
+
 {{end}}

 `
--- a/commands/prepare.go
+++ b/commands/prepare.go
@@ -1,185 +0,0 @@
-/* Vuls - Vulnerability Scanner
-Copyright (C) 2016  Future Architect, Inc. Japan.
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package commands
-
-import (
-	"context"
-	"flag"
-	"os"
-	"path/filepath"
-
-	"github.com/Sirupsen/logrus"
-	c "github.com/future-architect/vuls/config"
-	"github.com/future-architect/vuls/scan"
-	"github.com/future-architect/vuls/util"
-	"github.com/google/subcommands"
-)
-
-// PrepareCmd is Subcommand of host discovery mode
-type PrepareCmd struct {
-	debug      bool
-	configPath string
-
-	askSudoPassword bool
-	askKeyPassword  bool
-
-	sshExternal bool
-	assumeYes   bool
-}
-
-// Name return subcommand name
-func (*PrepareCmd) Name() string { return "prepare" }
-
-// Synopsis return synopsis
-func (*PrepareCmd) Synopsis() string {
-	return `Install required packages to scan.
-				CentOS: yum-plugin-security, yum-plugin-changelog
-				Amazon: None
-				RHEL:   None
-				Ubuntu: None
-				Debian: aptitude
-
-	`
-}
-
-// Usage return usage
-func (*PrepareCmd) Usage() string {
-	return `prepare:
-	prepare
-			[-config=/path/to/config.toml]
-			[-ask-key-password]
-			[-assume-yes]
-			[-debug]
-			[-ssh-external]
-
-			[SERVER]...
-`
-}
-
-// SetFlags set flag
-func (p *PrepareCmd) SetFlags(f *flag.FlagSet) {
-
-	f.BoolVar(&p.debug, "debug", false, "debug mode")
-
-	wd, _ := os.Getwd()
-
-	defaultConfPath := filepath.Join(wd, "config.toml")
-	f.StringVar(&p.configPath, "config", defaultConfPath, "/path/to/toml")
-
-	f.BoolVar(
-		&p.askKeyPassword,
-		"ask-key-password",
-		false,
-		"Ask ssh privatekey password before scanning",
-	)
-
-	f.BoolVar(
-		&p.askSudoPassword,
-		"ask-sudo-password",
-		false,
-		"[Deprecated] THIS OPTION WAS REMOVED FOR SECURITY REASONS. Define NOPASSWD in /etc/sudoers on target servers and use SSH key-based authentication",
-	)
-
-	f.BoolVar(
-		&p.sshExternal,
-		"ssh-external",
-		false,
-		"Use external ssh command. Default: Use the Go native implementation")
-
-	f.BoolVar(
-		&p.assumeYes,
-		"assume-yes",
-		false,
-		"Assume any dependencies should be installed")
-
-}
-
-// Execute execute
-func (p *PrepareCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
-	var keyPass string
-	var err error
-	if p.askKeyPassword {
-		prompt := "SSH key password: "
-		if keyPass, err = getPasswd(prompt); err != nil {
-			logrus.Error(err)
-			return subcommands.ExitFailure
-		}
-	}
-	if p.askSudoPassword {
-		logrus.Errorf("[Deprecated] -ask-sudo-password WAS REMOVED FOR SECURITY REASONS. Define NOPASSWD in /etc/sudoers on target servers and use SSH key-based authentication")
-		return subcommands.ExitFailure
-	}
-
-	err = c.Load(p.configPath, keyPass)
-	if err != nil {
-		logrus.Errorf("Error loading %s, %s", p.configPath, err)
-		return subcommands.ExitUsageError
-	}
-
-	logrus.Infof("Start Preparing (config: %s)", p.configPath)
-	target := make(map[string]c.ServerInfo)
-	for _, arg := range f.Args() {
-		found := false
-		for servername, info := range c.Conf.Servers {
-			if servername == arg {
-				target[servername] = info
-				found = true
-				break
-			}
-		}
-		if !found {
-			logrus.Errorf("%s is not in config", arg)
-			return subcommands.ExitUsageError
-		}
-	}
-	if 0 < len(f.Args()) {
-		c.Conf.Servers = target
-	}
-
-	c.Conf.Debug = p.debug
-	c.Conf.SSHExternal = p.sshExternal
-	c.Conf.AssumeYes = p.assumeYes
-
-	logrus.Info("Validating Config...")
-	if !c.Conf.ValidateOnPrepare() {
-		return subcommands.ExitUsageError
-	}
-	// Set up custom logger
-	logger := util.NewCustomLogger(c.ServerInfo{})
-
-	logger.Info("Detecting OS... ")
-	if err := scan.InitServers(logger); err != nil {
-		logger.Errorf("Failed to init servers: %s", err)
-		return subcommands.ExitFailure
-	}
-
-	logger.Info("Checking sudo configuration... ")
-	if err := scan.CheckIfSudoNoPasswd(logger); err != nil {
-		logger.Errorf("Failed to sudo with nopassword via SSH. Define NOPASSWD in /etc/sudoers on target servers")
-		return subcommands.ExitFailure
-	}
-
-	if errs := scan.Prepare(); 0 < len(errs) {
-		for _, e := range errs {
-			logger.Errorf("Failed to prepare: %s", e)
-		}
-		return subcommands.ExitFailure
-	}
-
-	return subcommands.ExitSuccess
-}
--- a/commands/report.go
+++ b/commands/report.go
@@ -30,7 +30,6 @@ import (
 	"github.com/future-architect/vuls/report"
 	"github.com/future-architect/vuls/util"
 	"github.com/google/subcommands"
-	"github.com/kotakanbe/go-cve-dictionary/log"
 )

 // ReportCmd is subcommand for reporting
@@ -40,15 +39,16 @@ type ReportCmd struct {
 	debugSQL   bool
 	configPath string
 	resultsDir string
+	logDir     string
 	refreshCve bool

 	cvssScoreOver      float64
 	ignoreUnscoredCves bool
 	httpProxy          string

-	cvedbtype        string
-	cvedbpath        string
-	cveDictionaryURL string
+	cvedbtype string
+	cvedbpath string
+	cvedbURL  string

 	toSlack     bool
 	toEMail     bool
@@ -58,6 +58,7 @@ type ReportCmd struct {

 	formatJSON        bool
 	formatXML         bool
+	formatOneEMail    bool
 	formatOneLineText bool
 	formatShortText   bool
 	formatFullText    bool
@@ -71,6 +72,10 @@ type ReportCmd struct {
 	azureAccount   string
 	azureKey       string
 	azureContainer string
+
+	pipe bool
+
+	diff bool
 }

 // Name return subcommand name
@@ -86,11 +91,13 @@ func (*ReportCmd) Usage() string {
 		[-lang=en|ja]
 		[-config=/path/to/config.toml]
 		[-results-dir=/path/to/results]
+		[-log-dir=/path/to/log]
 		[-refresh-cve]
 		[-cvedb-type=sqlite3|mysql]
 		[-cvedb-path=/path/to/cve.sqlite3]
 		[-cvedb-url=http://127.0.0.1:1323 or mysql connection string]
 		[-cvss-over=7]
+		[-diff]
 		[-ignore-unscored-cves]
 		[-to-email]
 		[-to-slack]
@@ -99,6 +106,7 @@ func (*ReportCmd) Usage() string {
 		[-to-azure-blob]
 		[-format-json]
 		[-format-xml]
+		[-format-one-email]
 		[-format-one-line-text]
 		[-format-short-text]
 		[-format-full-text]
@@ -112,6 +120,7 @@ func (*ReportCmd) Usage() string {
 		[-http-proxy=http://192.168.0.1:8080]
 		[-debug]
 		[-debug-sql]
+		[-pipe]

 		[SERVER]...
 `
@@ -131,6 +140,9 @@ func (p *ReportCmd) SetFlags(f *flag.FlagSet) {
 	defaultResultsDir := filepath.Join(wd, "results")
 	f.StringVar(&p.resultsDir, "results-dir", defaultResultsDir, "/path/to/results")

+	defaultLogDir := util.GetDefaultLogDir()
+	f.StringVar(&p.logDir, "log-dir", defaultLogDir, "/path/to/log")
+
 	f.BoolVar(
 		&p.refreshCve,
 		"refresh-cve",
@@ -151,7 +163,7 @@ func (p *ReportCmd) SetFlags(f *flag.FlagSet) {
 		"/path/to/sqlite3 (For get cve detail from cve.sqlite3)")

 	f.StringVar(
-		&p.cveDictionaryURL,
+		&p.cvedbURL,
 		"cvedb-url",
 		"",
 		"http://cve-dictionary.com:8080 or mysql connection string")
@@ -162,6 +174,11 @@ func (p *ReportCmd) SetFlags(f *flag.FlagSet) {
 		0,
 		"-cvss-over=6.5 means reporting CVSS Score 6.5 and over (default: 0 (means report all))")

+	f.BoolVar(&p.diff,
+		"diff",
+		false,
+		fmt.Sprintf("Difference between previous result and current result "))
+
 	f.BoolVar(
 		&p.ignoreUnscoredCves,
 		"ignore-unscored-cves",
@@ -184,6 +201,11 @@ func (p *ReportCmd) SetFlags(f *flag.FlagSet) {
 		false,
 		fmt.Sprintf("XML format"))

+	f.BoolVar(&p.formatOneEMail,
+		"format-one-email",
+		false,
+		"Send all the host report via only one EMail (Specify with -to-email)")
+
 	f.BoolVar(&p.formatOneLineText,
 		"format-one-line-text",
 		false,
@@ -229,16 +251,23 @@ func (p *ReportCmd) SetFlags(f *flag.FlagSet) {
 		"",
 		"Azure account key to use. AZURE_STORAGE_ACCESS_KEY environment variable is used if not specified")
 	f.StringVar(&p.azureContainer, "azure-container", "", "Azure storage container name")
+
+	f.BoolVar(
+		&p.pipe,
+		"pipe",
+		false,
+		"Use args passed via PIPE")
 }

 // Execute execute
 func (p *ReportCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
 	c.Conf.Debug = p.debug
 	c.Conf.DebugSQL = p.debugSQL
-	Log := util.NewCustomLogger(c.ServerInfo{})
+	c.Conf.LogDir = p.logDir
+	util.Log = util.NewCustomLogger(c.ServerInfo{})

 	if err := c.Load(p.configPath, ""); err != nil {
-		Log.Errorf("Error loading %s, %s", p.configPath, err)
+		util.Log.Errorf("Error loading %s, %s", p.configPath, err)
 		return subcommands.ExitUsageError
 	}

@@ -246,24 +275,34 @@ func (p *ReportCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}
 	c.Conf.ResultsDir = p.resultsDir
 	c.Conf.CveDBType = p.cvedbtype
 	c.Conf.CveDBPath = p.cvedbpath
-	c.Conf.CveDictionaryURL = p.cveDictionaryURL
+	c.Conf.CveDBURL = p.cvedbURL
 	c.Conf.CvssScoreOver = p.cvssScoreOver
 	c.Conf.IgnoreUnscoredCves = p.ignoreUnscoredCves
 	c.Conf.HTTPProxy = p.httpProxy

-	jsonDir, err := jsonDir(f.Args())
-	if err != nil {
-		log.Errorf("Failed to read from JSON: %s", err)
-		return subcommands.ExitFailure
-	}
+	c.Conf.Pipe = p.pipe

 	c.Conf.FormatXML = p.formatXML
 	c.Conf.FormatJSON = p.formatJSON
+	c.Conf.FormatOneEMail = p.formatOneEMail
 	c.Conf.FormatOneLineText = p.formatOneLineText
 	c.Conf.FormatShortText = p.formatShortText
 	c.Conf.FormatFullText = p.formatFullText

 	c.Conf.GZIP = p.gzip
+	c.Conf.Diff = p.diff
+
+	var dir string
+	var err error
+	if p.diff {
+		dir, err = jsonDir([]string{})
+	} else {
+		dir, err = jsonDir(f.Args())
+	}
+	if err != nil {
+		util.Log.Errorf("Failed to read from JSON: %s", err)
+		return subcommands.ExitFailure
+	}

 	// report
 	reports := []report.ResultWriter{
@@ -280,7 +319,7 @@ func (p *ReportCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}

 	if p.toLocalFile {
 		reports = append(reports, report.LocalFileWriter{
-			CurrentDir: jsonDir,
+			CurrentDir: dir,
 		})
 	}

@@ -289,7 +328,7 @@ func (p *ReportCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}
 		c.Conf.AwsProfile = p.awsProfile
 		c.Conf.S3Bucket = p.awsS3Bucket
 		if err := report.CheckIfBucketExists(); err != nil {
-			Log.Errorf("Check if there is a bucket beforehand: %s, err: %s", c.Conf.S3Bucket, err)
+			util.Log.Errorf("Check if there is a bucket beforehand: %s, err: %s", c.Conf.S3Bucket, err)
 			return subcommands.ExitUsageError
 		}
 		reports = append(reports, report.S3Writer{})
@@ -308,11 +347,11 @@ func (p *ReportCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}

 		c.Conf.AzureContainer = p.azureContainer
 		if len(c.Conf.AzureContainer) == 0 {
-			Log.Error("Azure storage container name is requied with --azure-container option")
+			util.Log.Error("Azure storage container name is requied with --azure-container option")
 			return subcommands.ExitUsageError
 		}
 		if err := report.CheckIfAzureContainerExists(); err != nil {
-			Log.Errorf("Check if there is a container beforehand: %s, err: %s", c.Conf.AzureContainer, err)
+			util.Log.Errorf("Check if there is a container beforehand: %s, err: %s", c.Conf.AzureContainer, err)
 			return subcommands.ExitUsageError
 		}
 		reports = append(reports, report.AzureBlobWriter{})
@@ -323,32 +362,38 @@ func (p *ReportCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}
 		c.Conf.FormatShortText = true
 	}

-	Log.Info("Validating Config...")
+	util.Log.Info("Validating config...")
 	if !c.Conf.ValidateOnReport() {
 		return subcommands.ExitUsageError
 	}
 	if ok, err := cveapi.CveClient.CheckHealth(); !ok {
-		Log.Errorf("CVE HTTP server is not running. err: %s", err)
-		Log.Errorf("Run go-cve-dictionary as server mode before reporting or run with --cvedb-path option")
+		util.Log.Errorf("CVE HTTP server is not running. err: %s", err)
+		util.Log.Errorf("Run go-cve-dictionary as server mode before reporting or run with --cvedb-path option")
 		return subcommands.ExitFailure
 	}
-	if c.Conf.CveDictionaryURL != "" {
-		Log.Infof("cve-dictionary: %s", c.Conf.CveDictionaryURL)
+	if c.Conf.CveDBURL != "" {
+		util.Log.Infof("cve-dictionary: %s", c.Conf.CveDBURL)
 	} else {
 		if c.Conf.CveDBType == "sqlite3" {
-			Log.Infof("cve-dictionary: %s", c.Conf.CveDBPath)
+			util.Log.Infof("cve-dictionary: %s", c.Conf.CveDBPath)
 		}
 	}

-	history, err := loadOneScanHistory(jsonDir)
+	var history models.ScanHistory
+	history, err = loadOneScanHistory(dir)
+	if err != nil {
+		util.Log.Error(err)
+		return subcommands.ExitFailure
+	}
+	util.Log.Infof("Loaded: %s", jsonDir)

 	var results []models.ScanResult
 	for _, r := range history.ScanResults {
 		if p.refreshCve || needToRefreshCve(r) {
-			Log.Debugf("need to refresh")
-			if c.Conf.CveDBType == "sqlite3" {
+			util.Log.Debugf("need to refresh")
+			if c.Conf.CveDBType == "sqlite3" && c.Conf.CveDBURL == "" {
 				if _, err := os.Stat(c.Conf.CveDBPath); os.IsNotExist(err) {
-					log.Errorf("SQLite3 DB(CVE-Dictionary) is not exist: %s",
+					util.Log.Errorf("SQLite3 DB(CVE-Dictionary) is not exist: %s",
 						c.Conf.CveDBPath)
 					return subcommands.ExitFailure
 				}
@@ -356,29 +401,49 @@ func (p *ReportCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}

 			filled, err := fillCveInfoFromCveDB(r)
 			if err != nil {
-				Log.Errorf("Failed to fill CVE information: %s", err)
+				util.Log.Errorf("Failed to fill CVE information: %s", err)
 				return subcommands.ExitFailure
 			}
 			filled.Lang = c.Conf.Lang
-
-			if err := overwriteJSONFile(jsonDir, filled); err != nil {
-				Log.Errorf("Failed to write JSON: %s", err)
+			if err := overwriteJSONFile(dir, *filled); err != nil {
+				util.Log.Errorf("Failed to write JSON: %s", err)
 				return subcommands.ExitFailure
 			}
-			results = append(results, filled)
+			results = append(results, *filled)
 		} else {
-			Log.Debugf("no need to refresh")
+			util.Log.Debugf("no need to refresh")
 			results = append(results, r)
 		}
 	}

+	if p.diff {
+		currentHistory := models.ScanHistory{ScanResults: results}
+		previousHistory, err := loadPreviousScanHistory(currentHistory)
+		if err != nil {
+			util.Log.Error(err)
+			return subcommands.ExitFailure
+		}
+
+		history, err = diff(currentHistory, previousHistory)
+		if err != nil {
+			util.Log.Error(err)
+			return subcommands.ExitFailure
+		}
+		results = []models.ScanResult{}
+		for _, r := range history.ScanResults {
+			filled, _ := r.FillCveDetail()
+			results = append(results, *filled)
+		}
+	}
+
 	var res models.ScanResults
 	for _, r := range results {
 		res = append(res, r.FilterByCvssOver())
 	}
+
 	for _, w := range reports {
 		if err := w.Write(res...); err != nil {
-			Log.Errorf("Failed to report: %s", err)
+			util.Log.Errorf("Failed to report: %s", err)
 			return subcommands.ExitFailure
 		}
 	}
--- a/commands/scan.go
+++ b/commands/scan.go
@@ -26,7 +26,6 @@ import (
 	"path/filepath"
 	"strings"

-	"github.com/Sirupsen/logrus"
 	c "github.com/future-architect/vuls/config"
 	"github.com/future-architect/vuls/scan"
 	"github.com/future-architect/vuls/util"
@@ -39,12 +38,14 @@ type ScanCmd struct {
 	debug          bool
 	configPath     string
 	resultsDir     string
+	logDir         string
 	cacheDBPath    string
 	httpProxy      string
 	askKeyPassword bool
 	containersOnly bool
 	skipBroken     bool
 	sshExternal    bool
+	pipe           bool
 }

 // Name return subcommand name
@@ -59,6 +60,7 @@ func (*ScanCmd) Usage() string {
 	scan
 		[-config=/path/to/config.toml]
 		[-results-dir=/path/to/results]
+		[-log-dir=/path/to/log]
 		[-cachedb-path=/path/to/cache.db]
 		[-ssh-external]
 		[-containers-only]
@@ -66,6 +68,7 @@ func (*ScanCmd) Usage() string {
 		[-http-proxy=http://192.168.0.1:8080]
 		[-ask-key-password]
 		[-debug]
+		[-pipe]

 		[SERVER]...
 `
@@ -83,6 +86,9 @@ func (p *ScanCmd) SetFlags(f *flag.FlagSet) {
 	defaultResultsDir := filepath.Join(wd, "results")
 	f.StringVar(&p.resultsDir, "results-dir", defaultResultsDir, "/path/to/results")

+	defaultLogDir := util.GetDefaultLogDir()
+	f.StringVar(&p.logDir, "log-dir", defaultLogDir, "/path/to/log")
+
 	defaultCacheDBPath := filepath.Join(wd, "cache.db")
 	f.StringVar(
 		&p.cacheDBPath,
@@ -121,45 +127,56 @@ func (p *ScanCmd) SetFlags(f *flag.FlagSet) {
 		false,
 		"Ask ssh privatekey password before scanning",
 	)
+
+	f.BoolVar(
+		&p.pipe,
+		"pipe",
+		false,
+		"Use stdin via PIPE")
 }

 // Execute execute
 func (p *ScanCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
+
+	// Setup Logger
+	c.Conf.Debug = p.debug
+	c.Conf.LogDir = p.logDir
+	util.Log = util.NewCustomLogger(c.ServerInfo{})
+
 	var keyPass string
 	var err error
 	if p.askKeyPassword {
 		prompt := "SSH key password: "
 		if keyPass, err = getPasswd(prompt); err != nil {
-			logrus.Error(err)
+			util.Log.Error(err)
 			return subcommands.ExitFailure
 		}
 	}

-	c.Conf.Debug = p.debug
 	err = c.Load(p.configPath, keyPass)
 	if err != nil {
-		logrus.Errorf("Error loading %s, %s", p.configPath, err)
+		util.Log.Errorf("Error loading %s, %s", p.configPath, err)
+		util.Log.Errorf("If you update Vuls and get this error, there may be incompatible changes in config.toml")
+		util.Log.Errorf("Please check README: https://github.com/future-architect/vuls#configuration")
 		return subcommands.ExitUsageError
 	}

-	logrus.Info("Start scanning")
-	logrus.Infof("config: %s", p.configPath)
+	util.Log.Info("Start scanning")
+	util.Log.Infof("config: %s", p.configPath)

+	c.Conf.Pipe = p.pipe
 	var servernames []string
 	if 0 < len(f.Args()) {
 		servernames = f.Args()
-	} else {
-		stat, _ := os.Stdin.Stat()
-		if (stat.Mode() & os.ModeCharDevice) == 0 {
-			bytes, err := ioutil.ReadAll(os.Stdin)
-			if err != nil {
-				logrus.Errorf("Failed to read stdin: %s", err)
-				return subcommands.ExitFailure
-			}
-			fields := strings.Fields(string(bytes))
-			if 0 < len(fields) {
-				servernames = fields
-			}
+	} else if c.Conf.Pipe {
+		bytes, err := ioutil.ReadAll(os.Stdin)
+		if err != nil {
+			util.Log.Errorf("Failed to read stdin: %s", err)
+			return subcommands.ExitFailure
+		}
+		fields := strings.Fields(string(bytes))
+		if 0 < len(fields) {
+			servernames = fields
 		}
 	}

@@ -174,17 +191,14 @@ func (p *ScanCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 			}
 		}
 		if !found {
-			logrus.Errorf("%s is not in config", arg)
+			util.Log.Errorf("%s is not in config", arg)
 			return subcommands.ExitUsageError
 		}
 	}
 	if 0 < len(servernames) {
 		c.Conf.Servers = target
 	}
-	logrus.Debugf("%s", pp.Sprintf("%v", target))
-
-	// logger
-	Log := util.NewCustomLogger(c.ServerInfo{})
+	util.Log.Debugf("%s", pp.Sprintf("%v", target))

 	c.Conf.ResultsDir = p.resultsDir
 	c.Conf.CacheDBPath = p.cacheDBPath
@@ -193,31 +207,23 @@ func (p *ScanCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 	c.Conf.ContainersOnly = p.containersOnly
 	c.Conf.SkipBroken = p.skipBroken

-	Log.Info("Validating Config...")
+	util.Log.Info("Validating config...")
 	if !c.Conf.ValidateOnScan() {
 		return subcommands.ExitUsageError
 	}

-	Log.Info("Detecting Server/Contianer OS... ")
-	if err := scan.InitServers(Log); err != nil {
-		Log.Errorf("Failed to init servers: %s", err)
+	util.Log.Info("Detecting Server/Container OS... ")
+	if err := scan.InitServers(); err != nil {
+		util.Log.Errorf("Failed to init servers: %s", err)
 		return subcommands.ExitFailure
 	}

-	Log.Info("Checking sudo configuration... ")
-	if err := scan.CheckIfSudoNoPasswd(Log); err != nil {
-		Log.Errorf("Failed to sudo with nopassword via SSH. Define NOPASSWD in /etc/sudoers on target servers")
-		return subcommands.ExitFailure
-	}
+	util.Log.Info("Detecting Platforms... ")
+	scan.DetectPlatforms()

-	Log.Info("Detecting Platforms... ")
-	scan.DetectPlatforms(Log)
-
-	Log.Info("Scanning vulnerabilities... ")
-	if errs := scan.Scan(); 0 < len(errs) {
-		for _, e := range errs {
-			Log.Errorf("Failed to scan. err: %s", e)
-		}
+	util.Log.Info("Scanning vulnerabilities... ")
+	if err := scan.Scan(); err != nil {
+		util.Log.Errorf("Failed to scan. err: %s", err)
 		return subcommands.ExitFailure
 	}
 	fmt.Printf("\n\n\n")
--- a/commands/tui.go
+++ b/commands/tui.go
@@ -23,23 +23,27 @@ import (
 	"os"
 	"path/filepath"

-	log "github.com/Sirupsen/logrus"
 	c "github.com/future-architect/vuls/config"
 	"github.com/future-architect/vuls/models"
 	"github.com/future-architect/vuls/report"
+	"github.com/future-architect/vuls/util"
 	"github.com/google/subcommands"
 )

 // TuiCmd is Subcommand of host discovery mode
 type TuiCmd struct {
-	lang       string
-	debugSQL   bool
-	resultsDir string
+	lang     string
+	debugSQL bool
+	debug    bool
+	logDir   string

+	resultsDir       string
 	refreshCve       bool
 	cvedbtype        string
 	cvedbpath        string
 	cveDictionaryURL string
+
+	pipe bool
 }

 // Name return subcommand name
@@ -55,9 +59,12 @@ func (*TuiCmd) Usage() string {
 		[-cvedb-type=sqlite3|mysql]
 		[-cvedb-path=/path/to/cve.sqlite3]
 		[-cvedb-url=http://127.0.0.1:1323 or mysql connection string]
-		[-results-dir=/path/to/results]
 		[-refresh-cve]
+		[-results-dir=/path/to/results]
+		[-log-dir=/path/to/log]
+		[-debug]
 		[-debug-sql]
+		[-pipe]

 `
 }
@@ -66,6 +73,10 @@ func (*TuiCmd) Usage() string {
 func (p *TuiCmd) SetFlags(f *flag.FlagSet) {
 	//  f.StringVar(&p.lang, "lang", "en", "[en|ja]")
 	f.BoolVar(&p.debugSQL, "debug-sql", false, "debug SQL")
+	f.BoolVar(&p.debug, "debug", false, "debug mode")
+
+	defaultLogDir := util.GetDefaultLogDir()
+	f.StringVar(&p.logDir, "log-dir", defaultLogDir, "/path/to/log")

 	wd, _ := os.Getwd()
 	defaultResultsDir := filepath.Join(wd, "results")
@@ -95,22 +106,36 @@ func (p *TuiCmd) SetFlags(f *flag.FlagSet) {
 		"cvedb-url",
 		"",
 		"http://cve-dictionary.com:8080 or mysql connection string")
+
+	f.BoolVar(
+		&p.pipe,
+		"pipe",
+		false,
+		"Use stdin via PIPE")
 }

 // Execute execute
 func (p *TuiCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
 	c.Conf.Lang = "en"
+
+	// Setup Logger
+	c.Conf.Debug = p.debug
 	c.Conf.DebugSQL = p.debugSQL
+	c.Conf.LogDir = p.logDir
+	util.Log = util.NewCustomLogger(c.ServerInfo{})
+	log := util.Log
+
 	c.Conf.ResultsDir = p.resultsDir
 	c.Conf.CveDBType = p.cvedbtype
 	c.Conf.CveDBPath = p.cvedbpath
-	c.Conf.CveDictionaryURL = p.cveDictionaryURL
+	c.Conf.CveDBURL = p.cveDictionaryURL

-	log.Info("Validating Config...")
+	log.Info("Validating config...")
 	if !c.Conf.ValidateOnTui() {
 		return subcommands.ExitUsageError
 	}

+	c.Conf.Pipe = p.pipe
 	jsonDir, err := jsonDir(f.Args())
 	if err != nil {
 		log.Errorf("Failed to read json dir under results: %s", err)
@@ -140,11 +165,11 @@ func (p *TuiCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) s
 				return subcommands.ExitFailure
 			}

-			if err := overwriteJSONFile(jsonDir, filled); err != nil {
+			if err := overwriteJSONFile(jsonDir, *filled); err != nil {
 				log.Errorf("Failed to write JSON: %s", err)
 				return subcommands.ExitFailure
 			}
-			results = append(results, filled)
+			results = append(results, *filled)
 		} else {
 			results = append(results, r)
 		}
--- a/commands/util.go
+++ b/commands/util.go
@@ -26,6 +26,7 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"time"

 	c "github.com/future-architect/vuls/config"
 	"github.com/future-architect/vuls/cveapi"
@@ -74,7 +75,7 @@ func lsValidJSONDirs() (dirs jsonDirs, err error) {

 // jsonDir returns
 // If there is an arg, check if it is a valid format and return the corresponding path under results.
-// If passed via PIPE (such as history subcommand), return that path.
+// If arg passed via PIPE (such as history subcommand), return that path.
 // Otherwise, returns the path of the latest directory
 func jsonDir(args []string) (string, error) {
 	var err error
@@ -98,8 +99,7 @@ func jsonDir(args []string) (string, error) {
 	}

 	// PIPE
-	stat, _ := os.Stdin.Stat()
-	if (stat.Mode() & os.ModeCharDevice) == 0 {
+	if c.Conf.Pipe {
 		bytes, err := ioutil.ReadAll(os.Stdin)
 		if err != nil {
 			return "", fmt.Errorf("Failed to read stdin: %s", err)
@@ -122,6 +122,19 @@ func jsonDir(args []string) (string, error) {
 	return dirs[0], nil
 }

+// loadOneServerScanResult read JSON data of one server
+func loadOneServerScanResult(jsonFile string) (result models.ScanResult, err error) {
+	var data []byte
+	if data, err = ioutil.ReadFile(jsonFile); err != nil {
+		err = fmt.Errorf("Failed to read %s: %s", jsonFile, err)
+		return
+	}
+	if json.Unmarshal(data, &result) != nil {
+		err = fmt.Errorf("Failed to parse %s: %s", jsonFile, err)
+	}
+	return
+}
+
 // loadOneScanHistory read JSON data
 func loadOneScanHistory(jsonDir string) (scanHistory models.ScanHistory, err error) {
 	var results []models.ScanResult
@@ -131,20 +144,16 @@ func loadOneScanHistory(jsonDir string) (scanHistory models.ScanHistory, err err
 		return
 	}
 	for _, f := range files {
-		if filepath.Ext(f.Name()) != ".json" {
+		if filepath.Ext(f.Name()) != ".json" || strings.HasSuffix(f.Name(), "_diff.json") {
 			continue
 		}
+
 		var r models.ScanResult
-		var data []byte
 		path := filepath.Join(jsonDir, f.Name())
-		if data, err = ioutil.ReadFile(path); err != nil {
-			err = fmt.Errorf("Failed to read %s: %s", path, err)
-			return
-		}
-		if json.Unmarshal(data, &r) != nil {
-			err = fmt.Errorf("Failed to parse %s: %s", path, err)
+		if r, err = loadOneServerScanResult(path); err != nil {
 			return
 		}
+
 		results = append(results, r)
 	}
 	if len(results) == 0 {
@@ -158,33 +167,128 @@ func loadOneScanHistory(jsonDir string) (scanHistory models.ScanHistory, err err
 	return
 }

-func fillCveInfoFromCveDB(r models.ScanResult) (filled models.ScanResult, err error) {
+func fillCveInfoFromCveDB(r models.ScanResult) (*models.ScanResult, error) {
+	var err error
+	var vs []models.VulnInfo
+
 	sInfo := c.Conf.Servers[r.ServerName]
-	vs, err := scanVulnByCpeNames(sInfo.CpeNames, r.ScannedCves)
+	vs, err = scanVulnByCpeNames(sInfo.CpeNames, r.ScannedCves)
 	if err != nil {
-		return
+		return nil, err
 	}
 	r.ScannedCves = vs
-	filled, err = r.FillCveDetail()
-	if err != nil {
+	return r.FillCveDetail()
+}
+
+func loadPreviousScanHistory(current models.ScanHistory) (previous models.ScanHistory, err error) {
+	var dirs jsonDirs
+	if dirs, err = lsValidJSONDirs(); err != nil {
 		return
 	}
+
+	for _, result := range current.ScanResults {
+		for _, dir := range dirs[1:] {
+			var r models.ScanResult
+			path := filepath.Join(dir, result.ServerName+".json")
+			if r, err = loadOneServerScanResult(path); err != nil {
+				continue
+			}
+			if r.Family == result.Family && r.Release == result.Release {
+				previous.ScanResults = append(previous.ScanResults, r)
+				break
+			}
+		}
+	}
+	return previous, nil
+}
+
+func diff(currentHistory, previousHistory models.ScanHistory) (diffHistory models.ScanHistory, err error) {
+	for _, currentResult := range currentHistory.ScanResults {
+		found := false
+		var previousResult models.ScanResult
+		for _, previousResult = range previousHistory.ScanResults {
+			if currentResult.ServerName == previousResult.ServerName {
+				found = true
+				break
+			}
+		}
+
+		if found {
+			currentResult.ScannedCves = getNewCves(previousResult, currentResult)
+
+			currentResult.KnownCves = []models.CveInfo{}
+			currentResult.UnknownCves = []models.CveInfo{}
+
+			currentResult.Packages = models.PackageInfoList{}
+			for _, s := range currentResult.ScannedCves {
+				currentResult.Packages = append(currentResult.Packages, s.Packages...)
+			}
+			currentResult.Packages = currentResult.Packages.UniqByName()
+		}
+
+		diffHistory.ScanResults = append(diffHistory.ScanResults, currentResult)
+	}
+	return diffHistory, err
+}
+
+func getNewCves(previousResult, currentResult models.ScanResult) (newVulninfos []models.VulnInfo) {
+	previousCveIDsSet := map[string]bool{}
+	for _, previousVulnInfo := range previousResult.ScannedCves {
+		previousCveIDsSet[previousVulnInfo.CveID] = true
+	}
+
+	for _, v := range currentResult.ScannedCves {
+		if previousCveIDsSet[v.CveID] {
+			if isCveInfoUpdated(currentResult, previousResult, v.CveID) {
+				newVulninfos = append(newVulninfos, v)
+			}
+		} else {
+			newVulninfos = append(newVulninfos, v)
+		}
+	}
 	return
 }

+func isCveInfoUpdated(currentResult, previousResult models.ScanResult, CveID string) bool {
+	type lastModified struct {
+		Nvd time.Time
+		Jvn time.Time
+	}
+
+	previousModifies := lastModified{}
+	for _, c := range previousResult.KnownCves {
+		if CveID == c.CveID {
+			previousModifies.Nvd = c.CveDetail.Nvd.LastModifiedDate
+			previousModifies.Jvn = c.CveDetail.Jvn.LastModifiedDate
+		}
+	}
+
+	currentModifies := lastModified{}
+	for _, c := range currentResult.KnownCves {
+		if CveID == c.CveDetail.CveID {
+			currentModifies.Nvd = c.CveDetail.Nvd.LastModifiedDate
+			currentModifies.Jvn = c.CveDetail.Jvn.LastModifiedDate
+		}
+	}
+	return !currentModifies.Nvd.Equal(previousModifies.Nvd) ||
+		!currentModifies.Jvn.Equal(previousModifies.Jvn)
+}
+
 func overwriteJSONFile(dir string, r models.ScanResult) error {
 	before := c.Conf.FormatJSON
+	beforeDiff := c.Conf.Diff
 	c.Conf.FormatJSON = true
+	c.Conf.Diff = false
 	w := report.LocalFileWriter{CurrentDir: dir}
 	if err := w.Write(r); err != nil {
 		return fmt.Errorf("Failed to write summary report: %s", err)
 	}
 	c.Conf.FormatJSON = before
+	c.Conf.Diff = beforeDiff
 	return nil
 }

-func scanVulnByCpeNames(cpeNames []string, scannedVulns []models.VulnInfo) ([]models.VulnInfo,
-	error) {
+func scanVulnByCpeNames(cpeNames []string, scannedVulns []models.VulnInfo) ([]models.VulnInfo, error) {
 	// To remove duplicate
 	set := map[string]models.VulnInfo{}
 	for _, v := range scannedVulns {
@@ -201,12 +305,16 @@ func scanVulnByCpeNames(cpeNames []string, scannedVulns []models.VulnInfo) ([]mo
 				names := val.CpeNames
 				names = util.AppendIfMissing(names, name)
 				val.CpeNames = names
+				val.Confidence = models.CpeNameMatch
 				set[detail.CveID] = val
 			} else {
-				set[detail.CveID] = models.VulnInfo{
-					CveID:    detail.CveID,
-					CpeNames: []string{name},
+				v := models.VulnInfo{
+					CveID:      detail.CveID,
+					CpeNames:   []string{name},
+					Confidence: models.CpeNameMatch,
 				}
+				v.NilSliceToEmpty()
+				set[detail.CveID] = v
 			}
 		}
 	}
--- a/commands/util_test.go
+++ b/commands/util_test.go
@@ -0,0 +1,294 @@
+/* Vuls - Vulnerability Scanner
+Copyright (C) 2016  Future Architect, Inc. Japan.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package commands
+
+import (
+	"testing"
+	"time"
+
+	"reflect"
+
+	"github.com/future-architect/vuls/models"
+	"github.com/k0kubun/pp"
+	cve "github.com/kotakanbe/go-cve-dictionary/models"
+)
+
+func TestDiff(t *testing.T) {
+	atCurrent, _ := time.Parse("2006-01-02", "2014-12-31")
+	atPrevious, _ := time.Parse("2006-01-02", "2014-11-31")
+	var tests = []struct {
+		inCurrent  models.ScanHistory
+		inPrevious models.ScanHistory
+		out        models.ScanResult
+	}{
+		{
+			models.ScanHistory{
+				ScanResults: models.ScanResults{
+					{
+						ScannedAt:  atCurrent,
+						ServerName: "u16",
+						Family:     "ubuntu",
+						Release:    "16.04",
+						ScannedCves: []models.VulnInfo{
+							{
+								CveID: "CVE-2012-6702",
+								Packages: models.PackageInfoList{
+									{
+										Name:       "libexpat1",
+										Version:    "2.1.0-7",
+										Release:    "",
+										NewVersion: "2.1.0-7ubuntu0.16.04.2",
+										NewRelease: "",
+										Repository: "",
+									},
+								},
+								DistroAdvisories: []models.DistroAdvisory{},
+								CpeNames:         []string{},
+							},
+							{
+								CveID: "CVE-2014-9761",
+								Packages: models.PackageInfoList{
+									{
+										Name:       "libc-bin",
+										Version:    "2.21-0ubuntu5",
+										Release:    "",
+										NewVersion: "2.23-0ubuntu5",
+										NewRelease: "",
+										Repository: "",
+									},
+								},
+								DistroAdvisories: []models.DistroAdvisory{},
+								CpeNames:         []string{},
+							},
+						},
+						KnownCves:   []models.CveInfo{},
+						UnknownCves: []models.CveInfo{},
+						IgnoredCves: []models.CveInfo{},
+
+						Packages: models.PackageInfoList{},
+
+						Errors:   []string{},
+						Optional: [][]interface{}{},
+					},
+				},
+			},
+			models.ScanHistory{
+				ScanResults: models.ScanResults{
+					{
+						ScannedAt:  atPrevious,
+						ServerName: "u16",
+						Family:     "ubuntu",
+						Release:    "16.04",
+						ScannedCves: []models.VulnInfo{
+							{
+								CveID: "CVE-2012-6702",
+								Packages: models.PackageInfoList{
+									{
+										Name:       "libexpat1",
+										Version:    "2.1.0-7",
+										Release:    "",
+										NewVersion: "2.1.0-7ubuntu0.16.04.2",
+										NewRelease: "",
+										Repository: "",
+									},
+								},
+								DistroAdvisories: []models.DistroAdvisory{},
+								CpeNames:         []string{},
+							},
+							{
+								CveID: "CVE-2014-9761",
+								Packages: models.PackageInfoList{
+									{
+										Name:       "libc-bin",
+										Version:    "2.21-0ubuntu5",
+										Release:    "",
+										NewVersion: "2.23-0ubuntu5",
+										NewRelease: "",
+										Repository: "",
+									},
+								},
+								DistroAdvisories: []models.DistroAdvisory{},
+								CpeNames:         []string{},
+							},
+						},
+						KnownCves:   []models.CveInfo{},
+						UnknownCves: []models.CveInfo{},
+						IgnoredCves: []models.CveInfo{},
+
+						Packages: models.PackageInfoList{},
+
+						Errors:   []string{},
+						Optional: [][]interface{}{},
+					},
+				},
+			},
+			models.ScanResult{
+				ScannedAt:   atCurrent,
+				ServerName:  "u16",
+				Family:      "ubuntu",
+				Release:     "16.04",
+				KnownCves:   []models.CveInfo{},
+				UnknownCves: []models.CveInfo{},
+				IgnoredCves: []models.CveInfo{},
+
+				// Packages: models.PackageInfoList{},
+
+				Errors:   []string{},
+				Optional: [][]interface{}{},
+			},
+		},
+		{
+			models.ScanHistory{
+				ScanResults: models.ScanResults{
+					{
+						ScannedAt:  atCurrent,
+						ServerName: "u16",
+						Family:     "ubuntu",
+						Release:    "16.04",
+						ScannedCves: []models.VulnInfo{
+							{
+								CveID: "CVE-2016-6662",
+								Packages: models.PackageInfoList{
+									{
+										Name:       "mysql-libs",
+										Version:    "5.1.73",
+										Release:    "7.el6",
+										NewVersion: "5.1.73",
+										NewRelease: "8.el6_8",
+										Repository: "",
+									},
+								},
+								DistroAdvisories: []models.DistroAdvisory{},
+								CpeNames:         []string{},
+							},
+						},
+						KnownCves: []models.CveInfo{
+							{
+								CveDetail: cve.CveDetail{
+									CveID: "CVE-2016-6662",
+									Nvd: cve.Nvd{
+										LastModifiedDate: time.Date(2016, 1, 1, 0, 0, 0, 0, time.Local),
+									},
+								},
+								VulnInfo: models.VulnInfo{
+									CveID: "CVE-2016-6662",
+								},
+							},
+						},
+						UnknownCves: []models.CveInfo{},
+						IgnoredCves: []models.CveInfo{},
+					},
+				},
+			},
+			models.ScanHistory{
+				ScanResults: models.ScanResults{
+					{
+						ScannedAt:  atPrevious,
+						ServerName: "u16",
+						Family:     "ubuntu",
+						Release:    "16.04",
+						ScannedCves: []models.VulnInfo{
+							{
+								CveID: "CVE-2016-6662",
+								Packages: models.PackageInfoList{
+									{
+										Name:       "mysql-libs",
+										Version:    "5.1.73",
+										Release:    "7.el6",
+										NewVersion: "5.1.73",
+										NewRelease: "8.el6_8",
+										Repository: "",
+									},
+								},
+								DistroAdvisories: []models.DistroAdvisory{},
+								CpeNames:         []string{},
+							},
+						},
+						KnownCves: []models.CveInfo{
+							{
+								CveDetail: cve.CveDetail{
+									CveID: "CVE-2016-6662",
+									Nvd: cve.Nvd{
+										LastModifiedDate: time.Date(2017, 3, 15, 13, 40, 57, 0, time.Local),
+									},
+								},
+								VulnInfo: models.VulnInfo{
+									CveID: "CVE-2016-6662",
+								},
+							},
+						},
+						UnknownCves: []models.CveInfo{},
+						IgnoredCves: []models.CveInfo{},
+					},
+				},
+			},
+			models.ScanResult{
+				ScannedAt:  atCurrent,
+				ServerName: "u16",
+				Family:     "ubuntu",
+				Release:    "16.04",
+				ScannedCves: []models.VulnInfo{
+					{
+						CveID: "CVE-2016-6662",
+						Packages: models.PackageInfoList{
+							{
+								Name:       "mysql-libs",
+								Version:    "5.1.73",
+								Release:    "7.el6",
+								NewVersion: "5.1.73",
+								NewRelease: "8.el6_8",
+								Repository: "",
+							},
+						},
+						DistroAdvisories: []models.DistroAdvisory{},
+						CpeNames:         []string{},
+					},
+				},
+				KnownCves:   []models.CveInfo{},
+				UnknownCves: []models.CveInfo{},
+				IgnoredCves: []models.CveInfo{},
+				Packages: models.PackageInfoList{
+					models.PackageInfo{
+						Name:       "mysql-libs",
+						Version:    "5.1.73",
+						Release:    "7.el6",
+						NewVersion: "5.1.73",
+						NewRelease: "8.el6_8",
+						Repository: "",
+						Changelog: models.Changelog{
+							Contents: "",
+							Method:   "",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	var s models.ScanHistory
+	for _, tt := range tests {
+		s, _ = diff(tt.inCurrent, tt.inPrevious)
+		for _, actual := range s.ScanResults {
+			if !reflect.DeepEqual(actual, tt.out) {
+				h := pp.Sprint(actual)
+				x := pp.Sprint(tt.out)
+				t.Errorf("diff result : \n %s \n output result : \n %s", h, x)
+			}
+		}
+	}
+}
--- a/config/config.go
+++ b/config/config.go
@@ -20,6 +20,7 @@ package config
 import (
 	"fmt"
 	"runtime"
+	"strconv"
 	"strings"

 	log "github.com/Sirupsen/logrus"
@@ -35,29 +36,30 @@ type Config struct {
 	DebugSQL bool
 	Lang     string

-	EMail   smtpConf
+	EMail   SMTPConf
 	Slack   SlackConf
 	Default ServerInfo
 	Servers map[string]ServerInfo

-	CveDictionaryURL string `valid:"url"`
-
 	CvssScoreOver      float64
 	IgnoreUnscoredCves bool

-	AssumeYes      bool
 	SSHExternal    bool
 	ContainersOnly bool
 	SkipBroken     bool

-	HTTPProxy   string `valid:"url"`
-	ResultsDir  string
+	HTTPProxy  string `valid:"url"`
+	LogDir     string
+	ResultsDir string
+
 	CveDBType   string
 	CveDBPath   string
+	CveDBURL    string
 	CacheDBPath string

 	FormatXML         bool
 	FormatJSON        bool
+	FormatOneEMail    bool
 	FormatOneLineText bool
 	FormatShortText   bool
 	FormatFullText    bool
@@ -71,6 +73,9 @@ type Config struct {
 	AzureAccount   string
 	AzureKey       string
 	AzureContainer string
+
+	Pipe bool
+	Diff bool
 }

 // ValidateOnConfigtest validates
@@ -150,16 +155,21 @@ func (c Config) ValidateOnReport() bool {
 		}
 	}

-	if c.CveDBType != "sqlite3" && c.CveDBType != "mysql" {
-		errs = append(errs, fmt.Errorf(
-			"CVE DB type must be either 'sqlite3' or 'mysql'.  -cve-dictionary-dbtype: %s", c.CveDBType))
-	}
-
-	if c.CveDBType == "sqlite3" {
+	switch c.CveDBType {
+	case "sqlite3":
 		if ok, _ := valid.IsFilePath(c.CveDBPath); !ok {
 			errs = append(errs, fmt.Errorf(
-				"SQLite3 DB(CVE-Dictionary) path must be a *Absolute* file path. -cve-dictionary-dbpath: %s", c.CveDBPath))
+				"SQLite3 DB(CVE-Dictionary) path must be a *Absolute* file path. -cvedb-path: %s",
+				c.CveDBPath))
 		}
+	case "mysql":
+		if c.CveDBURL == "" {
+			errs = append(errs, fmt.Errorf(
+				`MySQL connection string is needed. -cvedb-url="user:pass@tcp(localhost:3306)/dbname"`))
+		}
+	default:
+		errs = append(errs, fmt.Errorf(
+			"CVE DB type must be either 'sqlite3' or 'mysql'.  -cvedb-type: %s", c.CveDBType))
 	}

 	_, err := valid.ValidateStruct(c)
@@ -212,8 +222,8 @@ func (c Config) ValidateOnTui() bool {
 	return len(errs) == 0
 }

-// smtpConf is smtp config
-type smtpConf struct {
+// SMTPConf is smtp config
+type SMTPConf struct {
 	SMTPAddr string
 	SMTPPort string `valid:"port"`

@@ -240,7 +250,7 @@ func checkEmails(emails []string) (errs []error) {
 }

 // Validate SMTP configuration
-func (c *smtpConf) Validate() (errs []error) {
+func (c *SMTPConf) Validate() (errs []error) {

 	if !c.UseThisTime {
 		return
@@ -334,7 +344,7 @@ type ServerInfo struct {
 	DependencyCheckXMLPath string

 	// Container Names or IDs
-	Containers []string
+	Containers Containers

 	IgnoreCves []string

@@ -369,6 +379,16 @@ func (l Distro) String() string {
 	return fmt.Sprintf("%s %s", l.Family, l.Release)
 }

+// MajorVersion returns Major version
+func (l Distro) MajorVersion() (ver int, err error) {
+	if 0 < len(l.Release) {
+		ver, err = strconv.Atoi(strings.Split(l.Release, ".")[0])
+	} else {
+		err = fmt.Errorf("Release is empty")
+	}
+	return
+}
+
 // IsContainer returns whether this ServerInfo is about container
 func (s ServerInfo) IsContainer() bool {
 	return 0 < len(s.Container.ContainerID)
@@ -379,9 +399,16 @@ func (s *ServerInfo) SetContainer(d Container) {
 	s.Container = d
 }

+// Containers has Containers information.
+type Containers struct {
+	Type     string
+	Includes []string
+	Excludes []string
+}
+
 // Container has Container information.
 type Container struct {
 	ContainerID string
 	Name        string
-	Type        string
+	Image       string
 }
--- a/config/tomlloader.go
+++ b/config/tomlloader.go
@@ -62,15 +62,6 @@ func (c TOMLLoader) Load(pathToToml, keyPass string) error {

 		s := ServerInfo{ServerName: name}

-		switch {
-		case v.User != "":
-			s.User = v.User
-		case d.User != "":
-			s.User = d.User
-		default:
-			return fmt.Errorf("%s is invalid. User is empty", name)
-		}
-
 		s.Host = v.Host
 		if len(s.Host) == 0 {
 			return fmt.Errorf("%s is invalid. host is empty", name)
@@ -85,6 +76,17 @@ func (c TOMLLoader) Load(pathToToml, keyPass string) error {
 			s.Port = "22"
 		}

+		switch {
+		case v.User != "":
+			s.User = v.User
+		case d.User != "":
+			s.User = d.User
+		default:
+			if s.Port != "local" {
+				return fmt.Errorf("%s is invalid. User is empty", name)
+			}
+		}
+
 		s.KeyPath = v.KeyPath
 		if len(s.KeyPath) == 0 {
 			s.KeyPath = d.KeyPath
@@ -125,7 +127,7 @@ func (c TOMLLoader) Load(pathToToml, keyPass string) error {
 		}

 		s.Containers = v.Containers
-		if len(s.Containers) == 0 {
+		if len(s.Containers.Includes) == 0 {
 			s.Containers = d.Containers
 		}

--- a/cveapi/cve_client.go
+++ b/cveapi/cve_client.go
@@ -27,7 +27,6 @@ import (
 	"github.com/cenkalti/backoff"
 	"github.com/parnurzeal/gorequest"

-	log "github.com/Sirupsen/logrus"
 	"github.com/future-architect/vuls/config"
 	"github.com/future-architect/vuls/util"
 	cveconfig "github.com/kotakanbe/go-cve-dictionary/config"
@@ -44,12 +43,12 @@ type cvedictClient struct {
 }

 func (api *cvedictClient) initialize() {
-	api.baseURL = config.Conf.CveDictionaryURL
+	api.baseURL = config.Conf.CveDBURL
 }

 func (api cvedictClient) CheckHealth() (ok bool, err error) {
-	if config.Conf.CveDictionaryURL == "" {
-		log.Debugf("get cve-dictionary from %s", config.Conf.CveDBType)
+	if config.Conf.CveDBURL == "" || config.Conf.CveDBType == "mysql" {
+		util.Log.Debugf("get cve-dictionary from %s", config.Conf.CveDBType)
 		return true, nil
 	}

@@ -71,11 +70,12 @@ type response struct {
 }

 func (api cvedictClient) FetchCveDetails(cveIDs []string) (cveDetails cve.CveDetails, err error) {
-	if config.Conf.CveDictionaryURL == "" {
+	switch config.Conf.CveDBType {
+	case "sqlite3", "mysql":
 		return api.FetchCveDetailsFromCveDB(cveIDs)
 	}

-	api.baseURL = config.Conf.CveDictionaryURL
+	api.baseURL = config.Conf.CveDBURL
 	reqChan := make(chan string, len(cveIDs))
 	resChan := make(chan response, len(cveIDs))
 	errChan := make(chan error, len(cveIDs))
@@ -99,7 +99,7 @@ func (api cvedictClient) FetchCveDetails(cveIDs []string) (cveDetails cve.CveDet
 				if err != nil {
 					errChan <- err
 				} else {
-					log.Debugf("HTTP Request to %s", url)
+					util.Log.Debugf("HTTP Request to %s", url)
 					api.httpGet(cveID, url, resChan, errChan)
 				}
 			}
@@ -134,12 +134,12 @@ func (api cvedictClient) FetchCveDetails(cveIDs []string) (cveDetails cve.CveDet
 }

 func (api cvedictClient) FetchCveDetailsFromCveDB(cveIDs []string) (cveDetails cve.CveDetails, err error) {
-	log.Debugf("open cve-dictionary db (%s)", config.Conf.CveDBType)
+	util.Log.Debugf("open cve-dictionary db (%s)", config.Conf.CveDBType)
 	cveconfig.Conf.DBType = config.Conf.CveDBType
 	if config.Conf.CveDBType == "sqlite3" {
 		cveconfig.Conf.DBPath = config.Conf.CveDBPath
 	} else {
-		cveconfig.Conf.DBPath = config.Conf.CveDictionaryURL
+		cveconfig.Conf.DBPath = config.Conf.CveDBURL
 	}
 	cveconfig.Conf.DebugSQL = config.Conf.DebugSQL
 	if err := cvedb.OpenDB(); err != nil {
@@ -175,7 +175,7 @@ func (api cvedictClient) httpGet(key, url string, resChan chan<- response, errCh
 		return nil
 	}
 	notify := func(err error, t time.Duration) {
-		log.Warnf("Failed to HTTP GET. retrying in %s seconds. err: %s", t, err)
+		util.Log.Warnf("Failed to HTTP GET. retrying in %s seconds. err: %s", t, err)
 	}
 	err := backoff.RetryNotify(f, backoff.NewExponentialBackOff(), notify)
 	if err != nil {
@@ -197,18 +197,19 @@ type responseGetCveDetailByCpeName struct {
 }

 func (api cvedictClient) FetchCveDetailsByCpeName(cpeName string) ([]cve.CveDetail, error) {
-	if config.Conf.CveDictionaryURL == "" {
+	switch config.Conf.CveDBType {
+	case "sqlite3", "mysql":
 		return api.FetchCveDetailsByCpeNameFromDB(cpeName)
 	}

-	api.baseURL = config.Conf.CveDictionaryURL
+	api.baseURL = config.Conf.CveDBURL
 	url, err := util.URLPathJoin(api.baseURL, "cpes")
 	if err != nil {
 		return []cve.CveDetail{}, err
 	}

 	query := map[string]string{"name": cpeName}
-	log.Debugf("HTTP Request to %s, query: %#v", url, query)
+	util.Log.Debugf("HTTP Request to %s, query: %#v", url, query)
 	return api.httpPost(cpeName, url, query)
 }

@@ -228,7 +229,7 @@ func (api cvedictClient) httpPost(key, url string, query map[string]string) ([]c
 		return nil
 	}
 	notify := func(err error, t time.Duration) {
-		log.Warnf("Failed to HTTP POST. retrying in %s seconds. err: %s", t, err)
+		util.Log.Warnf("Failed to HTTP POST. retrying in %s seconds. err: %s", t, err)
 	}
 	err := backoff.RetryNotify(f, backoff.NewExponentialBackOff(), notify)
 	if err != nil {
@@ -244,9 +245,13 @@ func (api cvedictClient) httpPost(key, url string, query map[string]string) ([]c
 }

 func (api cvedictClient) FetchCveDetailsByCpeNameFromDB(cpeName string) ([]cve.CveDetail, error) {
-	log.Debugf("open cve-dictionary db (%s)", config.Conf.CveDBType)
+	util.Log.Debugf("open cve-dictionary db (%s)", config.Conf.CveDBType)
 	cveconfig.Conf.DBType = config.Conf.CveDBType
-	cveconfig.Conf.DBPath = config.Conf.CveDBPath
+	if config.Conf.CveDBType == "sqlite3" {
+		cveconfig.Conf.DBPath = config.Conf.CveDBPath
+	} else {
+		cveconfig.Conf.DBPath = config.Conf.CveDBURL
+	}
 	cveconfig.Conf.DebugSQL = config.Conf.DebugSQL

 	if err := cvedb.OpenDB(); err != nil {
--- a/glide.lock
+++ b/glide.lock
@@ -1,5 +1,5 @@
 hash: c3167d83e68562cd7ef73f138ce60cb9e60b72b50394e8615388d1f3ba9fbef2
-updated: 2017-01-02T09:37:09.437363123+09:00
+updated: 2017-02-08T11:59:59.893522816+09:00
 imports:
 - name: github.com/asaskevich/govalidator
  version: 7b3beb6df3c42abd3509abfc3bcacc0fbfb7c877
@@ -70,7 +70,7 @@ imports:
 - name: github.com/k0kubun/pp
  version: f5dce6ed0ccf6c350f1679964ff6b61f3d6d2033
 - name: github.com/kotakanbe/go-cve-dictionary
-  version: 7eb1f1a2e7e436177570bf234e21c2ed9489d3fb
+  version: bbfdd41e7785a9b7163b5109b10ac2dea8f36d84
  subpackages:
  - config
  - db
--- a/img/vuls-architecture-localscan.graphml
+++ b/img/vuls-architecture-localscan.graphml
--- a/img/vuls-architecture-localscan.png
+++ b/img/vuls-architecture-localscan.png
--- a/img/vuls-architecture.graphml
+++ b/img/vuls-architecture.graphml
@@ -471,7 +471,7 @@ ALAS (Amazon)<y:LabelModel>
              <y:Geometry height="201.49428304036473" width="161.48764324188164" x="964.6223485469814" y="296.7320760091144"/>
              <y:Fill color="#F5F5F5" transparent="false"/>
              <y:BorderStyle color="#000000" type="dashed" width="1.0"/>
-              <y:NodeLabel alignment="right" autoSizePolicy="node_width" backgroundColor="#EBEBEB" borderDistance="0.0" fontFamily="Dialog" fontSize="15" fontStyle="plain" hasLineColor="false" height="21.666015625" modelName="internal" modelPosition="t" textColor="#000000" visible="true" width="161.48764324188164" x="0.0" y="0.0">Docker Containers</y:NodeLabel>
+              <y:NodeLabel alignment="right" autoSizePolicy="node_width" backgroundColor="#EBEBEB" borderDistance="0.0" fontFamily="Dialog" fontSize="15" fontStyle="plain" hasLineColor="false" height="21.666015625" modelName="internal" modelPosition="t" textColor="#000000" visible="true" width="161.48764324188164" x="0.0" y="0.0">Docker/LXD</y:NodeLabel>
              <y:Shape type="roundrectangle"/>
              <y:State closed="false" closedHeight="50.0" closedWidth="50.0" innerGraphDisplayEnabled="false"/>
              <y:Insets bottom="15" bottomF="15.0" left="15" leftF="15.0" right="15" rightF="15.0" top="15" topF="15.0"/>
@@ -497,7 +497,7 @@ ALAS (Amazon)<y:LabelModel>
              <y:Geometry height="50.0" width="85.0" x="1011.6223485469814" y="433.22635904947913"/>
              <y:Fill color="#C0C0C0" transparent="false"/>
              <y:BorderStyle color="#000000" type="line" width="1.0"/>
-              <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="71.91015625" x="6.544921875" y="15.93359375">DockerHost<y:LabelModel>
+              <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="30.794921875" x="27.1025390625" y="15.93359375">Host<y:LabelModel>
                  <y:SmartNodeLabelModel distance="4.0"/>
                </y:LabelModel>
                <y:ModelParameter>
@@ -514,8 +514,7 @@ ALAS (Amazon)<y:LabelModel>
              <y:Geometry height="50.0" width="85.0" x="1011.6223485469814" y="333.3980916341144"/>
              <y:Fill color="#C0C0C0" transparent="false"/>
              <y:BorderStyle color="#000000" type="line" width="1.0"/>
-              <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="32.265625" modelName="custom" textColor="#000000" visible="true" width="60.748046875" x="12.1259765625" y="8.8671875">Docker
-Container<y:LabelModel>
+              <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="60.748046875" x="12.1259765625" y="15.93359375">Container<y:LabelModel>
                  <y:SmartNodeLabelModel distance="4.0"/>
                </y:LabelModel>
                <y:ModelParameter>
@@ -676,7 +675,6 @@ Container<y:LabelModel>
      </graph>
    </node>
    <node id="n12">
-      <data key="d5"/>
      <data key="d6">
        <y:ImageNode>
          <y:Geometry height="116.06321112515802" width="97.39570164348925" x="445.4298356510746" y="571.968394437421"/>
@@ -706,13 +704,12 @@ BLOB<y:LabelModel>
      </data>
    </node>
    <node id="n14">
-      <data key="d5"/>
      <data key="d6">
        <y:GenericNode configuration="com.yworks.flowchart.card">
          <y:Geometry height="40.0" width="39.02970922882429" x="390.97029077117577" y="490.0"/>
          <y:Fill color="#E8EEF7" color2="#B7C9E3" transparent="false"/>
          <y:BorderStyle color="#000000" type="line" width="1.0"/>
-          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="29.828125" x="4.600792114412172" y="10.93359375">.xml<y:LabelModel>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="29.828125" x="4.6007921144121156" y="10.93359375">.xml<y:LabelModel>
              <y:SmartNodeLabelModel distance="4.0"/>
            </y:LabelModel>
            <y:ModelParameter>
@@ -723,13 +720,12 @@ BLOB<y:LabelModel>
      </data>
    </node>
    <node id="n15">
-      <data key="d5"/>
      <data key="d6">
        <y:GenericNode configuration="com.yworks.flowchart.card">
          <y:Geometry height="40.0" width="39.02970922882429" x="389.4630622503162" y="587.4087217193426"/>
          <y:Fill color="#E8EEF7" color2="#B7C9E3" transparent="false"/>
          <y:BorderStyle color="#000000" type="line" width="1.0"/>
-          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="24.1328125" x="7.4484483644121156" y="10.93359375">.txt<y:LabelModel>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="24.1328125" x="7.448448364412172" y="10.93359375">.txt<y:LabelModel>
              <y:SmartNodeLabelModel distance="4.0"/>
            </y:LabelModel>
            <y:ModelParameter>
@@ -740,13 +736,12 @@ BLOB<y:LabelModel>
      </data>
    </node>
    <node id="n16">
-      <data key="d5"/>
      <data key="d6">
        <y:GenericNode configuration="com.yworks.flowchart.card">
          <y:Geometry height="40.0" width="39.02970922882429" x="389.9353177243998" y="538.8895352718077"/>
          <y:Fill color="#E8EEF7" color2="#B7C9E3" transparent="false"/>
          <y:BorderStyle color="#000000" type="line" width="1.0"/>
-          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="32.3828125" x="3.3234483644121156" y="10.93359375">.json<y:LabelModel>
+          <y:NodeLabel alignment="center" autoSizePolicy="content" fontFamily="Dialog" fontSize="12" fontStyle="plain" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" textColor="#000000" visible="true" width="32.3828125" x="3.3234483644121724" y="10.93359375">.json<y:LabelModel>
              <y:SmartNodeLabelModel distance="4.0"/>
            </y:LabelModel>
            <y:ModelParameter>
@@ -757,7 +752,6 @@ BLOB<y:LabelModel>
      </data>
    </node>
    <node id="n17">
-      <data key="d5"/>
      <data key="d6">
        <y:GenericNode configuration="com.yworks.flowchart.card">
          <y:Geometry height="40.0" width="39.02970922882429" x="389.7450294816688" y="640.0"/>
@@ -888,11 +882,12 @@ Vulnerability data<y:LabelModel>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
          <y:LineStyle color="#000000" type="line" width="1.0"/>
          <y:Arrows source="none" target="standard"/>
-          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Dialog" fontSize="12" fontStyle="bold" hasBackgroundColor="false" hasLineColor="false" height="18.1328125" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#0000FF" visible="true" width="77.576171875" x="-68.78805184364364" y="-33.974731445312614">docker exec<y:LabelModel>
+          <y:EdgeLabel alignment="center" configuration="AutoFlippingLabel" distance="2.0" fontFamily="Dialog" fontSize="12" fontStyle="bold" hasBackgroundColor="false" hasLineColor="false" height="32.265625" modelName="custom" preferredPlacement="anywhere" ratio="0.5" textColor="#0000FF" visible="true" width="77.576171875" x="-86.46309207519198" y="-41.560991819769924">docker exec
+lxc exec<y:LabelModel>
              <y:SmartEdgeLabelModel autoRotationEnabled="false" defaultAngle="0.0" defaultDistance="10.0"/>
            </y:LabelModel>
            <y:ModelParameter>
-              <y:SmartEdgeLabelModelParameter angle="0.0" distance="30.0" distanceToCenter="true" position="left" ratio="0.5" segment="0"/>
+              <y:SmartEdgeLabelModelParameter angle="6.283185307179586" distance="47.67504023154834" distanceToCenter="true" position="left" ratio="0.5687397467585064" segment="-1"/>
            </y:ModelParameter>
            <y:PreferredPlacementDescriptor angle="0.0" angleOffsetOnRightSide="0" angleReference="absolute" angleRotationOnRightSide="co" distance="-1.0" frozen="true" placement="anywhere" side="anywhere" sideReference="relative_to_edge_flow"/>
          </y:EdgeLabel>
@@ -985,7 +980,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e10" source="n4::n1" target="n11">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
@@ -996,7 +990,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e11" source="n4::n1" target="n5">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
@@ -1007,7 +1000,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e12" source="n4::n1" target="n6">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
@@ -1018,7 +1010,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e13" source="n4::n1" target="n8">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
@@ -1029,7 +1020,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e14" source="n4::n2" target="n11">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
@@ -1040,7 +1030,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e15" source="n4::n1" target="n12">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
@@ -1059,7 +1048,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e16" source="n4::n1" target="n13">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
@@ -1070,7 +1058,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e17" source="n4::n3" target="n11">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
@@ -1081,7 +1068,6 @@ Vulnerability data<y:LabelModel>
      </data>
    </edge>
    <edge id="e18" source="n5" target="n4::n3">
-      <data key="d9"/>
      <data key="d10">
        <y:PolyLineEdge>
          <y:Path sx="0.0" sy="0.0" tx="0.0" ty="0.0"/>
--- a/img/vuls-architecture.png
+++ b/img/vuls-architecture.png
--- a/main.go
+++ b/main.go
@@ -26,12 +26,10 @@ import (

 	"github.com/future-architect/vuls/commands"
 	"github.com/google/subcommands"
-
-	_ "github.com/mattn/go-sqlite3"
 )

 // Version of Vuls
-var version = "0.2.0"
+var version = "0.3.0"

 // Revision of Git
 var revision string
@@ -43,7 +41,6 @@ func main() {
 	subcommands.Register(&commands.DiscoverCmd{}, "discover")
 	subcommands.Register(&commands.TuiCmd{}, "tui")
 	subcommands.Register(&commands.ScanCmd{}, "scan")
-	subcommands.Register(&commands.PrepareCmd{}, "prepare")
 	subcommands.Register(&commands.HistoryCmd{}, "history")
 	subcommands.Register(&commands.ReportCmd{}, "report")
 	subcommands.Register(&commands.ConfigtestCmd{}, "configtest")
--- a/models/models.go
+++ b/models/models.go
@@ -73,12 +73,13 @@ type ScanResult struct {

 	Packages PackageInfoList

+	Errors   []string
 	Optional [][]interface{}
 }

 // FillCveDetail fetches CVE detailed information from
 // CVE Database, and then set to fields.
-func (r ScanResult) FillCveDetail() (ScanResult, error) {
+func (r ScanResult) FillCveDetail() (*ScanResult, error) {
 	set := map[string]VulnInfo{}
 	var cveIDs []string
 	for _, v := range r.ScannedCves {
@@ -88,21 +89,20 @@ func (r ScanResult) FillCveDetail() (ScanResult, error) {

 	ds, err := cveapi.CveClient.FetchCveDetails(cveIDs)
 	if err != nil {
-		return r, err
+		return nil, err
 	}

-	icves := config.Conf.Servers[r.ServerName].IgnoreCves
-
-	var known, unknown, ignored CveInfos
+	known, unknown, ignored := CveInfos{}, CveInfos{}, CveInfos{}
 	for _, d := range ds {
 		cinfo := CveInfo{
 			CveDetail: d,
 			VulnInfo:  set[d.CveID],
 		}
+		cinfo.NilSliceToEmpty()

 		// ignored
 		found := false
-		for _, icve := range icves {
+		for _, icve := range config.Conf.Servers[r.ServerName].IgnoreCves {
 			if icve == d.CveID {
 				ignored = append(ignored, cinfo)
 				found = true
@@ -128,7 +128,7 @@ func (r ScanResult) FillCveDetail() (ScanResult, error) {
 	r.KnownCves = known
 	r.UnknownCves = unknown
 	r.IgnoredCves = ignored
-	return r, nil
+	return &r, nil
 }

 // FilterByCvssOver is filter function.
@@ -162,47 +162,42 @@ func (r ScanResult) ReportKeyName() (name string) {

 // ServerInfo returns server name one line
 func (r ScanResult) ServerInfo() string {
-	hostinfo := ""
 	if len(r.Container.ContainerID) == 0 {
-		hostinfo = fmt.Sprintf(
-			"%s (%s%s)",
-			r.ServerName,
-			r.Family,
-			r.Release,
-		)
-	} else {
-		hostinfo = fmt.Sprintf(
-			"%s / %s (%s%s) on %s",
-			r.Container.Name,
-			r.Container.ContainerID,
-			r.Family,
-			r.Release,
-			r.ServerName,
-		)
+		return fmt.Sprintf("%s (%s%s)",
+			r.ServerName, r.Family, r.Release)
 	}
-	return hostinfo
+	return fmt.Sprintf(
+		"%s / %s (%s%s) on %s",
+		r.Container.Name,
+		r.Container.ContainerID,
+		r.Family,
+		r.Release,
+		r.ServerName,
+	)
 }

 // ServerInfoTui returns server infromation for TUI sidebar
 func (r ScanResult) ServerInfoTui() string {
-	hostinfo := ""
 	if len(r.Container.ContainerID) == 0 {
-		hostinfo = fmt.Sprintf(
-			"%s (%s%s)",
-			r.ServerName,
-			r.Family,
-			r.Release,
-		)
-	} else {
-		hostinfo = fmt.Sprintf(
-			"|-- %s (%s%s)",
-			r.Container.Name,
-			r.Family,
-			r.Release,
-			//  r.Container.ContainerID,
-		)
+		return fmt.Sprintf("%s (%s%s)",
+			r.ServerName, r.Family, r.Release)
 	}
-	return hostinfo
+	return fmt.Sprintf(
+		"|-- %s (%s%s)",
+		r.Container.Name,
+		r.Family,
+		r.Release,
+		//  r.Container.ContainerID,
+	)
+}
+
+// FormatServerName returns server and container name
+func (r ScanResult) FormatServerName() string {
+	if len(r.Container.ContainerID) == 0 {
+		return r.ServerName
+	}
+	return fmt.Sprintf("%s@%s",
+		r.Container.Name, r.ServerName)
 }

 // CveSummary summarize the number of CVEs group by CVSSv2 Severity
@@ -244,17 +239,80 @@ type NWLink struct {
 	LinkState string
 }

+// Confidence is a ranking how confident the CVE-ID was deteted correctly
+// Score: 0 - 100
+type Confidence struct {
+	Score           int
+	DetectionMethod string
+}
+
+func (c Confidence) String() string {
+	return fmt.Sprintf("%d / %s", c.Score, c.DetectionMethod)
+}
+
+const (
+	// CpeNameMatchStr is a String representation of CpeNameMatch
+	CpeNameMatchStr = "CpeNameMatch"
+
+	// YumUpdateSecurityMatchStr is a String representation of YumUpdateSecurityMatch
+	YumUpdateSecurityMatchStr = "YumUpdateSecurityMatch"
+
+	// PkgAuditMatchStr is a String representation of PkgAuditMatch
+	PkgAuditMatchStr = "PkgAuditMatch"
+
+	// ChangelogExactMatchStr is a String representation of ChangelogExactMatch
+	ChangelogExactMatchStr = "ChangelogExactMatch"
+
+	// ChangelogLenientMatchStr is a String representation of ChangelogLenientMatch
+	ChangelogLenientMatchStr = "ChangelogLenientMatch"
+
+	// FailedToGetChangelog is a String representation of FailedToGetChangelog
+	FailedToGetChangelog = "FailedToGetChangelog"
+
+	// FailedToFindVersionInChangelog is a String representation of FailedToFindVersionInChangelog
+	FailedToFindVersionInChangelog = "FailedToFindVersionInChangelog"
+)
+
+// CpeNameMatch is a ranking how confident the CVE-ID was deteted correctly
+var CpeNameMatch = Confidence{100, CpeNameMatchStr}
+
+// YumUpdateSecurityMatch is a ranking how confident the CVE-ID was deteted correctly
+var YumUpdateSecurityMatch = Confidence{100, YumUpdateSecurityMatchStr}
+
+// PkgAuditMatch is a ranking how confident the CVE-ID was deteted correctly
+var PkgAuditMatch = Confidence{100, PkgAuditMatchStr}
+
+// ChangelogExactMatch is a ranking how confident the CVE-ID was deteted correctly
+var ChangelogExactMatch = Confidence{95, ChangelogExactMatchStr}
+
+// ChangelogLenientMatch is a ranking how confident the CVE-ID was deteted correctly
+var ChangelogLenientMatch = Confidence{50, ChangelogLenientMatchStr}
+
 // VulnInfos is VulnInfo list, getter/setter, sortable methods.
 type VulnInfos []VulnInfo

 // VulnInfo holds a vulnerability information and unsecure packages
 type VulnInfo struct {
 	CveID            string
+	Confidence       Confidence
 	Packages         PackageInfoList
 	DistroAdvisories []DistroAdvisory // for Aamazon, RHEL, FreeBSD
 	CpeNames         []string
 }

+// NilSliceToEmpty set nil slice fields to empty slice to avoid null in JSON
+func (v *VulnInfo) NilSliceToEmpty() {
+	if v.CpeNames == nil {
+		v.CpeNames = []string{}
+	}
+	if v.DistroAdvisories == nil {
+		v.DistroAdvisories = []DistroAdvisory{}
+	}
+	if v.Packages == nil {
+		v.Packages = PackageInfoList{}
+	}
+}
+
 // FindByCveID find by CVEID
 func (s VulnInfos) FindByCveID(cveID string) (VulnInfo, bool) {
 	for _, p := range s {
@@ -316,6 +374,22 @@ type CveInfo struct {
 	VulnInfo
 }

+// NilSliceToEmpty set nil slice fields to empty slice to avoid null in JSON
+func (c *CveInfo) NilSliceToEmpty() {
+	if c.CveDetail.Nvd.Cpes == nil {
+		c.CveDetail.Nvd.Cpes = []cve.Cpe{}
+	}
+	if c.CveDetail.Jvn.Cpes == nil {
+		c.CveDetail.Jvn.Cpes = []cve.Cpe{}
+	}
+	if c.CveDetail.Nvd.References == nil {
+		c.CveDetail.Nvd.References = []cve.Reference{}
+	}
+	if c.CveDetail.Jvn.References == nil {
+		c.CveDetail.Jvn.References = []cve.Reference{}
+	}
+}
+
 // PackageInfoList is slice of PackageInfo
 type PackageInfoList []PackageInfo

@@ -371,16 +445,18 @@ func (ps PackageInfoList) MergeNewVersion(as PackageInfoList) {

 func (ps PackageInfoList) countUpdatablePacks() int {
 	count := 0
+	set := make(map[string]bool)
 	for _, p := range ps {
-		if len(p.NewVersion) != 0 {
+		if len(p.NewVersion) != 0 && !set[p.Name] {
 			count++
+			set[p.Name] = true
 		}
 	}
 	return count
 }

-// ToUpdatablePacksSummary returns a summary of updatable packages
-func (ps PackageInfoList) ToUpdatablePacksSummary() string {
+// FormatUpdatablePacksSummary returns a summary of updatable packages
+func (ps PackageInfoList) FormatUpdatablePacksSummary() string {
 	return fmt.Sprintf("%d updatable packages",
 		ps.countUpdatablePacks())
 }
@@ -418,6 +494,14 @@ type PackageInfo struct {
 	NewVersion string
 	NewRelease string
 	Repository string
+	Changelog  Changelog
+}
+
+// Changelog has contents of changelog and how to get it.
+// Method: modesl.detectionMethodStr
+type Changelog struct {
+	Contents string
+	Method   string
 }

 // ToStringCurrentVersion returns package name-version-release
@@ -456,6 +540,8 @@ type DistroAdvisory struct {
 type Container struct {
 	ContainerID string
 	Name        string
+	Image       string
+	Type        string
 }

 // Platform has platform information
--- a/report/azureblob.go
+++ b/report/azureblob.go
@@ -47,7 +47,7 @@ func (w AzureBlobWriter) Write(rs ...models.ScanResult) (err error) {
 	if c.Conf.FormatOneLineText {
 		timestr := rs[0].ScannedAt.Format(time.RFC3339)
 		k := fmt.Sprintf(timestr + "/summary.txt")
-		text := toOneLineSummary(rs...)
+		text := formatOneLineSummary(rs...)
 		b := []byte(text)
 		if err := createBlockBlob(cli, k, b); err != nil {
 			return err
@@ -69,7 +69,7 @@ func (w AzureBlobWriter) Write(rs ...models.ScanResult) (err error) {

 		if c.Conf.FormatShortText {
 			k := key + "_short.txt"
-			b := []byte(toShortPlainText(r))
+			b := []byte(formatShortPlainText(r))
 			if err := createBlockBlob(cli, k, b); err != nil {
 				return err
 			}
@@ -77,7 +77,7 @@ func (w AzureBlobWriter) Write(rs ...models.ScanResult) (err error) {

 		if c.Conf.FormatFullText {
 			k := key + "_full.txt"
-			b := []byte(toFullPlainText(r))
+			b := []byte(formatFullPlainText(r))
 			if err := createBlockBlob(cli, k, b); err != nil {
 				return err
 			}
--- a/report/email.go
+++ b/report/email.go
@@ -34,51 +34,104 @@ type EMailWriter struct{}

 func (w EMailWriter) Write(rs ...models.ScanResult) (err error) {
 	conf := config.Conf
-	to := strings.Join(conf.EMail.To[:], ", ")
-	cc := strings.Join(conf.EMail.Cc[:], ", ")
-	mailAddresses := append(conf.EMail.To, conf.EMail.Cc...)
+	var message string
+	var totalResult models.ScanResult
+	sender := NewEMailSender()
+
+	for _, r := range rs {
+		if conf.FormatOneEMail {
+			message += formatFullPlainText(r) + "\r\n\r\n"
+			totalResult.KnownCves = append(totalResult.KnownCves, r.KnownCves...)
+			totalResult.UnknownCves = append(totalResult.UnknownCves, r.UnknownCves...)
+		} else {
+			var subject string
+			if len(r.Errors) != 0 {
+				subject = fmt.Sprintf("%s%s An error occurred while scanning",
+					conf.EMail.SubjectPrefix, r.ServerInfo())
+			} else {
+				subject = fmt.Sprintf("%s%s %s",
+					conf.EMail.SubjectPrefix, r.ServerInfo(), r.CveSummary())
+			}
+			message = formatFullPlainText(r)
+			if err := sender.Send(subject, message); err != nil {
+				return err
+			}
+		}
+	}
+
+	if conf.FormatOneEMail {
+		message = fmt.Sprintf(
+			`
+One Line Summary
+================
+%s
+
+
+%s`,
+			formatOneLineSummary(rs...), message)
+
+		subject := fmt.Sprintf("%s %s",
+			conf.EMail.SubjectPrefix,
+			totalResult.CveSummary(),
+		)
+		return sender.Send(subject, message)
+	}
+	return nil
+}
+
+// EMailSender is interface of sending e-mail
+type EMailSender interface {
+	Send(subject, body string) error
+}
+
+type emailSender struct {
+	conf config.SMTPConf
+	send func(string, smtp.Auth, string, []string, []byte) error
+}
+
+func (e *emailSender) Send(subject, body string) (err error) {
+	emailConf := e.conf
+	to := strings.Join(emailConf.To[:], ", ")
+	cc := strings.Join(emailConf.Cc[:], ", ")
+	mailAddresses := append(emailConf.To, emailConf.Cc...)
 	if _, err := mail.ParseAddressList(strings.Join(mailAddresses[:], ", ")); err != nil {
 		return fmt.Errorf("Failed to parse email addresses: %s", err)
 	}

-	for _, r := range rs {
-		subject := fmt.Sprintf("%s%s %s",
-			conf.EMail.SubjectPrefix,
-			r.ServerInfo(),
-			r.CveSummary(),
-		)
+	headers := make(map[string]string)
+	headers["From"] = emailConf.From
+	headers["To"] = to
+	headers["Cc"] = cc
+	headers["Subject"] = subject
+	headers["Date"] = time.Now().Format(time.RFC1123Z)
+	headers["Content-Type"] = "text/plain; charset=utf-8"

-		headers := make(map[string]string)
-		headers["From"] = conf.EMail.From
-		headers["To"] = to
-		headers["Cc"] = cc
-		headers["Subject"] = subject
-		headers["Date"] = time.Now().Format(time.RFC1123Z)
-		headers["Content-Type"] = "text/plain; charset=utf-8"
+	var header string
+	for k, v := range headers {
+		header += fmt.Sprintf("%s: %s\r\n", k, v)
+	}
+	message := fmt.Sprintf("%s\r\n%s", header, body)

-		var message string
-		for k, v := range headers {
-			message += fmt.Sprintf("%s: %s\r\n", k, v)
-		}
-		message += "\r\n" + toFullPlainText(r)
-
-		smtpServer := net.JoinHostPort(conf.EMail.SMTPAddr, conf.EMail.SMTPPort)
-		err = smtp.SendMail(
-			smtpServer,
-			smtp.PlainAuth(
-				"",
-				conf.EMail.User,
-				conf.EMail.Password,
-				conf.EMail.SMTPAddr,
-			),
-			conf.EMail.From,
-			conf.EMail.To,
-			[]byte(message),
-		)
-
-		if err != nil {
-			return fmt.Errorf("Failed to send emails: %s", err)
-		}
+	smtpServer := net.JoinHostPort(emailConf.SMTPAddr, emailConf.SMTPPort)
+	err = e.send(
+		smtpServer,
+		smtp.PlainAuth(
+			"",
+			emailConf.User,
+			emailConf.Password,
+			emailConf.SMTPAddr,
+		),
+		emailConf.From,
+		mailAddresses,
+		[]byte(message),
+	)
+	if err != nil {
+		return fmt.Errorf("Failed to send emails: %s", err)
 	}
 	return nil
 }
+
+// NewEMailSender creates emailSender
+func NewEMailSender() EMailSender {
+	return &emailSender{config.Conf.EMail, smtp.SendMail}
+}
--- a/report/email_test.go
+++ b/report/email_test.go
@@ -0,0 +1,132 @@
+/* Vuls - Vulnerability Scanner
+Copyright (C) 2016  Future Architect, Inc. Japan.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package report
+
+import (
+	"net/smtp"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/future-architect/vuls/config"
+)
+
+type emailRecorder struct {
+	addr string
+	auth smtp.Auth
+	from string
+	to   []string
+	body string
+}
+
+type mailTest struct {
+	in  config.SMTPConf
+	out emailRecorder
+}
+
+var mailTests = []mailTest{
+	{
+		config.SMTPConf{
+			SMTPAddr: "127.0.0.1",
+			SMTPPort: "25",
+
+			From: "from@address.com",
+			To:   []string{"to@address.com"},
+			Cc:   []string{"cc@address.com"},
+		},
+		emailRecorder{
+			addr: "127.0.0.1:25",
+			auth: smtp.PlainAuth("", "", "", "127.0.0.1"),
+			from: "from@address.com",
+			to:   []string{"to@address.com", "cc@address.com"},
+			body: "body",
+		},
+	},
+	{
+		config.SMTPConf{
+			SMTPAddr: "127.0.0.1",
+			SMTPPort: "25",
+
+			User:     "vuls",
+			Password: "password",
+
+			From: "from@address.com",
+			To:   []string{"to1@address.com", "to2@address.com"},
+			Cc:   []string{"cc1@address.com", "cc2@address.com"},
+		},
+		emailRecorder{
+			addr: "127.0.0.1:25",
+			auth: smtp.PlainAuth(
+				"",
+				"vuls",
+				"password",
+				"127.0.0.1",
+			),
+			from: "from@address.com",
+			to: []string{"to1@address.com", "to2@address.com",
+				"cc1@address.com", "cc2@address.com"},
+			body: "body",
+		},
+	},
+}
+
+func TestSend(t *testing.T) {
+	for i, test := range mailTests {
+		f, r := mockSend(nil)
+		sender := &emailSender{conf: test.in, send: f}
+
+		subject := "subject"
+		body := "body"
+		if err := sender.Send(subject, body); err != nil {
+			t.Errorf("unexpected error: %s", err)
+		}
+
+		if r.addr != test.out.addr {
+			t.Errorf("#%d: wrong 'addr' field.\r\nexpected: %s\n got: %s", i, test.out.addr, r.addr)
+		}
+
+		if !reflect.DeepEqual(r.auth, test.out.auth) {
+			t.Errorf("#%d: wrong 'auth' field.\r\nexpected: %v\n got: %v", i, test.out.auth, r.auth)
+		}
+
+		if r.from != test.out.from {
+			t.Errorf("#%d: wrong 'from' field.\r\nexpected: %v\n got: %v", i, test.out.from, r.from)
+		}
+
+		if !reflect.DeepEqual(r.to, test.out.to) {
+			t.Errorf("#%d: wrong 'to' field.\r\nexpected: %v\n got: %v", i, test.out.to, r.to)
+		}
+
+		if r.body != test.out.body {
+			t.Errorf("#%d: wrong 'body' field.\r\nexpected: %v\n got: %v", i, test.out.body, r.body)
+		}
+
+	}
+
+}
+
+func mockSend(errToReturn error) (func(string, smtp.Auth, string, []string, []byte) error, *emailRecorder) {
+	r := new(emailRecorder)
+	return func(addr string, a smtp.Auth, from string, to []string, msg []byte) error {
+		// Split into header and body
+		messages := strings.Split(string(msg), "\r\n\r\n")
+		body := messages[1]
+		*r = emailRecorder{addr, a, from, to, body}
+		return errToReturn
+	}, r
+}
--- a/report/localfile.go
+++ b/report/localfile.go
@@ -38,7 +38,7 @@ type LocalFileWriter struct {
 func (w LocalFileWriter) Write(rs ...models.ScanResult) (err error) {
 	if c.Conf.FormatOneLineText {
 		path := filepath.Join(w.CurrentDir, "summary.txt")
-		text := toOneLineSummary(rs...)
+		text := formatOneLineSummary(rs...)
 		if err := writeFile(path, []byte(text), 0600); err != nil {
 			return fmt.Errorf(
 				"Failed to write to file. path: %s, err: %s",
@@ -50,7 +50,13 @@ func (w LocalFileWriter) Write(rs ...models.ScanResult) (err error) {
 		path := filepath.Join(w.CurrentDir, r.ReportFileName())

 		if c.Conf.FormatJSON {
-			p := path + ".json"
+			var p string
+			if c.Conf.Diff {
+				p = path + "_diff.json"
+			} else {
+				p = path + ".json"
+			}
+
 			var b []byte
 			if b, err = json.Marshal(r); err != nil {
 				return fmt.Errorf("Failed to Marshal to JSON: %s", err)
@@ -61,25 +67,43 @@ func (w LocalFileWriter) Write(rs ...models.ScanResult) (err error) {
 		}

 		if c.Conf.FormatShortText {
-			p := path + "_short.txt"
+			var p string
+			if c.Conf.Diff {
+				p = path + "_short_diff.txt"
+			} else {
+				p = path + "_short.txt"
+			}
+
 			if err := writeFile(
-				p, []byte(toShortPlainText(r)), 0600); err != nil {
+				p, []byte(formatShortPlainText(r)), 0600); err != nil {
 				return fmt.Errorf(
 					"Failed to write text files. path: %s, err: %s", p, err)
 			}
 		}

 		if c.Conf.FormatFullText {
-			p := path + "_full.txt"
+			var p string
+			if c.Conf.Diff {
+				p = path + "_full_diff.txt"
+			} else {
+				p = path + "_full.txt"
+			}
+
 			if err := writeFile(
-				p, []byte(toFullPlainText(r)), 0600); err != nil {
+				p, []byte(formatFullPlainText(r)), 0600); err != nil {
 				return fmt.Errorf(
 					"Failed to write text files. path: %s, err: %s", p, err)
 			}
 		}

 		if c.Conf.FormatXML {
-			p := path + ".xml"
+			var p string
+			if c.Conf.Diff {
+				p = path + "_diff.xml"
+			} else {
+				p = path + ".xml"
+			}
+
 			var b []byte
 			if b, err = xml.Marshal(r); err != nil {
 				return fmt.Errorf("Failed to Marshal to XML: %s", err)
--- a/report/s3.go
+++ b/report/s3.go
@@ -26,6 +26,8 @@ import (

 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds"
+	"github.com/aws/aws-sdk-go/aws/ec2metadata"
 	"github.com/aws/aws-sdk-go/aws/session"
 	"github.com/aws/aws-sdk-go/service/s3"

@@ -37,10 +39,15 @@ import (
 type S3Writer struct{}

 func getS3() *s3.S3 {
-	return s3.New(session.New(&aws.Config{
-		Region:      aws.String(c.Conf.AwsRegion),
-		Credentials: credentials.NewSharedCredentials("", c.Conf.AwsProfile),
-	}))
+	Config := &aws.Config{
+		Region: aws.String(c.Conf.AwsRegion),
+		Credentials: credentials.NewChainCredentials([]credentials.Provider{
+			&credentials.EnvProvider{},
+			&credentials.SharedCredentialsProvider{Filename: "", Profile: c.Conf.AwsProfile},
+			&ec2rolecreds.EC2RoleProvider{Client: ec2metadata.New(session.New())},
+		}),
+	}
+	return s3.New(session.New(Config))
 }

 // Write results to S3
@@ -55,7 +62,7 @@ func (w S3Writer) Write(rs ...models.ScanResult) (err error) {
 	if c.Conf.FormatOneLineText {
 		timestr := rs[0].ScannedAt.Format(time.RFC3339)
 		k := fmt.Sprintf(timestr + "/summary.txt")
-		text := toOneLineSummary(rs...)
+		text := formatOneLineSummary(rs...)
 		if err := putObject(svc, k, []byte(text)); err != nil {
 			return err
 		}
@@ -76,7 +83,7 @@ func (w S3Writer) Write(rs ...models.ScanResult) (err error) {

 		if c.Conf.FormatShortText {
 			k := key + "_short.txt"
-			text := toShortPlainText(r)
+			text := formatShortPlainText(r)
 			if err := putObject(svc, k, []byte(text)); err != nil {
 				return err
 			}
@@ -84,7 +91,7 @@ func (w S3Writer) Write(rs ...models.ScanResult) (err error) {

 		if c.Conf.FormatFullText {
 			k := key + "_full.txt"
-			text := toFullPlainText(r)
+			text := formatFullPlainText(r)
 			if err := putObject(svc, k, []byte(text)); err != nil {
 				return err
 			}
--- a/report/slack.go
+++ b/report/slack.go
@@ -20,6 +20,7 @@ package report
 import (
 	"encoding/json"
 	"fmt"
+	"sort"
 	"strings"
 	"time"

@@ -65,32 +66,86 @@ func (w SlackWriter) Write(rs ...models.ScanResult) error {
 			channel = fmt.Sprintf("#%s", r.ServerName)
 		}

-		msg := message{
-			Text:        msgText(r),
-			Username:    conf.AuthUser,
-			IconEmoji:   conf.IconEmoji,
-			Channel:     channel,
-			Attachments: toSlackAttachments(r),
+		if 0 < len(r.Errors) {
+			serverInfo := fmt.Sprintf("*%s*", r.ServerInfo())
+			notifyUsers := getNotifyUsers(config.Conf.Slack.NotifyUsers)
+			txt := fmt.Sprintf("%s\n%s\nError: %s", notifyUsers, serverInfo, r.Errors)
+			msg := message{
+				Text:      txt,
+				Username:  conf.AuthUser,
+				IconEmoji: conf.IconEmoji,
+				Channel:   channel,
+			}
+			if err := send(msg); err != nil {
+				return err
+			}
+			continue
 		}

-		bytes, _ := json.Marshal(msg)
-		jsonBody := string(bytes)
-		f := func() (err error) {
-			resp, body, errs := gorequest.New().Proxy(config.Conf.HTTPProxy).Post(conf.HookURL).Send(string(jsonBody)).End()
-			if 0 < len(errs) || resp == nil || resp.StatusCode != 200 {
-				return fmt.Errorf(
-					"HTTP POST error: %v, url: %s, resp: %v, body: %s",
-					errs, conf.HookURL, resp, body)
+		// A maximum of 100 attachments are allowed on a message.
+		// Split into chunks with 100 elements
+		// https://api.slack.com/methods/chat.postMessage
+		maxAttachments := 100
+		m := map[int][]*attachment{}
+		for i, a := range toSlackAttachments(r) {
+			m[i/maxAttachments] = append(m[i/maxAttachments], a)
+		}
+		chunkKeys := []int{}
+		for k := range m {
+			chunkKeys = append(chunkKeys, k)
+		}
+		sort.Ints(chunkKeys)
+
+		for i, k := range chunkKeys {
+			txt := ""
+			if i == 0 {
+				txt = msgText(r)
+			}
+			msg := message{
+				Text:        txt,
+				Username:    conf.AuthUser,
+				IconEmoji:   conf.IconEmoji,
+				Channel:     channel,
+				Attachments: m[k],
+			}
+			if err := send(msg); err != nil {
+				return err
 			}
-			return nil
 		}
-		notify := func(err error, t time.Duration) {
-			log.Warn("Error %s", err)
-			log.Warn("Retrying in ", t)
-		}
-		if err := backoff.RetryNotify(f, backoff.NewExponentialBackOff(), notify); err != nil {
-			return fmt.Errorf("HTTP Error: %s", err)
+	}
+	return nil
+}
+
+func send(msg message) error {
+	conf := config.Conf.Slack
+	count, retryMax := 0, 10
+
+	bytes, _ := json.Marshal(msg)
+	jsonBody := string(bytes)
+
+	f := func() (err error) {
+		resp, body, errs := gorequest.New().Proxy(config.Conf.HTTPProxy).Post(conf.HookURL).Send(string(jsonBody)).End()
+		if 0 < len(errs) || resp == nil || resp.StatusCode != 200 {
+			count++
+			if count == retryMax {
+				return nil
+			}
+			return fmt.Errorf(
+				"HTTP POST error: %v, url: %s, resp: %v, body: %s",
+				errs, conf.HookURL, resp, body)
 		}
+		return nil
+	}
+	notify := func(err error, t time.Duration) {
+		log.Warnf("Error %s", err)
+		log.Warn("Retrying in ", t)
+	}
+	boff := backoff.NewExponentialBackOff()
+	if err := backoff.RetryNotify(f, boff, notify); err != nil {
+		return fmt.Errorf("HTTP error: %s", err)
+	}
+	if count == retryMax {
+		return fmt.Errorf("Retry count exceeded")
 	}
 	return nil
 }
@@ -100,7 +155,6 @@ func msgText(r models.ScanResult) string {
 	if 0 < len(r.KnownCves) || 0 < len(r.UnknownCves) {
 		notifyUsers = getNotifyUsers(config.Conf.Slack.NotifyUsers)
 	}
-
 	serverInfo := fmt.Sprintf("*%s*", r.ServerInfo())
 	return fmt.Sprintf("%s\n%s\n>%s", notifyUsers, serverInfo, r.CveSummary())
 }
@@ -167,36 +221,38 @@ func color(cvssScore float64) string {
 }

 func attachmentText(cveInfo models.CveInfo, osFamily string) string {
-
 	linkText := links(cveInfo, osFamily)
-
 	switch {
 	case config.Conf.Lang == "ja" &&
 		0 < cveInfo.CveDetail.Jvn.CvssScore():

 		jvn := cveInfo.CveDetail.Jvn
-		return fmt.Sprintf("*%4.1f (%s)* <%s|%s>\n%s\n%s",
+		return fmt.Sprintf("*%4.1f (%s)* <%s|%s>\n%s\n%s\n*Confidence:* %v",
 			cveInfo.CveDetail.CvssScore(config.Conf.Lang),
 			jvn.CvssSeverity(),
-			fmt.Sprintf(cvssV2CalcURLTemplate, cveInfo.CveDetail.CveID, jvn.CvssVector()),
+			fmt.Sprintf(cvssV2CalcURLTemplate,
+				cveInfo.CveDetail.CveID, jvn.CvssVector()),
 			jvn.CvssVector(),
 			jvn.CveTitle(),
 			linkText,
+			cveInfo.VulnInfo.Confidence,
 		)
-
 	case 0 < cveInfo.CveDetail.CvssScore("en"):
 		nvd := cveInfo.CveDetail.Nvd
-		return fmt.Sprintf("*%4.1f (%s)* <%s|%s>\n%s\n%s",
+		return fmt.Sprintf("*%4.1f (%s)* <%s|%s>\n%s\n%s\n*Confidence:* %v",
 			cveInfo.CveDetail.CvssScore(config.Conf.Lang),
 			nvd.CvssSeverity(),
-			fmt.Sprintf(cvssV2CalcURLTemplate, cveInfo.CveDetail.CveID, nvd.CvssVector()),
+			fmt.Sprintf(cvssV2CalcURLTemplate,
+				cveInfo.CveDetail.CveID, nvd.CvssVector()),
 			nvd.CvssVector(),
 			nvd.CveSummary(),
 			linkText,
+			cveInfo.VulnInfo.Confidence,
 		)
 	default:
 		nvd := cveInfo.CveDetail.Nvd
-		return fmt.Sprintf("?\n%s\n%s", nvd.CveSummary(), linkText)
+		return fmt.Sprintf("?\n%s\n%s\n*Confidence:* %v",
+			nvd.CveSummary(), linkText, cveInfo.VulnInfo.Confidence)
 	}
 }

--- a/report/stdout.go
+++ b/report/stdout.go
@@ -30,9 +30,9 @@ type StdoutWriter struct{}
 // WriteScanSummary prints Scan summary at the end of scan
 func (w StdoutWriter) WriteScanSummary(rs ...models.ScanResult) {
 	fmt.Printf("\n\n")
-	fmt.Printf("Scan Summary\n")
-	fmt.Printf("============\n")
-	fmt.Printf("%s\n", toScanSummary(rs...))
+	fmt.Println("One Line Summary")
+	fmt.Println("================")
+	fmt.Printf("%s\n", formatScanSummary(rs...))
 }

 func (w StdoutWriter) Write(rs ...models.ScanResult) error {
@@ -40,19 +40,19 @@ func (w StdoutWriter) Write(rs ...models.ScanResult) error {
 		fmt.Print("\n\n")
 		fmt.Println("One Line Summary")
 		fmt.Println("================")
-		fmt.Println(toOneLineSummary(rs...))
+		fmt.Println(formatOneLineSummary(rs...))
 		fmt.Print("\n")
 	}

 	if c.Conf.FormatShortText {
 		for _, r := range rs {
-			fmt.Println(toShortPlainText(r))
+			fmt.Println(formatShortPlainText(r))
 		}
 	}

 	if c.Conf.FormatFullText {
 		for _, r := range rs {
-			fmt.Println(toFullPlainText(r))
+			fmt.Println(formatFullPlainText(r))
 		}
 	}
 	return nil
--- a/report/tui.go
+++ b/report/tui.go
@@ -133,6 +133,27 @@ func keybindings(g *gocui.Gui) (err error) {
 	errs = append(errs, g.SetKeybinding("detail", gocui.KeyCtrlP, gocui.ModNone, previousSummary))
 	errs = append(errs, g.SetKeybinding("detail", gocui.KeyEnter, gocui.ModNone, nextView))

+	// changelog
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyTab, gocui.ModNone, nextView))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlQ, gocui.ModNone, previousView))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlH, gocui.ModNone, nextView))
+	//  errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlL, gocui.ModNone, nextView))
+	//  errs = append(errs, g.SetKeybinding("changelog", gocui.KeyArrowUp, gocui.ModAlt, previousView))
+	//  errs = append(errs, g.SetKeybinding("changelog", gocui.KeyArrowLeft, gocui.ModAlt, nextView))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyArrowDown, gocui.ModNone, cursorDown))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyArrowUp, gocui.ModNone, cursorUp))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlJ, gocui.ModNone, cursorDown))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlK, gocui.ModNone, cursorUp))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlD, gocui.ModNone, cursorPageDown))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlU, gocui.ModNone, cursorPageUp))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeySpace, gocui.ModNone, cursorPageDown))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyBackspace, gocui.ModNone, cursorPageUp))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyBackspace2, gocui.ModNone, cursorPageUp))
+	//  errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlM, gocui.ModNone, cursorMoveMiddle))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlN, gocui.ModNone, nextSummary))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyCtrlP, gocui.ModNone, previousSummary))
+	errs = append(errs, g.SetKeybinding("changelog", gocui.KeyEnter, gocui.ModNone, nextView))
+
 	//  errs = append(errs, g.SetKeybinding("msg", gocui.KeyEnter, gocui.ModNone, delMsg))
 	//  errs = append(errs, g.SetKeybinding("detail", gocui.KeyEnter, gocui.ModNone, showMsg))

@@ -162,6 +183,8 @@ func nextView(g *gocui.Gui, v *gocui.View) error {
 	case "summary":
 		_, err = g.SetCurrentView("detail")
 	case "detail":
+		_, err = g.SetCurrentView("changelog")
+	case "changelog":
 		_, err = g.SetCurrentView("side")
 	default:
 		_, err = g.SetCurrentView("summary")
@@ -182,6 +205,8 @@ func previousView(g *gocui.Gui, v *gocui.View) error {
 		_, err = g.SetCurrentView("side")
 	case "detail":
 		_, err = g.SetCurrentView("summary")
+	case "changelog":
+		_, err = g.SetCurrentView("detail")
 	default:
 		_, err = g.SetCurrentView("side")
 	}
@@ -207,6 +232,11 @@ func movable(v *gocui.View, nextY int) (ok bool, yLimit int) {
 			return false, currentDetailLimitY
 		}
 		return true, currentDetailLimitY
+	case "changelog":
+		if currentDetailLimitY < nextY {
+			return false, currentDetailLimitY
+		}
+		return true, currentDetailLimitY
 	default:
 		return true, 0
 	}
@@ -217,7 +247,7 @@ func pageUpDownJumpCount(v *gocui.View) int {
 	switch v.Name() {
 	case "side", "summary":
 		jump = 8
-	case "detail":
+	case "detail", "changelog":
 		jump = 30
 	default:
 		jump = 8
@@ -232,6 +262,9 @@ func onMovingCursorRedrawView(g *gocui.Gui, v *gocui.View) error {
 		if err := redrawDetail(g); err != nil {
 			return err
 		}
+		if err := redrawChangelog(g); err != nil {
+			return err
+		}
 	case "side":
 		if err := changeHost(g, v); err != nil {
 			return err
@@ -395,6 +428,9 @@ func changeHost(g *gocui.Gui, v *gocui.View) error {
 	if err := g.DeleteView("detail"); err != nil {
 		return err
 	}
+	if err := g.DeleteView("changelog"); err != nil {
+		return err
+	}

 	_, cy := v.Cursor()
 	l, err := v.Line(cy)
@@ -416,6 +452,9 @@ func changeHost(g *gocui.Gui, v *gocui.View) error {
 	if err := setDetailLayout(g); err != nil {
 		return err
 	}
+	if err := setChangelogLayout(g); err != nil {
+		return err
+	}
 	return nil
 }

@@ -430,6 +469,17 @@ func redrawDetail(g *gocui.Gui) error {
 	return nil
 }

+func redrawChangelog(g *gocui.Gui) error {
+	if err := g.DeleteView("changelog"); err != nil {
+		return err
+	}
+
+	if err := setChangelogLayout(g); err != nil {
+		return err
+	}
+	return nil
+}
+
 func getLine(g *gocui.Gui, v *gocui.View) error {
 	var l string
 	var err error
@@ -498,12 +548,15 @@ func layout(g *gocui.Gui) error {
 	if err := setDetailLayout(g); err != nil {
 		return err
 	}
+	if err := setChangelogLayout(g); err != nil {
+		return err
+	}
 	return nil
 }

 func setSideLayout(g *gocui.Gui) error {
 	_, maxY := g.Size()
-	if v, err := g.SetView("side", -1, -1, 40, maxY); err != nil {
+	if v, err := g.SetView("side", -1, -1, 40, int(float64(maxY)*0.2)); err != nil {
 		if err != gocui.ErrUnknownView {
 			return err
 		}
@@ -545,6 +598,10 @@ func summaryLines() string {
 	stable.MaxColWidth = 1000
 	stable.Wrap = false

+	if len(currentScanResult.Errors) != 0 {
+		return "Error: Scan with --debug to view the details"
+	}
+
 	indexFormat := ""
 	if len(currentScanResult.AllCves()) < 10 {
 		indexFormat = "[%1d]"
@@ -565,11 +622,9 @@ func summaryLines() string {
 			cols = []string{
 				fmt.Sprintf(indexFormat, i+1),
 				d.CveDetail.CveID,
-				fmt.Sprintf("|  %-4.1f(%s)",
-					d.CveDetail.CvssScore(config.Conf.Lang),
-					d.CveDetail.Jvn.CvssSeverity(),
-				),
-				//  strings.Join(packs, ","),
+				fmt.Sprintf("| %4.1f",
+					d.CveDetail.CvssScore(config.Conf.Lang)),
+				fmt.Sprintf("| %3d |", d.VulnInfo.Confidence.Score),
 				summary,
 			}
 		} else {
@@ -577,18 +632,17 @@ func summaryLines() string {

 			var cvssScore string
 			if d.CveDetail.CvssScore("en") <= 0 {
-				cvssScore = "| ?"
+				cvssScore = "|   ?"
 			} else {
-				cvssScore = fmt.Sprintf("| %-4.1f(%s)",
-					d.CveDetail.CvssScore(config.Conf.Lang),
-					d.CveDetail.Nvd.CvssSeverity(),
-				)
+				cvssScore = fmt.Sprintf("| %4.1f",
+					d.CveDetail.CvssScore(config.Conf.Lang))
 			}

 			cols = []string{
 				fmt.Sprintf(indexFormat, i+1),
 				d.CveDetail.CveID,
 				cvssScore,
+				fmt.Sprintf("| %3d |", d.VulnInfo.Confidence.Score),
 				summary,
 			}
 		}
@@ -613,14 +667,10 @@ func setDetailLayout(g *gocui.Gui) error {
 	_, oy := summaryView.Origin()
 	currentCveInfo = cy + oy

-	if v, err := g.SetView("detail", 40, int(float64(maxY)*0.2), maxX, maxY); err != nil {
+	if v, err := g.SetView("detail", -1, int(float64(maxY)*0.2), int(float64(maxX)*0.5), maxY); err != nil {
 		if err != gocui.ErrUnknownView {
 			return err
 		}
-		//  text := report.ToPlainTextDetailsLangEn(
-		//      currentScanResult.KnownCves[currentCveInfo],
-		//      currentScanResult.Family)
-
 		text, err := detailLines()
 		if err != nil {
 			return err
@@ -634,12 +684,51 @@ func setDetailLayout(g *gocui.Gui) error {
 	return nil
 }

+func setChangelogLayout(g *gocui.Gui) error {
+	maxX, maxY := g.Size()
+
+	summaryView, err := g.View("summary")
+	if err != nil {
+		return err
+	}
+	_, cy := summaryView.Cursor()
+	_, oy := summaryView.Origin()
+	currentCveInfo = cy + oy
+
+	if v, err := g.SetView("changelog", int(float64(maxX)*0.5), int(float64(maxY)*0.2), maxX, maxY); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		if len(currentScanResult.Errors) != 0 || len(currentScanResult.AllCves()) == 0 {
+			return nil
+		}
+
+		lines := []string{}
+		cveInfo := currentScanResult.AllCves()[currentCveInfo]
+		for _, pack := range cveInfo.Packages {
+			for _, p := range currentScanResult.Packages {
+				if pack.Name == p.Name {
+					lines = append(lines, formatOneChangelog(p), "\n")
+				}
+			}
+		}
+		text := strings.Join(lines, "\n")
+		fmt.Fprint(v, text)
+		v.Editable = false
+		v.Wrap = true
+
+		currentDetailLimitY = len(strings.Split(text, "\n")) - 1
+	}
+	return nil
+}
+
 type dataForTmpl struct {
 	CveID            string
 	CvssScore        string
 	CvssVector       string
 	CvssSeverity     string
 	Summary          string
+	Confidence       models.Confidence
 	CweURL           string
 	VulnSiteLinks    []string
 	References       []cve.Reference
@@ -650,6 +739,10 @@ type dataForTmpl struct {
 }

 func detailLines() (string, error) {
+	if len(currentScanResult.Errors) != 0 {
+		return "", nil
+	}
+
 	if len(currentScanResult.AllCves()) == 0 {
 		return "No vulnerable packages", nil
 	}
@@ -715,6 +808,7 @@ func detailLines() (string, error) {
 		CvssSeverity:  cvssSeverity,
 		CvssVector:    cvssVector,
 		Summary:       summary,
+		Confidence:    cveInfo.VulnInfo.Confidence,
 		CweURL:        cweURL,
 		VulnSiteLinks: links,
 		References:    refs,
@@ -730,8 +824,6 @@ func detailLines() (string, error) {
 	return string(buf.Bytes()), nil
 }

-//  * {{.Name}}-{{.Version}}-{{.Release}}
-
 func detailTemplate() string {
 	return `
 {{.CveID}}
@@ -747,6 +839,11 @@ Summary

 {{.Summary }}

+Confidence
+--------------
+
+ {{.Confidence }}
+
 CWE
 --------------

--- a/report/util.go
+++ b/report/util.go
@@ -29,38 +29,57 @@ import (

 const maxColWidth = 80

-func toScanSummary(rs ...models.ScanResult) string {
+func formatScanSummary(rs ...models.ScanResult) string {
 	table := uitable.New()
 	table.MaxColWidth = maxColWidth
 	table.Wrap = true
 	for _, r := range rs {
-		cols := []interface{}{
-			r.ServerName,
-			fmt.Sprintf("%s%s", r.Family, r.Release),
-			fmt.Sprintf("%d CVEs", len(r.ScannedCves)),
-			r.Packages.ToUpdatablePacksSummary(),
+		var cols []interface{}
+		if len(r.Errors) == 0 {
+			cols = []interface{}{
+				r.FormatServerName(),
+				fmt.Sprintf("%s%s", r.Family, r.Release),
+				fmt.Sprintf("%d CVEs", len(r.ScannedCves)),
+				r.Packages.FormatUpdatablePacksSummary(),
+			}
+		} else {
+			cols = []interface{}{
+				r.FormatServerName(),
+				"Error",
+				"",
+				"Run with --debug to view the details",
+			}
 		}
 		table.AddRow(cols...)
 	}
 	return fmt.Sprintf("%s\n", table)
 }

-func toOneLineSummary(rs ...models.ScanResult) string {
+func formatOneLineSummary(rs ...models.ScanResult) string {
 	table := uitable.New()
 	table.MaxColWidth = maxColWidth
 	table.Wrap = true
 	for _, r := range rs {
-		cols := []interface{}{
-			r.ServerName,
-			r.CveSummary(),
-			r.Packages.ToUpdatablePacksSummary(),
+		var cols []interface{}
+		if len(r.Errors) == 0 {
+			cols = []interface{}{
+				r.FormatServerName(),
+				r.CveSummary(),
+				r.Packages.FormatUpdatablePacksSummary(),
+			}
+		} else {
+			cols = []interface{}{
+				r.FormatServerName(),
+				"Error: Scan with --debug to view the details",
+				"",
+			}
 		}
 		table.AddRow(cols...)
 	}
 	return fmt.Sprintf("%s\n", table)
 }

-func toShortPlainText(r models.ScanResult) string {
+func formatShortPlainText(r models.ScanResult) string {
 	stable := uitable.New()
 	stable.MaxColWidth = maxColWidth
 	stable.Wrap = true
@@ -78,15 +97,21 @@ func toShortPlainText(r models.ScanResult) string {
 		r.ServerInfo(),
 		buf.String(),
 		r.CveSummary(),
-		r.Packages.ToUpdatablePacksSummary(),
+		r.Packages.FormatUpdatablePacksSummary(),
 	)

+	if len(r.Errors) != 0 {
+		return fmt.Sprintf(
+			"%s\nError: Scan with --debug to view the details\n%s\n\n",
+			header, r.Errors)
+	}
+
 	if len(cves) == 0 {
 		return fmt.Sprintf(`
 %s
 No CVE-IDs are found in updatable packages.
 %s
-`, header, r.Packages.ToUpdatablePacksSummary())
+`, header, r.Packages.FormatUpdatablePacksSummary())
 	}

 	for _, d := range cves {
@@ -103,11 +128,12 @@ No CVE-IDs are found in updatable packages.
 		switch {
 		case config.Conf.Lang == "ja" &&
 			0 < d.CveDetail.Jvn.CvssScore():
-			summary := fmt.Sprintf("%s\n%s\n%s\n%s",
+			summary := fmt.Sprintf("%s\n%s\n%s\n%sConfidence: %v",
 				d.CveDetail.Jvn.CveTitle(),
 				d.CveDetail.Jvn.Link(),
 				distroLinks(d, r.Family)[0].url,
 				packsVer,
+				d.VulnInfo.Confidence,
 			)
 			scols = []string{
 				d.CveDetail.CveID,
@@ -119,12 +145,13 @@ No CVE-IDs are found in updatable packages.
 			}

 		case 0 < d.CveDetail.CvssScore("en"):
-			summary := fmt.Sprintf("%s\n%s/%s\n%s\n%s",
+			summary := fmt.Sprintf("%s\n%s/%s\n%s\n%sConfidence: %v",
 				d.CveDetail.Nvd.CveSummary(),
 				cveDetailsBaseURL,
 				d.CveDetail.CveID,
 				distroLinks(d, r.Family)[0].url,
 				packsVer,
+				d.VulnInfo.Confidence,
 			)
 			scols = []string{
 				d.CveDetail.CveID,
@@ -135,8 +162,8 @@ No CVE-IDs are found in updatable packages.
 				summary,
 			}
 		default:
-			summary := fmt.Sprintf("%s\n%s",
-				distroLinks(d, r.Family)[0].url, packsVer)
+			summary := fmt.Sprintf("%s\n%sConfidence: %v",
+				distroLinks(d, r.Family)[0].url, packsVer, d.VulnInfo.Confidence)
 			scols = []string{
 				d.CveDetail.CveID,
 				"?",
@@ -154,7 +181,7 @@ No CVE-IDs are found in updatable packages.
 	return fmt.Sprintf("%s\n%s\n", header, stable)
 }

-func toFullPlainText(r models.ScanResult) string {
+func formatFullPlainText(r models.ScanResult) string {
 	serverInfo := r.ServerInfo()

 	var buf bytes.Buffer
@@ -165,19 +192,25 @@ func toFullPlainText(r models.ScanResult) string {
 		r.ServerInfo(),
 		buf.String(),
 		r.CveSummary(),
-		r.Packages.ToUpdatablePacksSummary(),
+		r.Packages.FormatUpdatablePacksSummary(),
 	)

+	if len(r.Errors) != 0 {
+		return fmt.Sprintf(
+			"%s\nError: Scan with --debug to view the details\n%s\n\n",
+			header, r.Errors)
+	}
+
 	if len(r.KnownCves) == 0 && len(r.UnknownCves) == 0 {
 		return fmt.Sprintf(`
 %s
 No CVE-IDs are found in updatable packages.
 %s
-`, header, r.Packages.ToUpdatablePacksSummary())
+`, header, r.Packages.FormatUpdatablePacksSummary())
 	}

 	scoredReport, unscoredReport := []string{}, []string{}
-	scoredReport, unscoredReport = toPlainTextDetails(r, r.Family)
+	scoredReport, unscoredReport = formatPlainTextDetails(r, r.Family)

 	unscored := ""
 	if !config.Conf.IgnoreUnscoredCves {
@@ -193,41 +226,41 @@ No CVE-IDs are found in updatable packages.
 		scored,
 		unscored,
 	)
-	return fmt.Sprintf("%s\n%s\n", header, detail)
+	return fmt.Sprintf("%s\n%s\n%s", header, detail, formatChangelogs(r))
 }

-func toPlainTextDetails(r models.ScanResult, osFamily string) (scoredReport, unscoredReport []string) {
+func formatPlainTextDetails(r models.ScanResult, osFamily string) (scoredReport, unscoredReport []string) {
 	for _, cve := range r.KnownCves {
 		switch config.Conf.Lang {
 		case "en":
 			if 0 < cve.CveDetail.Nvd.CvssScore() {
 				scoredReport = append(
-					scoredReport, toPlainTextDetailsLangEn(cve, osFamily))
+					scoredReport, formatPlainTextDetailsLangEn(cve, osFamily))
 			} else {
 				scoredReport = append(
-					scoredReport, toPlainTextUnknownCve(cve, osFamily))
+					scoredReport, formatPlainTextUnknownCve(cve, osFamily))
 			}
 		case "ja":
 			if 0 < cve.CveDetail.Jvn.CvssScore() {
 				scoredReport = append(
-					scoredReport, toPlainTextDetailsLangJa(cve, osFamily))
+					scoredReport, formatPlainTextDetailsLangJa(cve, osFamily))
 			} else if 0 < cve.CveDetail.Nvd.CvssScore() {
 				scoredReport = append(
-					scoredReport, toPlainTextDetailsLangEn(cve, osFamily))
+					scoredReport, formatPlainTextDetailsLangEn(cve, osFamily))
 			} else {
 				scoredReport = append(
-					scoredReport, toPlainTextUnknownCve(cve, osFamily))
+					scoredReport, formatPlainTextUnknownCve(cve, osFamily))
 			}
 		}
 	}
 	for _, cve := range r.UnknownCves {
 		unscoredReport = append(
-			unscoredReport, toPlainTextUnknownCve(cve, osFamily))
+			unscoredReport, formatPlainTextUnknownCve(cve, osFamily))
 	}
 	return
 }

-func toPlainTextUnknownCve(cveInfo models.CveInfo, osFamily string) string {
+func formatPlainTextUnknownCve(cveInfo models.CveInfo, osFamily string) string {
 	cveID := cveInfo.CveDetail.CveID
 	dtable := uitable.New()
 	dtable.MaxColWidth = maxColWidth
@@ -246,11 +279,12 @@ func toPlainTextUnknownCve(cveInfo models.CveInfo, osFamily string) string {
 	}
 	dtable = addPackageInfos(dtable, cveInfo.Packages)
 	dtable = addCpeNames(dtable, cveInfo.CpeNames)
+	dtable.AddRow("Confidence", cveInfo.VulnInfo.Confidence)

 	return fmt.Sprintf("%s", dtable)
 }

-func toPlainTextDetailsLangJa(cveInfo models.CveInfo, osFamily string) string {
+func formatPlainTextDetailsLangJa(cveInfo models.CveInfo, osFamily string) string {
 	cveDetail := cveInfo.CveDetail
 	cveID := cveDetail.CveID
 	jvn := cveDetail.Jvn
@@ -288,11 +322,12 @@ func toPlainTextDetailsLangJa(cveInfo models.CveInfo, osFamily string) string {

 	dtable = addPackageInfos(dtable, cveInfo.Packages)
 	dtable = addCpeNames(dtable, cveInfo.CpeNames)
+	dtable.AddRow("Confidence", cveInfo.VulnInfo.Confidence)

 	return fmt.Sprintf("%s", dtable)
 }

-func toPlainTextDetailsLangEn(d models.CveInfo, osFamily string) string {
+func formatPlainTextDetailsLangEn(d models.CveInfo, osFamily string) string {
 	cveDetail := d.CveDetail
 	cveID := cveDetail.CveID
 	nvd := cveDetail.Nvd
@@ -328,6 +363,7 @@ func toPlainTextDetailsLangEn(d models.CveInfo, osFamily string) string {
 	}
 	dtable = addPackageInfos(dtable, d.Packages)
 	dtable = addCpeNames(dtable, d.CpeNames)
+	dtable.AddRow("Confidence", d.VulnInfo.Confidence)

 	return fmt.Sprintf("%s\n", dtable)
 }
@@ -357,6 +393,21 @@ func distroLinks(cveInfo models.CveInfo, osFamily string) []distroLink {
 			})
 		}
 		return links
+	case "oraclelinux":
+		links := []distroLink{
+			{
+				"Oracle-CVE",
+				fmt.Sprintf(oracleSecurityBaseURL, cveID),
+			},
+		}
+		for _, advisory := range cveInfo.DistroAdvisories {
+			links = append(links, distroLink{
+				// "Oracle-ELSA"
+				advisory.AdvisoryID,
+				fmt.Sprintf(oracleELSABaseBaseURL, advisory.AdvisoryID),
+			})
+		}
+		return links
 	case "amazon":
 		links := []distroLink{
 			{
@@ -431,3 +482,43 @@ func cweURL(cweID string) string {
 func cweJvnURL(cweID string) string {
 	return fmt.Sprintf("http://jvndb.jvn.jp/ja/cwe/%s.html", cweID)
 }
+
+func formatChangelogs(r models.ScanResult) string {
+	buf := []string{}
+	for _, p := range r.Packages {
+		if p.NewVersion == "" {
+			continue
+		}
+		clog := formatOneChangelog(p)
+		buf = append(buf, clog, "\n\n")
+	}
+	return strings.Join(buf, "\n")
+}
+
+func formatOneChangelog(p models.PackageInfo) string {
+	buf := []string{}
+	if p.NewVersion == "" {
+		return ""
+	}
+
+	packVer := fmt.Sprintf("%s -> %s",
+		p.ToStringCurrentVersion(), p.ToStringNewVersion())
+	var delim bytes.Buffer
+	for i := 0; i < len(packVer); i++ {
+		delim.WriteString("-")
+	}
+
+	clog := p.Changelog.Contents
+	if lines := strings.Split(clog, "\n"); len(lines) != 0 {
+		clog = strings.Join(lines[0:len(lines)-1], "\n")
+	}
+
+	switch p.Changelog.Method {
+	case models.FailedToGetChangelog:
+		clog = "No changelogs"
+	case models.FailedToFindVersionInChangelog:
+		clog = "Failed to parse changelogs. For detials, check yourself"
+	}
+	buf = append(buf, packVer, delim.String(), clog)
+	return strings.Join(buf, "\n")
+}
--- a/report/writer.go
+++ b/report/writer.go
@@ -33,6 +33,8 @@ const (
 	redhatSecurityBaseURL = "https://access.redhat.com/security/cve"
 	redhatRHSABaseBaseURL = "https://rhn.redhat.com/errata/%s.html"
 	amazonSecurityBaseURL = "https://alas.aws.amazon.com/%s.html"
+	oracleSecurityBaseURL = "https://linux.oracle.com/cve/%s.html"
+	oracleELSABaseBaseURL = "https://linux.oracle.com/errata/%s.html"

 	ubuntuSecurityBaseURL = "http://people.ubuntu.com/~ubuntu-security/cve"
 	debianTrackerBaseURL  = "https://security-tracker.debian.org/tracker"
--- a/scan/base.go
+++ b/scan/base.go
@@ -34,15 +34,14 @@ type base struct {
 	Distro     config.Distro
 	Platform   models.Platform

-	lackDependencies []string
 	osPackages

 	log  *logrus.Entry
 	errs []error
 }

-func (l *base) ssh(cmd string, sudo bool) sshResult {
-	return sshExec(l.ServerInfo, cmd, sudo, l.log)
+func (l *base) exec(cmd string, sudo bool) execResult {
+	return exec(l.ServerInfo, cmd, sudo, l.log)
 }

 func (l *base) setServerInfo(c config.ServerInfo) {
@@ -77,61 +76,84 @@ func (l base) getPlatform() models.Platform {
 	return l.Platform
 }

-func (l base) getLackDependencies() []string {
-	return l.lackDependencies
-}
-
 func (l base) allContainers() (containers []config.Container, err error) {
-	switch l.ServerInfo.Container.Type {
+	switch l.ServerInfo.Containers.Type {
 	case "", "docker":
-		stdout, err := l.dockerPs("-a --format '{{.ID}} {{.Names}}'")
+		stdout, err := l.dockerPs("-a --format '{{.ID}} {{.Names}} {{.Image}}'")
 		if err != nil {
 			return containers, err
 		}
 		return l.parseDockerPs(stdout)
+	case "lxd":
+		stdout, err := l.lxdPs("-c n")
+		if err != nil {
+			return containers, err
+		}
+		return l.parseLxdPs(stdout)
 	default:
 		return containers, fmt.Errorf(
-			"Not supported yet: %s", l.ServerInfo.Container.Type)
+			"Not supported yet: %s", l.ServerInfo.Containers.Type)
 	}
 }

 func (l *base) runningContainers() (containers []config.Container, err error) {
-	switch l.ServerInfo.Container.Type {
+	switch l.ServerInfo.Containers.Type {
 	case "", "docker":
-		stdout, err := l.dockerPs("--format '{{.ID}} {{.Names}}'")
+		stdout, err := l.dockerPs("--format '{{.ID}} {{.Names}} {{.Image}}'")
 		if err != nil {
 			return containers, err
 		}
 		return l.parseDockerPs(stdout)
+	case "lxd":
+		stdout, err := l.lxdPs("volatile.last_state.power=RUNNING -c n")
+		if err != nil {
+			return containers, err
+		}
+		return l.parseLxdPs(stdout)
 	default:
 		return containers, fmt.Errorf(
-			"Not supported yet: %s", l.ServerInfo.Container.Type)
+			"Not supported yet: %s", l.ServerInfo.Containers.Type)
 	}
 }

 func (l *base) exitedContainers() (containers []config.Container, err error) {
-	switch l.ServerInfo.Container.Type {
+	switch l.ServerInfo.Containers.Type {
 	case "", "docker":
-		stdout, err := l.dockerPs("--filter 'status=exited' --format '{{.ID}} {{.Names}}'")
+		stdout, err := l.dockerPs("--filter 'status=exited' --format '{{.ID}} {{.Names}} {{.Image}}'")
 		if err != nil {
 			return containers, err
 		}
 		return l.parseDockerPs(stdout)
+	case "lxd":
+		stdout, err := l.lxdPs("volatile.last_state.power=STOPPED -c n")
+		if err != nil {
+			return containers, err
+		}
+		return l.parseLxdPs(stdout)
 	default:
 		return containers, fmt.Errorf(
-			"Not supported yet: %s", l.ServerInfo.Container.Type)
+			"Not supported yet: %s", l.ServerInfo.Containers.Type)
 	}
 }

 func (l *base) dockerPs(option string) (string, error) {
 	cmd := fmt.Sprintf("docker ps %s", option)
-	r := l.ssh(cmd, noSudo)
+	r := l.exec(cmd, noSudo)
 	if !r.isSuccess() {
 		return "", fmt.Errorf("Failed to SSH: %s", r)
 	}
 	return r.Stdout, nil
 }

+func (l *base) lxdPs(option string) (string, error) {
+	cmd := fmt.Sprintf("lxc list %s", option)
+	r := l.exec(cmd, noSudo)
+	if !r.isSuccess() {
+		return "", fmt.Errorf("failed to SSH: %s", r)
+	}
+	return r.Stdout, nil
+}
+
 func (l *base) parseDockerPs(stdout string) (containers []config.Container, err error) {
 	lines := strings.Split(stdout, "\n")
 	for _, line := range lines {
@@ -139,41 +161,62 @@ func (l *base) parseDockerPs(stdout string) (containers []config.Container, err
 		if len(fields) == 0 {
 			break
 		}
-		if len(fields) != 2 {
+		if len(fields) != 3 {
 			return containers, fmt.Errorf("Unknown format: %s", line)
 		}
 		containers = append(containers, config.Container{
 			ContainerID: fields[0],
 			Name:        fields[1],
+			Image:       fields[2],
 		})
 	}
 	return
 }

-func (l *base) detectPlatform() error {
+func (l *base) parseLxdPs(stdout string) (containers []config.Container, err error) {
+	lines := strings.Split(stdout, "\n")
+	for i, line := range lines[3:] {
+		if i%2 == 1 {
+			continue
+		}
+		fields := strings.Fields(strings.Replace(line, "|", " ", -1))
+		if len(fields) == 0 {
+			break
+		}
+		if len(fields) != 1 {
+			return containers, fmt.Errorf("Unknown format: %s", line)
+		}
+		containers = append(containers, config.Container{
+			ContainerID: fields[0],
+			Name:        fields[0],
+		})
+	}
+	return
+}
+
+func (l *base) detectPlatform() {
 	ok, instanceID, err := l.detectRunningOnAws()
 	if err != nil {
-		return err
+		l.setPlatform(models.Platform{Name: "other"})
+		return
 	}
 	if ok {
 		l.setPlatform(models.Platform{
 			Name:       "aws",
 			InstanceID: instanceID,
 		})
-		return nil
+		return
 	}

 	//TODO Azure, GCP...
-	l.setPlatform(models.Platform{
-		Name: "other",
-	})
-	return nil
+	l.setPlatform(models.Platform{Name: "other"})
+	return
 }

 func (l base) detectRunningOnAws() (ok bool, instanceID string, err error) {
-	if r := l.ssh("type curl", noSudo); r.isSuccess() {
+	if r := l.exec("type curl", noSudo); r.isSuccess() {
 		cmd := "curl --max-time 1 --retry 3 --noproxy 169.254.169.254 http://169.254.169.254/latest/meta-data/instance-id"
-		r := l.ssh(cmd, noSudo)
+		r := l.exec(cmd, noSudo)
 		if r.isSuccess() {
 			id := strings.TrimSpace(r.Stdout)
 			if !l.isAwsInstanceID(id) {
@@ -191,9 +234,9 @@ func (l base) detectRunningOnAws() (ok bool, instanceID string, err error) {
 		}
 	}

-	if r := l.ssh("type wget", noSudo); r.isSuccess() {
+	if r := l.exec("type wget", noSudo); r.isSuccess() {
 		cmd := "wget --tries=3 --timeout=1 --no-proxy -q -O - http://169.254.169.254/latest/meta-data/instance-id"
-		r := l.ssh(cmd, noSudo)
+		r := l.exec(cmd, noSudo)
 		if r.isSuccess() {
 			id := strings.TrimSpace(r.Stdout)
 			if !l.isAwsInstanceID(id) {
@@ -222,15 +265,31 @@ func (l base) isAwsInstanceID(str string) bool {
 	return awsInstanceIDPattern.MatchString(str)
 }

-func (l *base) convertToModel() (models.ScanResult, error) {
+func (l *base) convertToModel() models.ScanResult {
 	for _, p := range l.VulnInfos {
 		sort.Sort(models.PackageInfosByName(p.Packages))
 	}
 	sort.Sort(l.VulnInfos)

+	ctype := l.ServerInfo.Containers.Type
+	if l.ServerInfo.Container.ContainerID != "" && ctype == "" {
+		ctype = "docker"
+	}
 	container := models.Container{
 		ContainerID: l.ServerInfo.Container.ContainerID,
 		Name:        l.ServerInfo.Container.Name,
+		Image:       l.ServerInfo.Container.Image,
+		Type:        ctype,
+	}
+
+	errs := []string{}
+	for _, e := range l.errs {
+		errs = append(errs, fmt.Sprintf("%s", e))
+	}
+
+	// Avoid null slice being null in JSON
+	for i := range l.VulnInfos {
+		l.VulnInfos[i].NilSliceToEmpty()
 	}

 	return models.ScanResult{
@@ -243,7 +302,8 @@ func (l *base) convertToModel() (models.ScanResult, error) {
 		ScannedCves: l.VulnInfos,
 		Packages:    l.Packages,
 		Optional:    l.ServerInfo.Optional,
-	}, nil
+		Errors:      errs,
+	}
 }

 func (l *base) setErrs(errs []error) {
--- a/scan/base_test.go
+++ b/scan/base_test.go
@@ -30,16 +30,18 @@ func TestParseDockerPs(t *testing.T) {
 		in       string
 		expected []config.Container
 	}{
-		`c7ca0992415a romantic_goldberg
-f570ae647edc agitated_lovelace`,
+		`c7ca0992415a romantic_goldberg ubuntu:14.04.5
+f570ae647edc agitated_lovelace centos:latest`,
 		[]config.Container{
 			{
 				ContainerID: "c7ca0992415a",
 				Name:        "romantic_goldberg",
+				Image:       "ubuntu:14.04.5",
 			},
 			{
 				ContainerID: "f570ae647edc",
 				Name:        "agitated_lovelace",
+				Image:       "centos:latest",
 			},
 		},
 	}
@@ -57,6 +59,44 @@ f570ae647edc agitated_lovelace`,
 	}
 }

+func TestParseLxdPs(t *testing.T) {
+
+	var test = struct {
+		in       string
+		expected []config.Container
+	}{
+		`+-------+
+| NAME  |
+-------+
+| test1 |
+-------+
+| test2 |
+-------+`,
+		[]config.Container{
+			{
+				ContainerID: "test1",
+				Name:        "test1",
+			},
+			{
+				ContainerID: "test2",
+				Name:        "test2",
+			},
+		},
+	}
+
+	r := newRedhat(config.ServerInfo{})
+	actual, err := r.parseLxdPs(test.in)
+	if err != nil {
+		t.Errorf("Error occurred. in: %s, err: %s", test.in, err)
+		return
+	}
+	for i, e := range test.expected {
+		if !reflect.DeepEqual(e, actual[i]) {
+			t.Errorf("expected %v, actual %v", e, actual[i])
+		}
+	}
+}
+
 func TestIsAwsInstanceID(t *testing.T) {
 	var tests = []struct {
 		in       string
--- a/scan/debian.go
+++ b/scan/debian.go
@@ -43,24 +43,38 @@ func newDebian(c config.ServerInfo) *debian {
 	return d
 }

-// Ubuntu, Debian
+// Ubuntu, Debian, Raspbian
 // https://github.com/serverspec/specinfra/blob/master/lib/specinfra/helper/detect_os/debian.rb
 func detectDebian(c config.ServerInfo) (itsMe bool, deb osTypeInterface, err error) {
 	deb = newDebian(c)

-	if r := sshExec(c, "ls /etc/debian_version", noSudo); !r.isSuccess() {
+	if r := exec(c, "ls /etc/debian_version", noSudo); !r.isSuccess() {
 		if r.Error != nil {
-			return false, deb, r.Error
+			return false, deb, nil
 		}
 		if r.ExitStatus == 255 {
 			return false, deb, fmt.Errorf(
 				"Unable to connect via SSH. Check SSH settings. %s", r)
 		}
-		Log.Debugf("Not Debian like Linux. %s", r)
+		util.Log.Debugf("Not Debian like Linux. %s", r)
 		return false, deb, nil
 	}

-	if r := sshExec(c, "lsb_release -ir", noSudo); r.isSuccess() {
+	// Raspbian
+	// lsb_release in Raspbian Jessie returns 'Distributor ID: Raspbian'.
+	// However, lsb_release in Raspbian Wheezy returns 'Distributor ID: Debian'.
+	if r := exec(c, "cat /etc/issue", noSudo); r.isSuccess() {
+		//  e.g.
+		//  Raspbian GNU/Linux 7 \n \l
+		result := strings.Fields(r.Stdout)
+		if len(result) > 2 && result[0] == "Raspbian" {
+			distro := strings.ToLower(trim(result[0]))
+			deb.setDistro(distro, trim(result[2]))
+			return true, deb, nil
+		}
+	}
+
+	if r := exec(c, "lsb_release -ir", noSudo); r.isSuccess() {
 		//  e.g.
 		//  root@fa3ec524be43:/# lsb_release -ir
 		//  Distributor ID:	Ubuntu
@@ -70,7 +84,7 @@ func detectDebian(c config.ServerInfo) (itsMe bool, deb osTypeInterface, err err

 		if len(result) == 0 {
 			deb.setDistro("debian/ubuntu", "unknown")
-			Log.Warnf(
+			util.Log.Warnf(
 				"Unknown Debian/Ubuntu version. lsb_release -ir: %s", r)
 		} else {
 			distro := strings.ToLower(trim(result[1]))
@@ -79,7 +93,7 @@ func detectDebian(c config.ServerInfo) (itsMe bool, deb osTypeInterface, err err
 		return true, deb, nil
 	}

-	if r := sshExec(c, "cat /etc/lsb-release", noSudo); r.isSuccess() {
+	if r := exec(c, "cat /etc/lsb-release", noSudo); r.isSuccess() {
 		//  e.g.
 		//  DISTRIB_ID=Ubuntu
 		//  DISTRIB_RELEASE=14.04
@@ -88,7 +102,7 @@ func detectDebian(c config.ServerInfo) (itsMe bool, deb osTypeInterface, err err
 		re := regexp.MustCompile(`(?s)^DISTRIB_ID=(.+?)\n*DISTRIB_RELEASE=(.+?)\n.*$`)
 		result := re.FindStringSubmatch(trim(r.Stdout))
 		if len(result) == 0 {
-			Log.Warnf(
+			util.Log.Warnf(
 				"Unknown Debian/Ubuntu. cat /etc/lsb-release: %s", r)
 			deb.setDistro("debian/ubuntu", "unknown")
 		} else {
@@ -100,12 +114,12 @@ func detectDebian(c config.ServerInfo) (itsMe bool, deb osTypeInterface, err err

 	// Debian
 	cmd := "cat /etc/debian_version"
-	if r := sshExec(c, cmd, noSudo); r.isSuccess() {
+	if r := exec(c, cmd, noSudo); r.isSuccess() {
 		deb.setDistro("debian", trim(r.Stdout))
 		return true, deb, nil
 	}

-	Log.Debugf("Not Debian like Linux: %s", c.ServerName)
+	util.Log.Debugf("Not Debian like Linux: %s", c.ServerName)
 	return false, deb, nil
 }

@@ -114,28 +128,31 @@ func trim(str string) string {
 }

 func (o *debian) checkIfSudoNoPasswd() error {
-	r := o.ssh("apt-get -v", sudo)
+	cmd := util.PrependProxyEnv("apt-get update")
+	o.log.Infof("Checking... sudo %s", cmd)
+	r := o.exec(cmd, sudo)
 	if !r.isSuccess() {
 		o.log.Errorf("sudo error on %s", r)
 		return fmt.Errorf("Failed to sudo: %s", r)
 	}
-	o.log.Infof("sudo ... OK")
+	o.log.Infof("Sudo... Pass")
 	return nil
 }

 func (o *debian) checkDependencies() error {
 	switch o.Distro.Family {
-	case "ubuntu":
+	case "ubuntu", "raspbian":
 		return nil

 	case "debian":
 		// Debian needs aptitude to get changelogs.
 		// Because unable to get changelogs via apt-get changelog on Debian.
-		name := "aptitude"
-		cmd := name + " -h"
-		if r := o.ssh(cmd, noSudo); !r.isSuccess() {
-			o.lackDependencies = []string{name}
+		if r := o.exec("test -f /usr/bin/aptitude", noSudo); !r.isSuccess() {
+			msg := fmt.Sprintf("aptitude is not installed: %s", r)
+			o.log.Errorf(msg)
+			return fmt.Errorf(msg)
 		}
+		o.log.Infof("Dependencies... Pass")
 		return nil

 	default:
@@ -143,32 +160,6 @@ func (o *debian) checkDependencies() error {
 	}
 }

-func (o *debian) install() error {
-	if len(o.lackDependencies) == 0 {
-		return nil
-	}
-
-	// apt-get update
-	o.log.Infof("apt-get update...")
-	cmd := util.PrependProxyEnv("apt-get update")
-	if r := o.ssh(cmd, sudo); !r.isSuccess() {
-		msg := fmt.Sprintf("Failed to SSH: %s", r)
-		o.log.Errorf(msg)
-		return fmt.Errorf(msg)
-	}
-
-	for _, name := range o.lackDependencies {
-		cmd = util.PrependProxyEnv("apt-get install -y " + name)
-		if r := o.ssh(cmd, sudo); !r.isSuccess() {
-			msg := fmt.Sprintf("Failed to SSH: %s", r)
-			o.log.Errorf(msg)
-			return fmt.Errorf(msg)
-		}
-		o.log.Infof("Installed: " + name)
-	}
-	return nil
-}
-
 func (o *debian) scanPackages() error {
 	var err error
 	var packs []models.PackageInfo
@@ -188,7 +179,7 @@ func (o *debian) scanPackages() error {
 }

 func (o *debian) scanInstalledPackages() (packs []models.PackageInfo, err error) {
-	r := o.ssh("dpkg-query -W", noSudo)
+	r := o.exec("dpkg-query -W", noSudo)
 	if !r.isSuccess() {
 		return packs, fmt.Errorf("Failed to SSH: %s", r)
 	}
@@ -230,21 +221,10 @@ func (o *debian) parseScannedPackagesLine(line string) (name, version string, er
 	return "", "", fmt.Errorf("Unknown format: %s", line)
 }

-func (o *debian) checkRequiredPackagesInstalled() error {
-	if o.Distro.Family == "debian" {
-		if r := o.ssh("test -f /usr/bin/aptitude", noSudo); !r.isSuccess() {
-			msg := fmt.Sprintf("aptitude is not installed: %s", r)
-			o.log.Errorf(msg)
-			return fmt.Errorf(msg)
-		}
-	}
-	return nil
-}
-
 func (o *debian) scanUnsecurePackages(installed []models.PackageInfo) ([]models.VulnInfo, error) {
 	o.log.Infof("apt-get update...")
 	cmd := util.PrependProxyEnv("apt-get update")
-	if r := o.ssh(cmd, sudo); !r.isSuccess() {
+	if r := o.exec(cmd, sudo); !r.isSuccess() {
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
 	}

@@ -277,13 +257,15 @@ func (o *debian) scanUnsecurePackages(installed []models.PackageInfo) ([]models.
 		Distro: o.getServerInfo().Distro,
 		Packs:  upgradablePacks,
 	}
+
 	o.log.Debugf("Ensure changelog cache: %s", current.Name)
-	if err := o.ensureChangelogCache(current); err != nil {
+	var meta *cache.Meta
+	if meta, err = o.ensureChangelogCache(current); err != nil {
 		return nil, err
 	}

 	// Collect CVE information of upgradable packages
-	vulnInfos, err := o.scanVulnInfos(upgradablePacks)
+	vulnInfos, err := o.scanVulnInfos(upgradablePacks, meta)
 	if err != nil {
 		return nil, fmt.Errorf("Failed to scan unsecure packages. err: %s", err)
 	}
@@ -291,35 +273,39 @@ func (o *debian) scanUnsecurePackages(installed []models.PackageInfo) ([]models.
 	return vulnInfos, nil
 }

-func (o *debian) ensureChangelogCache(current cache.Meta) error {
+func (o *debian) ensureChangelogCache(current cache.Meta) (*cache.Meta, error) {
 	// Search from cache
-	old, found, err := cache.DB.GetMeta(current.Name)
+	cached, found, err := cache.DB.GetMeta(current.Name)
 	if err != nil {
-		return fmt.Errorf("Failed to get meta. err: %s", err)
+		return nil, fmt.Errorf(
+			"Failed to get meta. Please remove cache.db and then try again. err: %s", err)
 	}
+
 	if !found {
 		o.log.Debugf("Not found in meta: %s", current.Name)
 		err = cache.DB.EnsureBuckets(current)
 		if err != nil {
-			return fmt.Errorf("Failed to ensure buckets. err: %s", err)
-		}
-	} else {
-		if current.Distro.Family != old.Distro.Family ||
-			current.Distro.Release != old.Distro.Release {
-			o.log.Debugf("Need to refesh meta: %s", current.Name)
-			err = cache.DB.EnsureBuckets(current)
-			if err != nil {
-				return fmt.Errorf("Failed to ensure buckets. err: %s", err)
-			}
-		} else {
-			o.log.Debugf("Reuse meta: %s", current.Name)
+			return nil, fmt.Errorf("Failed to ensure buckets. err: %s", err)
 		}
+		return &current, nil
 	}

+	if current.Distro.Family != cached.Distro.Family ||
+		current.Distro.Release != cached.Distro.Release {
+		o.log.Debugf("Need to refesh meta: %s", current.Name)
+		err = cache.DB.EnsureBuckets(current)
+		if err != nil {
+			return nil, fmt.Errorf("Failed to ensure buckets. err: %s", err)
+		}
+		return &current, nil
+
+	}
+
+	o.log.Debugf("Reuse meta: %s", current.Name)
 	if config.Conf.Debug {
 		cache.DB.PrettyPrint(current)
 	}
-	return nil
+	return &cached, nil
 }

 func (o *debian) fillCandidateVersion(before models.PackageInfoList) (filled []models.PackageInfo, err error) {
@@ -328,7 +314,7 @@ func (o *debian) fillCandidateVersion(before models.PackageInfoList) (filled []m
 		names = append(names, p.Name)
 	}
 	cmd := fmt.Sprintf("LANGUAGE=en_US.UTF-8 apt-cache policy %s", strings.Join(names, " "))
-	r := o.ssh(cmd, sudo)
+	r := o.exec(cmd, noSudo)
 	if !r.isSuccess() {
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
 	}
@@ -350,7 +336,7 @@ func (o *debian) fillCandidateVersion(before models.PackageInfoList) (filled []m

 func (o *debian) GetUpgradablePackNames() (packNames []string, err error) {
 	cmd := util.PrependProxyEnv("LANGUAGE=en_US.UTF-8 apt-get upgrade --dry-run")
-	r := o.ssh(cmd, sudo)
+	r := o.exec(cmd, noSudo)
 	if r.isSuccess(0, 1) {
 		return o.parseAptGetUpgrade(r.Stdout)
 	}
@@ -401,17 +387,10 @@ func (o *debian) parseAptGetUpgrade(stdout string) (upgradableNames []string, er
 	return
 }

-func (o *debian) scanVulnInfos(upgradablePacks []models.PackageInfo) (models.VulnInfos, error) {
-	meta := cache.Meta{
-		Name:   o.getServerInfo().GetServerName(),
-		Distro: o.getServerInfo().Distro,
-		Packs:  upgradablePacks,
-	}
-
-	type strarray []string
+func (o *debian) scanVulnInfos(upgradablePacks []models.PackageInfo, meta *cache.Meta) (models.VulnInfos, error) {
 	resChan := make(chan struct {
 		models.PackageInfo
-		strarray
+		DetectedCveIDs
 	}, len(upgradablePacks))
 	errChan := make(chan error, len(upgradablePacks))
 	reqChan := make(chan models.PackageInfo, len(upgradablePacks))
@@ -435,22 +414,23 @@ func (o *debian) scanVulnInfos(upgradablePacks []models.PackageInfo) (models.Vul
 				func(p models.PackageInfo) {
 					changelog := o.getChangelogCache(meta, p)
 					if 0 < len(changelog) {
-						cveIDs := o.getCveIDFromChangelog(changelog, p.Name, p.Version)
+						cveIDs, _ := o.getCveIDsFromChangelog(changelog, p.Name, p.Version)
 						resChan <- struct {
 							models.PackageInfo
-							strarray
+							DetectedCveIDs
 						}{p, cveIDs}
 						return
 					}

 					// if the changelog is not in cache or failed to get from local cache,
 					// get the changelog of the package via internet.
+					// After that, store it in the cache.
 					if cveIDs, err := o.scanPackageCveIDs(p); err != nil {
 						errChan <- err
 					} else {
 						resChan <- struct {
 							models.PackageInfo
-							strarray
+							DetectedCveIDs
 						}{p, cveIDs}
 					}
 				}(pack)
@@ -458,14 +438,14 @@ func (o *debian) scanVulnInfos(upgradablePacks []models.PackageInfo) (models.Vul
 		}
 	}

-	// { CVE ID: [packageInfo] }
-	cvePackages := make(map[string][]models.PackageInfo)
+	// { DetectedCveID{} : [packageInfo] }
+	cvePackages := make(map[DetectedCveID][]models.PackageInfo)
 	errs := []error{}
 	for i := 0; i < len(upgradablePacks); i++ {
 		select {
 		case pair := <-resChan:
 			pack := pair.PackageInfo
-			cveIDs := pair.strarray
+			cveIDs := pair.DetectedCveIDs
 			for _, cveID := range cveIDs {
 				cvePackages[cveID] = appendPackIfMissing(cvePackages[cveID], pack)
 			}
@@ -481,7 +461,7 @@ func (o *debian) scanVulnInfos(upgradablePacks []models.PackageInfo) (models.Vul
 		return nil, fmt.Errorf("%v", errs)
 	}

-	var cveIDs []string
+	var cveIDs []DetectedCveID
 	for k := range cvePackages {
 		cveIDs = append(cveIDs, k)
 	}
@@ -489,19 +469,31 @@ func (o *debian) scanVulnInfos(upgradablePacks []models.PackageInfo) (models.Vul
 	var vinfos models.VulnInfos
 	for k, v := range cvePackages {
 		vinfos = append(vinfos, models.VulnInfo{
-			CveID:    k,
-			Packages: v,
+			CveID:      k.CveID,
+			Confidence: k.Confidence,
+			Packages:   v,
 		})
 	}
+
+	// Update meta package information of changelog cache to the latest one.
+	meta.Packs = upgradablePacks
+	if err := cache.DB.RefreshMeta(*meta); err != nil {
+		return nil, err
+	}
+
 	return vinfos, nil
 }

-func (o *debian) getChangelogCache(meta cache.Meta, pack models.PackageInfo) string {
+func (o *debian) getChangelogCache(meta *cache.Meta, pack models.PackageInfo) string {
 	cachedPack, found := meta.FindPack(pack.Name)
 	if !found {
+		o.log.Debugf("Not found: %s", pack.Name)
 		return ""
 	}
+
 	if cachedPack.NewVersion != pack.NewVersion {
+		o.log.Debugf("Expired: %s, cache: %s, new: %s",
+			pack.Name, cachedPack.NewVersion, pack.NewVersion)
 		return ""
 	}
 	changelog, err := cache.DB.GetChangelog(meta.Name, pack.Name)
@@ -511,79 +503,138 @@ func (o *debian) getChangelogCache(meta cache.Meta, pack models.PackageInfo) str
 		return ""
 	}
 	if len(changelog) == 0 {
+		o.log.Debugf("Empty string: %s", pack.Name)
 		return ""
 	}

-	o.log.Debugf("Cache hit: %s, len: %d, %s...",
-		meta.Name, len(changelog), util.Truncate(changelog, 30))
+	o.log.Debugf("Hit: %s, %s, cache: %s, new: %s len: %d, %s...",
+		meta.Name, pack.Name, cachedPack.NewVersion, pack.NewVersion, len(changelog), util.Truncate(changelog, 30))
 	return changelog
 }

-func (o *debian) scanPackageCveIDs(pack models.PackageInfo) ([]string, error) {
+func (o *debian) scanPackageCveIDs(pack models.PackageInfo) ([]DetectedCveID, error) {
 	cmd := ""
 	switch o.Distro.Family {
-	case "ubuntu":
-		cmd = fmt.Sprintf(`apt-get changelog %s | grep '\(urgency\|CVE\)'`, pack.Name)
+	case "ubuntu", "raspbian":
+		cmd = fmt.Sprintf(`PAGER=cat apt-get -q=2 changelog %s`, pack.Name)
 	case "debian":
-		cmd = fmt.Sprintf(`aptitude changelog %s | grep '\(urgency\|CVE\)'`, pack.Name)
+		cmd = fmt.Sprintf(`PAGER=cat aptitude -q=2 changelog %s`, pack.Name)
 	}
 	cmd = util.PrependProxyEnv(cmd)

-	r := o.ssh(cmd, noSudo)
+	r := o.exec(cmd, noSudo)
 	if !r.isSuccess() {
 		o.log.Warnf("Failed to SSH: %s", r)
 		// Ignore this Error.
 		return nil, nil
 	}

-	if 0 < len(strings.TrimSpace(r.Stdout)) {
-		err := cache.DB.PutChangelog(o.getServerInfo().GetServerName(), pack.Name, r.Stdout)
+	stdout := strings.Replace(r.Stdout, "\r", "", -1)
+	cveIDs, clog := o.getCveIDsFromChangelog(
+		stdout, pack.Name, pack.Version)
+
+	if clog.Method != models.FailedToGetChangelog {
+		err := cache.DB.PutChangelog(o.getServerInfo().GetServerName(), pack.Name, clog.Contents)
 		if err != nil {
 			return nil, fmt.Errorf("Failed to put changelog into cache")
 		}
 	}
+
 	// No error will be returned. Only logging.
-	return o.getCveIDFromChangelog(r.Stdout, pack.Name, pack.Version), nil
+	return cveIDs, nil
 }

-func (o *debian) getCveIDFromChangelog(changelog string,
-	packName string, versionOrLater string) []string {
+// Debian Version Numbers
+// https://readme.phys.ethz.ch/documentation/debian_version_numbers/
+func (o *debian) getCveIDsFromChangelog(
+	changelog, name, ver string) ([]DetectedCveID, models.Changelog) {

-	if cveIDs, err := o.parseChangelog(changelog, packName, versionOrLater); err == nil {
-		return cveIDs
+	if cveIDs, relevant, err := o.parseChangelog(
+		changelog, name, ver, models.ChangelogExactMatch); err == nil {
+		return cveIDs, relevant
 	}

-	ver := strings.Split(versionOrLater, "ubuntu")[0]
-	if cveIDs, err := o.parseChangelog(changelog, packName, ver); err == nil {
-		return cveIDs
-	}
+	var verAfterColon string
+	var err error

-	splittedByColon := strings.Split(versionOrLater, ":")
+	splittedByColon := strings.Split(ver, ":")
 	if 1 < len(splittedByColon) {
-		ver = splittedByColon[1]
+		verAfterColon = splittedByColon[1]
+		if cveIDs, relevant, err := o.parseChangelog(
+			changelog, name, verAfterColon, models.ChangelogLenientMatch); err == nil {
+			return cveIDs, relevant
+		}
 	}
-	cveIDs, err := o.parseChangelog(changelog, packName, ver)
-	if err == nil {
-		return cveIDs
+
+	delim := []string{"+", "~", "build"}
+	switch o.Distro.Family {
+	case "ubuntu":
+		delim = append(delim, "ubuntu")
+	case "debian":
+	case "Raspbian":
+	}
+
+	for _, d := range delim {
+		ss := strings.Split(ver, d)
+		if 1 < len(ss) {
+			if cveIDs, relevant, err := o.parseChangelog(
+				changelog, name, ss[0], models.ChangelogLenientMatch); err == nil {
+				return cveIDs, relevant
+			}
+		}
+
+		ss = strings.Split(verAfterColon, d)
+		if 1 < len(ss) {
+			if cveIDs, relevant, err := o.parseChangelog(
+				changelog, name, ss[0], models.ChangelogLenientMatch); err == nil {
+				return cveIDs, relevant
+			}
+		}
 	}

 	// Only logging the error.
 	o.log.Error(err)
-	return []string{}
+
+	for i, p := range o.Packages {
+		if p.Name == name {
+			o.Packages[i].Changelog = models.Changelog{
+				Contents: "",
+				Method:   models.FailedToFindVersionInChangelog,
+			}
+		}
+	}
+
+	// If the version is not in changelog, return entire changelog to put into cache
+	return []DetectedCveID{}, models.Changelog{
+		Contents: changelog,
+		Method:   models.FailedToFindVersionInChangelog,
+	}
 }

+// DetectedCveID has CveID, Confidence and DetectionMethod fields
+// LenientMatching will be true if this vulnerability is not detected by accurate version matching.
+// see https://github.com/future-architect/vuls/pull/328
+type DetectedCveID struct {
+	CveID      string
+	Confidence models.Confidence
+}
+
+// DetectedCveIDs is a slice of DetectedCveID
+type DetectedCveIDs []DetectedCveID
+
+var cveRe = regexp.MustCompile(`(CVE-\d{4}-\d{4,})`)
+
 // Collect CVE-IDs included in the changelog.
 // The version which specified in argument(versionOrLater) is excluded.
-func (o *debian) parseChangelog(changelog string,
-	packName string, versionOrLater string) (cveIDs []string, err error) {
-
-	cveRe := regexp.MustCompile(`(CVE-\d{4}-\d{4,})`)
-	stopRe := regexp.MustCompile(fmt.Sprintf(`\(%s\)`, regexp.QuoteMeta(versionOrLater)))
+func (o *debian) parseChangelog(changelog, name, ver string, confidence models.Confidence) ([]DetectedCveID, models.Changelog, error) {
+	buf, cveIDs := []string{}, []string{}
+	stopRe := regexp.MustCompile(fmt.Sprintf(`\(%s\)`, regexp.QuoteMeta(ver)))
 	stopLineFound := false
 	lines := strings.Split(changelog, "\n")
 	for _, line := range lines {
-		if matche := stopRe.MatchString(line); matche {
-			o.log.Debugf("Found the stop line. line: %s", line)
+		buf = append(buf, line)
+		if match := stopRe.MatchString(line); match {
+			//  o.log.Debugf("Found the stop line: %s", line)
 			stopLineFound = true
 			break
 		} else if matches := cveRe.FindAllString(line, -1); 0 < len(matches) {
@@ -593,18 +644,37 @@ func (o *debian) parseChangelog(changelog string,
 		}
 	}
 	if !stopLineFound {
-		return []string{}, fmt.Errorf(
-			"Failed to scan CVE IDs. The version is not in changelog. name: %s, version: %s",
-			packName,
-			versionOrLater,
-		)
+		return nil, models.Changelog{
+				Contents: "",
+				Method:   models.FailedToFindVersionInChangelog,
+			}, fmt.Errorf(
+				"Failed to scan CVE IDs. The version is not in changelog. name: %s, version: %s",
+				name,
+				ver,
+			)
 	}
-	return
+
+	clog := models.Changelog{
+		Contents: strings.Join(buf, "\n"),
+		Method:   string(confidence.DetectionMethod),
+	}
+
+	for i, p := range o.Packages {
+		if p.Name == name {
+			o.Packages[i].Changelog = clog
+		}
+	}
+
+	cves := []DetectedCveID{}
+	for _, id := range cveIDs {
+		cves = append(cves, DetectedCveID{id, confidence})
+	}
+
+	return cves, clog, nil
 }

 func (o *debian) splitAptCachePolicy(stdout string) map[string]string {
-	//  re := regexp.MustCompile(`(?m:^[^ \t]+:$)`)
-	re := regexp.MustCompile(`(?m:^[^ \t]+:\r\n)`)
+	re := regexp.MustCompile(`(?m:^[^ \t]+:\r?\n)`)
 	ii := re.FindAllStringIndex(stdout, -1)
 	ri := []int{}
 	for i := len(ii) - 1; 0 <= i; i-- {
--- a/scan/debian_test.go
+++ b/scan/debian_test.go
@@ -58,11 +58,12 @@ func TestParseScannedPackagesLineDebian(t *testing.T) {

 }

-func TestGetCveIDParsingChangelog(t *testing.T) {
+func TestGetCveIDsFromChangelog(t *testing.T) {

 	var tests = []struct {
-		in       []string
-		expected []string
+		in        []string
+		cveIDs    []DetectedCveID
+		changelog models.Changelog
 	}{
 		{
 			// verubuntu1
@@ -77,17 +78,23 @@ CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
 CVE-2015-3210: heap buffer overflow in pcre_compile2() /
 systemd (228-5) unstable; urgency=medium
 systemd (228-4) unstable; urgency=medium
-systemd (228-3) unstable; urgency=medium
-systemd (228-2) unstable; urgency=medium
-systemd (228-1) unstable; urgency=medium
-systemd (227-3) unstable; urgency=medium
-systemd (227-2) unstable; urgency=medium
-systemd (227-1) unstable; urgency=medium`,
+systemd (228-3) unstable; urgency=medium`,
 			},
-			[]string{
-				"CVE-2015-2325",
-				"CVE-2015-2326",
-				"CVE-2015-3210",
+			[]DetectedCveID{
+				{"CVE-2015-2325", models.ChangelogLenientMatch},
+				{"CVE-2015-2326", models.ChangelogLenientMatch},
+				{"CVE-2015-3210", models.ChangelogLenientMatch},
+			},
+			models.Changelog{
+				Contents: `systemd (229-2) unstable; urgency=medium
+systemd (229-1) unstable; urgency=medium
+systemd (228-6) unstable; urgency=medium
+CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+CVE-2015-3210: heap buffer overflow in pcre_compile2() /
+systemd (228-5) unstable; urgency=medium
+systemd (228-4) unstable; urgency=medium`,
+				Method: models.ChangelogLenientMatchStr,
 			},
 		},
 		{
@@ -96,21 +103,34 @@ systemd (227-1) unstable; urgency=medium`,
 				"libpcre3",
 				"2:8.35-7.1ubuntu1",
 				`pcre3 (2:8.38-2) unstable; urgency=low
-pcre3 (2:8.38-1) unstable; urgency=low
-pcre3 (2:8.35-8) unstable; urgency=low
-pcre3 (2:8.35-7.4) unstable; urgency=medium
-pcre3 (2:8.35-7.3) unstable; urgency=medium
-pcre3 (2:8.35-7.2) unstable; urgency=low
-CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
-CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
-CVE-2015-3210: heap buffer overflow in pcre_compile2() /
-pcre3 (2:8.35-7.1) unstable; urgency=medium
-pcre3 (2:8.35-7) unstable; urgency=medium`,
+		 pcre3 (2:8.38-1) unstable; urgency=low
+		 pcre3 (2:8.35-8) unstable; urgency=low
+		 pcre3 (2:8.35-7.4) unstable; urgency=medium
+		 pcre3 (2:8.35-7.3) unstable; urgency=medium
+		 pcre3 (2:8.35-7.2) unstable; urgency=low
+		 CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 CVE-2015-3210: heap buffer overflow in pcre_compile2() /
+		 pcre3 (2:8.35-7.1) unstable; urgency=medium
+		 pcre3 (2:8.35-7) unstable; urgency=medium`,
 			},
-			[]string{
-				"CVE-2015-2325",
-				"CVE-2015-2326",
-				"CVE-2015-3210",
+			[]DetectedCveID{
+				{"CVE-2015-2325", models.ChangelogLenientMatch},
+				{"CVE-2015-2326", models.ChangelogLenientMatch},
+				{"CVE-2015-3210", models.ChangelogLenientMatch},
+			},
+			models.Changelog{
+				Contents: `pcre3 (2:8.38-2) unstable; urgency=low
+		 pcre3 (2:8.38-1) unstable; urgency=low
+		 pcre3 (2:8.35-8) unstable; urgency=low
+		 pcre3 (2:8.35-7.4) unstable; urgency=medium
+		 pcre3 (2:8.35-7.3) unstable; urgency=medium
+		 pcre3 (2:8.35-7.2) unstable; urgency=low
+		 CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 CVE-2015-3210: heap buffer overflow in pcre_compile2() /
+		 pcre3 (2:8.35-7.1) unstable; urgency=medium`,
+				Method: models.ChangelogLenientMatchStr,
 			},
 		},
 		{
@@ -119,29 +139,38 @@ pcre3 (2:8.35-7) unstable; urgency=medium`,
 				"sysvinit",
 				"2.88dsf-59.2ubuntu3",
 				`sysvinit (2.88dsf-59.3ubuntu1) xenial; urgency=low
-sysvinit (2.88dsf-59.3) unstable; urgency=medium
-CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
-CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
-CVE-2015-3210: heap buffer overflow in pcre_compile2() /
-sysvinit (2.88dsf-59.2ubuntu3) xenial; urgency=medium
-sysvinit (2.88dsf-59.2ubuntu2) wily; urgency=medium
-sysvinit (2.88dsf-59.2ubuntu1) wily; urgency=medium
-CVE-2015-2321: heap buffer overflow in pcre_compile2(). (Closes: #783285)
-sysvinit (2.88dsf-59.2) unstable; urgency=medium
-sysvinit (2.88dsf-59.1ubuntu3) wily; urgency=medium
-CVE-2015-2322: heap buffer overflow in pcre_compile2(). (Closes: #783285)
-sysvinit (2.88dsf-59.1ubuntu2) wily; urgency=medium
-sysvinit (2.88dsf-59.1ubuntu1) wily; urgency=medium
-sysvinit (2.88dsf-59.1) unstable; urgency=medium
-CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
-sysvinit (2.88dsf-59) unstable; urgency=medium
-sysvinit (2.88dsf-58) unstable; urgency=low
-sysvinit (2.88dsf-57) unstable; urgency=low`,
+		 sysvinit (2.88dsf-59.3) unstable; urgency=medium
+		 CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 CVE-2015-3210: heap buffer overflow in pcre_compile2() /
+		 sysvinit (2.88dsf-59.2ubuntu3) xenial; urgency=medium
+		 sysvinit (2.88dsf-59.2ubuntu2) wily; urgency=medium
+		 sysvinit (2.88dsf-59.2ubuntu1) wily; urgency=medium
+		 CVE-2015-2321: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 sysvinit (2.88dsf-59.2) unstable; urgency=medium
+		 sysvinit (2.88dsf-59.1ubuntu3) wily; urgency=medium
+		 CVE-2015-2322: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 sysvinit (2.88dsf-59.1ubuntu2) wily; urgency=medium
+		 sysvinit (2.88dsf-59.1ubuntu1) wily; urgency=medium
+		 sysvinit (2.88dsf-59.1) unstable; urgency=medium
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 sysvinit (2.88dsf-59) unstable; urgency=medium
+		 sysvinit (2.88dsf-58) unstable; urgency=low
+		 sysvinit (2.88dsf-57) unstable; urgency=low`,
 			},
-			[]string{
-				"CVE-2015-2325",
-				"CVE-2015-2326",
-				"CVE-2015-3210",
+			[]DetectedCveID{
+				{"CVE-2015-2325", models.ChangelogExactMatch},
+				{"CVE-2015-2326", models.ChangelogExactMatch},
+				{"CVE-2015-3210", models.ChangelogExactMatch},
+			},
+			models.Changelog{
+				Contents: `sysvinit (2.88dsf-59.3ubuntu1) xenial; urgency=low
+		 sysvinit (2.88dsf-59.3) unstable; urgency=medium
+		 CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 CVE-2015-3210: heap buffer overflow in pcre_compile2() /
+		 sysvinit (2.88dsf-59.2ubuntu3) xenial; urgency=medium`,
+				Method: models.ChangelogExactMatchStr,
 			},
 		},
 		{
@@ -149,55 +178,120 @@ sysvinit (2.88dsf-57) unstable; urgency=low`,
 			[]string{
 				"bsdutils",
 				"1:2.27.1-1ubuntu3",
-				` util-linux (2.27.1-3ubuntu1) xenial; urgency=medium
-util-linux (2.27.1-3) unstable; urgency=medium
-CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
-CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
-CVE-2015-3210: CVE-2016-1000000heap buffer overflow in pcre_compile2() /
-util-linux (2.27.1-2) unstable; urgency=medium
-util-linux (2.27.1-1ubuntu4) xenial; urgency=medium
-util-linux (2.27.1-1ubuntu3) xenial; urgency=medium
-util-linux (2.27.1-1ubuntu2) xenial; urgency=medium
-util-linux (2.27.1-1ubuntu1) xenial; urgency=medium
-util-linux (2.27.1-1) unstable; urgency=medium
-util-linux (2.27-3ubuntu1) xenial; urgency=medium
-util-linux (2.27-3) unstable; urgency=medium
-util-linux (2.27-2) unstable; urgency=medium
-util-linux (2.27-1) unstable; urgency=medium
-util-linux (2.27~rc2-2) experimental; urgency=medium
-util-linux (2.27~rc2-1) experimental; urgency=medium
-util-linux (2.27~rc1-1) experimental; urgency=medium
-util-linux (2.26.2-9) unstable; urgency=medium
-util-linux (2.26.2-8) experimental; urgency=medium
-util-linux (2.26.2-7) experimental; urgency=medium
-util-linux (2.26.2-6ubuntu3) wily; urgency=medium
-CVE-2015-2329: heap buffer overflow in compile_branch(). (Closes: #781795)
-util-linux (2.26.2-6ubuntu2) wily; urgency=medium
-util-linux (2.26.2-6ubuntu1) wily; urgency=medium
-util-linux (2.26.2-6) unstable; urgency=medium`,
+				`util-linux (2.27.1-3ubuntu1) xenial; urgency=medium
+		 util-linux (2.27.1-3) unstable; urgency=medium
+		 CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 CVE-2015-3210: CVE-2016-1000000heap buffer overflow in pcre_compile2() /
+		 util-linux (2.27.1-2) unstable; urgency=medium
+		 util-linux (2.27.1-1ubuntu4) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu3) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu2) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu1) xenial; urgency=medium
+		 util-linux (2.27.1-1) unstable; urgency=medium
+		 util-linux (2.27-3ubuntu1) xenial; urgency=medium`,
 			},
+			[]DetectedCveID{
+				{"CVE-2015-2325", models.ChangelogLenientMatch},
+				{"CVE-2015-2326", models.ChangelogLenientMatch},
+				{"CVE-2015-3210", models.ChangelogLenientMatch},
+				{"CVE-2016-1000000", models.ChangelogLenientMatch},
+			},
+			models.Changelog{
+				Contents: `util-linux (2.27.1-3ubuntu1) xenial; urgency=medium
+		 util-linux (2.27.1-3) unstable; urgency=medium
+		 CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 CVE-2015-3210: CVE-2016-1000000heap buffer overflow in pcre_compile2() /
+		 util-linux (2.27.1-2) unstable; urgency=medium
+		 util-linux (2.27.1-1ubuntu4) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu3) xenial; urgency=medium`,
+				Method: models.ChangelogLenientMatchStr,
+			},
+		},
+		{
+			// 1:ver-ubuntu3
 			[]string{
-				"CVE-2015-2325",
-				"CVE-2015-2326",
-				"CVE-2015-3210",
-				"CVE-2016-1000000",
+				"bsdutils",
+				"1:2.27-3ubuntu3",
+				`util-linux (2.27.1-3ubuntu1) xenial; urgency=medium
+		 util-linux (2.27.1-3) unstable; urgency=medium
+		 CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 CVE-2015-3210: CVE-2016-1000000heap buffer overflow in pcre_compile2() /
+		 util-linux (2.27.1-2) unstable; urgency=medium
+		 util-linux (2.27.1-1ubuntu4) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu3) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu2) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu1) xenial; urgency=medium
+		 util-linux (2.27.1-1) unstable; urgency=medium
+		 util-linux (2.27-3) xenial; urgency=medium`,
+			},
+			[]DetectedCveID{
+				{"CVE-2015-2325", models.ChangelogLenientMatch},
+				{"CVE-2015-2326", models.ChangelogLenientMatch},
+				{"CVE-2015-3210", models.ChangelogLenientMatch},
+				{"CVE-2016-1000000", models.ChangelogLenientMatch},
+			},
+			models.Changelog{
+				Contents: `util-linux (2.27.1-3ubuntu1) xenial; urgency=medium
+		 util-linux (2.27.1-3) unstable; urgency=medium
+		 CVE-2015-2325: heap buffer overflow in compile_branch(). (Closes: #781795)
+		 CVE-2015-2326: heap buffer overflow in pcre_compile2(). (Closes: #783285)
+		 CVE-2015-3210: CVE-2016-1000000heap buffer overflow in pcre_compile2() /
+		 util-linux (2.27.1-2) unstable; urgency=medium
+		 util-linux (2.27.1-1ubuntu4) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu3) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu2) xenial; urgency=medium
+		 util-linux (2.27.1-1ubuntu1) xenial; urgency=medium
+		 util-linux (2.27.1-1) unstable; urgency=medium
+		 util-linux (2.27-3) xenial; urgency=medium`,
+				Method: models.ChangelogLenientMatchStr,
+			},
+		},
+		{
+			// https://github.com/future-architect/vuls/pull/350
+			[]string{
+				"tar",
+				"1.27.1-2+b1",
+				`tar (1.27.1-2+deb8u1) jessie-security; urgency=high
+		   * CVE-2016-6321: Bypassing the extract path name.
+		 tar (1.27.1-2) unstable; urgency=low`,
+			},
+			[]DetectedCveID{
+				{"CVE-2016-6321", models.ChangelogLenientMatch},
+			},
+			models.Changelog{
+				Contents: `tar (1.27.1-2+deb8u1) jessie-security; urgency=high
+		   * CVE-2016-6321: Bypassing the extract path name.
+		 tar (1.27.1-2) unstable; urgency=low`,
+				Method: models.ChangelogLenientMatchStr,
 			},
 		},
 	}

 	d := newDebian(config.ServerInfo{})
-	for _, tt := range tests {
-		actual := d.getCveIDFromChangelog(tt.in[2], tt.in[0], tt.in[1])
-		if len(actual) != len(tt.expected) {
-			t.Errorf("Len of return array are'nt same. expected %#v, actual %#v", tt.expected, actual)
+	d.Distro.Family = "ubuntu"
+	for i, tt := range tests {
+		aCveIDs, aClog := d.getCveIDsFromChangelog(tt.in[2], tt.in[0], tt.in[1])
+		if len(aCveIDs) != len(tt.cveIDs) {
+			t.Errorf("[%d] Len of return array are'nt same. expected %#v, actual %#v", i, tt.cveIDs, aCveIDs)
 			t.Errorf(pp.Sprintf("%s", tt.in))
 			continue
 		}
-		for i := range tt.expected {
-			if actual[i] != tt.expected[i] {
-				t.Errorf("expected %s, actual %s", tt.expected[i], actual[i])
+		for j := range tt.cveIDs {
+			if !reflect.DeepEqual(tt.cveIDs[j], aCveIDs[j]) {
+				t.Errorf("[%d] expected %v, actual %v", i, tt.cveIDs[j], aCveIDs[j])
 			}
 		}
+
+		if aClog.Contents != tt.changelog.Contents {
+			t.Errorf(pp.Sprintf("expected: %s, actual: %s", tt.changelog.Contents, aClog.Contents))
+		}
+
+		if aClog.Method != tt.changelog.Method {
+			t.Errorf(pp.Sprintf("expected: %s, actual: %s", tt.changelog.Method, aClog.Method))
+		}
 	}
 }

@@ -545,7 +639,7 @@ func TestGetChangelogCache(t *testing.T) {
 	}

 	d := newDebian(config.ServerInfo{})
-	actual := d.getChangelogCache(meta, pack)
+	actual := d.getChangelogCache(&meta, pack)
 	if actual != "" {
 		t.Errorf("Failed to get empty stirng from cache:")
 	}
@@ -555,21 +649,21 @@ func TestGetChangelogCache(t *testing.T) {
 		t.Errorf("Failed to put changelog: %s", err)
 	}

-	actual = d.getChangelogCache(meta, pack)
+	actual = d.getChangelogCache(&meta, pack)
 	if actual != clog {
 		t.Errorf("Failed to get changelog from cache: %s", actual)
 	}

 	// increment a version of the pack
 	pack.NewVersion = "1.0.2"
-	actual = d.getChangelogCache(meta, pack)
+	actual = d.getChangelogCache(&meta, pack)
 	if actual != "" {
 		t.Errorf("The changelog is not invalidated: %s", actual)
 	}

 	// change a name of the pack
 	pack.Name = "bash"
-	actual = d.getChangelogCache(meta, pack)
+	actual = d.getChangelogCache(&meta, pack)
 	if actual != "" {
 		t.Errorf("The changelog is not invalidated: %s", actual)
 	}
--- a/scan/executil.go
+++ b/scan/executil.go
@@ -25,7 +25,7 @@ import (
 	"io/ioutil"
 	"net"
 	"os"
-	"os/exec"
+	ex "os/exec"
 	"strings"
 	"syscall"
 	"time"
@@ -39,7 +39,7 @@ import (
 	"github.com/future-architect/vuls/util"
 )

-type sshResult struct {
+type execResult struct {
 	Servername string
 	Host       string
 	Port       string
@@ -50,16 +50,13 @@ type sshResult struct {
 	Error      error
 }

-func (s sshResult) String() string {
+func (s execResult) String() string {
 	return fmt.Sprintf(
-		"SSHResult: servername: %s, cmd: %s, exitstatus: %d, stdout: %s, stderr: %s, err: %s",
+		"execResult: servername: %s\n  cmd: %s\n  exitstatus: %d\n  stdout: %s\n  stderr: %s\n  err: %s",
 		s.Servername, s.Cmd, s.ExitStatus, s.Stdout, s.Stderr, s.Error)
 }

-func (s sshResult) isSuccess(expectedStatusCodes ...int) bool {
-	if s.Error != nil {
-		return false
-	}
+func (s execResult) isSuccess(expectedStatusCodes ...int) bool {
 	if len(expectedStatusCodes) == 0 {
 		return s.ExitStatus == 0
 	}
@@ -68,38 +65,36 @@ func (s sshResult) isSuccess(expectedStatusCodes ...int) bool {
 			return true
 		}
 	}
+	if s.Error != nil {
+		return false
+	}
 	return false
 }

-// Sudo is Const value for sudo mode
+// sudo is Const value for sudo mode
 const sudo = true

-// NoSudo is Const value for normal user mode
+// noSudo is Const value for normal user mode
 const noSudo = false

-func parallelSSHExec(fn func(osTypeInterface) error, timeoutSec ...int) (errs []error) {
-	resChan := make(chan string, len(servers))
-	errChan := make(chan error, len(servers))
-	defer close(errChan)
+//  Issue commands to the target servers in parallel via SSH or local execution.  If execution fails, the server will be excluded from the target server list(servers) and added to the error server list(errServers).
+func parallelExec(fn func(osTypeInterface) error, timeoutSec ...int) {
+	resChan := make(chan osTypeInterface, len(servers))
 	defer close(resChan)

 	for _, s := range servers {
 		go func(s osTypeInterface) {
 			defer func() {
 				if p := recover(); p != nil {
-					logrus.Debugf("Panic: %s on %s",
+					util.Log.Debugf("Panic: %s on %s",
 						p, s.getServerInfo().GetServerName())
 				}
 			}()
 			if err := fn(s); err != nil {
-				errChan <- fmt.Errorf("%s@%s:%s: %s",
-					s.getServerInfo().User,
-					s.getServerInfo().Host,
-					s.getServerInfo().Port,
-					err,
-				)
+				s.setErrs([]error{err})
+				resChan <- s
 			} else {
-				resChan <- s.getServerInfo().GetServerName()
+				resChan <- s
 			}
 		}(s)
 	}
@@ -111,45 +106,52 @@ func parallelSSHExec(fn func(osTypeInterface) error, timeoutSec ...int) (errs []
 		timeout = timeoutSec[0]
 	}

-	var snames []string
+	var successes []osTypeInterface
 	isTimedout := false
 	for i := 0; i < len(servers); i++ {
 		select {
 		case s := <-resChan:
-			snames = append(snames, s)
-		case err := <-errChan:
-			errs = append(errs, err)
+			if len(s.getErrs()) == 0 {
+				successes = append(successes, s)
+			} else {
+				util.Log.Errorf("Error: %s, err: %s",
+					s.getServerInfo().GetServerName(), s.getErrs())
+				errServers = append(errServers, s)
+			}
 		case <-time.After(time.Duration(timeout) * time.Second):
 			isTimedout = true
 		}
 	}

-	// collect timed out servernames
-	var timedoutSnames []string
 	if isTimedout {
+		// set timed out error and append to errServers
 		for _, s := range servers {
 			name := s.getServerInfo().GetServerName()
 			found := false
-			for _, t := range snames {
-				if name == t {
+			for _, ss := range successes {
+				if name == ss.getServerInfo().GetServerName() {
 					found = true
 					break
 				}
 			}
 			if !found {
-				timedoutSnames = append(timedoutSnames, name)
+				msg := fmt.Sprintf("Timed out: %s",
+					s.getServerInfo().GetServerName())
+				util.Log.Errorf(msg)
+				s.setErrs([]error{fmt.Errorf(msg)})
+				errServers = append(errServers, s)
 			}
 		}
 	}
-	if isTimedout {
-		errs = append(errs, fmt.Errorf(
-			"Timed out: %s", timedoutSnames))
-	}
+	servers = successes
 	return
 }

-func sshExec(c conf.ServerInfo, cmd string, sudo bool, log ...*logrus.Entry) (result sshResult) {
-	if conf.Conf.SSHExternal {
+func exec(c conf.ServerInfo, cmd string, sudo bool, log ...*logrus.Entry) (result execResult) {
+	if c.Port == "local" &&
+		(c.Host == "127.0.0.1" || c.Host == "localhost") {
+		result = localExec(c, cmd, sudo)
+	} else if conf.Conf.SSHExternal {
 		result = sshExecExternal(c, cmd, sudo)
 	} else {
 		result = sshExecNative(c, cmd, sudo)
@@ -160,7 +162,37 @@ func sshExec(c conf.ServerInfo, cmd string, sudo bool, log ...*logrus.Entry) (re
 	return
 }

-func sshExecNative(c conf.ServerInfo, cmd string, sudo bool) (result sshResult) {
+func localExec(c conf.ServerInfo, cmdstr string, sudo bool) (result execResult) {
+	cmdstr = decorateCmd(c, cmdstr, sudo)
+	var cmd *ex.Cmd
+	if c.Distro.Family == "FreeBSD" {
+		cmd = ex.Command("/bin/sh", "-c", cmdstr)
+	} else {
+		cmd = ex.Command("/bin/bash", "-c", cmdstr)
+	}
+	var stdoutBuf, stderrBuf bytes.Buffer
+	cmd.Stdout = &stdoutBuf
+	cmd.Stderr = &stderrBuf
+
+	if err := cmd.Run(); err != nil {
+		result.Error = err
+		if exitError, ok := err.(*ex.ExitError); ok {
+			waitStatus := exitError.Sys().(syscall.WaitStatus)
+			result.ExitStatus = waitStatus.ExitStatus()
+		} else {
+			result.ExitStatus = 999
+		}
+	} else {
+		result.ExitStatus = 0
+	}
+
+	result.Stdout = stdoutBuf.String()
+	result.Stderr = stderrBuf.String()
+	result.Cmd = strings.Replace(cmdstr, "\n", "", -1)
+	return
+}
+
+func sshExecNative(c conf.ServerInfo, cmd string, sudo bool) (result execResult) {
 	result.Servername = c.ServerName
 	result.Host = c.Host
 	result.Port = c.Port
@@ -190,7 +222,7 @@ func sshExecNative(c conf.ServerInfo, cmd string, sudo bool) (result sshResult)
 		ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud
 		ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud
 	}
-	if err = session.RequestPty("xterm", 400, 256, modes); err != nil {
+	if err = session.RequestPty("xterm", 400, 1000, modes); err != nil {
 		result.Error = fmt.Errorf(
 			"Failed to request for pseudo terminal. servername: %s, err: %s",
 			c.ServerName, err)
@@ -202,7 +234,7 @@ func sshExecNative(c conf.ServerInfo, cmd string, sudo bool) (result sshResult)
 	session.Stdout = &stdoutBuf
 	session.Stderr = &stderrBuf

-	cmd = decolateCmd(c, cmd, sudo)
+	cmd = decorateCmd(c, cmd, sudo)
 	if err := session.Run(cmd); err != nil {
 		if exitErr, ok := err.(*ssh.ExitError); ok {
 			result.ExitStatus = exitErr.ExitStatus()
@@ -219,14 +251,14 @@ func sshExecNative(c conf.ServerInfo, cmd string, sudo bool) (result sshResult)
 	return
 }

-func sshExecExternal(c conf.ServerInfo, cmd string, sudo bool) (result sshResult) {
-	sshBinaryPath, err := exec.LookPath("ssh")
+func sshExecExternal(c conf.ServerInfo, cmd string, sudo bool) (result execResult) {
+	sshBinaryPath, err := ex.LookPath("ssh")
 	if err != nil {
 		return sshExecNative(c, cmd, sudo)
 	}

 	defaultSSHArgs := []string{
-		"-t",
+		"-tt",
 		"-o", "StrictHostKeyChecking=no",
 		"-o", "UserKnownHostsFile=/dev/null",
 		"-o", "LogLevel=quiet",
@@ -252,17 +284,17 @@ func sshExecExternal(c conf.ServerInfo, cmd string, sudo bool) (result sshResult
 		args = append(args, "-o", "PasswordAuthentication=no")
 	}

-	cmd = decolateCmd(c, cmd, sudo)
-	//  cmd = fmt.Sprintf("stty cols 256; set -o pipefail; %s", cmd)
+	cmd = decorateCmd(c, cmd, sudo)
+	cmd = fmt.Sprintf("stty cols 1000; %s", cmd)

 	args = append(args, cmd)
-	execCmd := exec.Command(sshBinaryPath, args...)
+	execCmd := ex.Command(sshBinaryPath, args...)

 	var stdoutBuf, stderrBuf bytes.Buffer
 	execCmd.Stdout = &stdoutBuf
 	execCmd.Stderr = &stderrBuf
 	if err := execCmd.Run(); err != nil {
-		if e, ok := err.(*exec.ExitError); ok {
+		if e, ok := err.(*ex.ExitError); ok {
 			if s, ok := e.Sys().(syscall.WaitStatus); ok {
 				result.ExitStatus = s.ExitStatus()
 			} else {
@@ -291,22 +323,27 @@ func getSSHLogger(log ...*logrus.Entry) *logrus.Entry {
 	return log[0]
 }

-func decolateCmd(c conf.ServerInfo, cmd string, sudo bool) string {
+func decorateCmd(c conf.ServerInfo, cmd string, sudo bool) string {
 	if sudo && c.User != "root" && !c.IsContainer() {
 		cmd = fmt.Sprintf("sudo -S %s", cmd)
 		cmd = strings.Replace(cmd, "|", "| sudo ", -1)
 	}

-	if c.Distro.Family != "FreeBSD" {
-		// set pipefail option. Bash only
-		// http://unix.stackexchange.com/questions/14270/get-exit-status-of-process-thats-piped-to-another
-		cmd = fmt.Sprintf("set -o pipefail; %s", cmd)
-	}
+	// If you are using pipe and you want to detect preprocessing errors, remove comment out
+	//  switch c.Distro.Family {
+	//  case "FreeBSD", "ubuntu", "debian", "raspbian":
+	//  default:
+	//      // set pipefail option. Bash only
+	//      // http://unix.stackexchange.com/questions/14270/get-exit-status-of-process-thats-piped-to-another
+	//      cmd = fmt.Sprintf("set -o pipefail; %s", cmd)
+	//  }

 	if c.IsContainer() {
-		switch c.Container.Type {
+		switch c.Containers.Type {
 		case "", "docker":
 			cmd = fmt.Sprintf(`docker exec %s /bin/bash -c "%s"`, c.Container.ContainerID, cmd)
+		case "lxd":
+			cmd = fmt.Sprintf(`lxc exec %s -- /bin/bash -c "%s"`, c.Container.Name, cmd)
 		}
 	}
 	//  cmd = fmt.Sprintf("set -x; %s", cmd)
--- a/scan/freebsd.go
+++ b/scan/freebsd.go
@@ -46,22 +46,22 @@ func detectFreebsd(c config.ServerInfo) (itsMe bool, bsd osTypeInterface) {
 	// Prevent from adding `set -o pipefail` option
 	c.Distro = config.Distro{Family: "FreeBSD"}

-	if r := sshExec(c, "uname", noSudo); r.isSuccess() {
+	if r := exec(c, "uname", noSudo); r.isSuccess() {
 		if strings.Contains(r.Stdout, "FreeBSD") == true {
-			if b := sshExec(c, "uname -r", noSudo); b.isSuccess() {
+			if b := exec(c, "freebsd-version", noSudo); b.isSuccess() {
 				rel := strings.TrimSpace(b.Stdout)
 				bsd.setDistro("FreeBSD", rel)
 				return true, bsd
 			}
 		}
 	}
-	Log.Debugf("Not FreeBSD. servernam: %s", c.ServerName)
+	util.Log.Debugf("Not FreeBSD. servernam: %s", c.ServerName)
 	return false, bsd
 }

 func (o *bsd) checkIfSudoNoPasswd() error {
 	// FreeBSD doesn't need root privilege
-	o.log.Infof("sudo ... OK")
+	o.log.Infof("sudo ... No need")
 	return nil
 }

@@ -69,14 +69,6 @@ func (o *bsd) checkDependencies() error {
 	return nil
 }

-func (o *bsd) install() error {
-	return nil
-}
-
-func (o *bsd) checkRequiredPackagesInstalled() error {
-	return nil
-}
-
 func (o *bsd) scanPackages() error {
 	var err error
 	var packs []models.PackageInfo
@@ -97,7 +89,7 @@ func (o *bsd) scanPackages() error {

 func (o *bsd) scanInstalledPackages() ([]models.PackageInfo, error) {
 	cmd := util.PrependProxyEnv("pkg version -v")
-	r := o.ssh(cmd, noSudo)
+	r := o.exec(cmd, noSudo)
 	if !r.isSuccess() {
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
 	}
@@ -107,13 +99,13 @@ func (o *bsd) scanInstalledPackages() ([]models.PackageInfo, error) {
 func (o *bsd) scanUnsecurePackages() (vulnInfos []models.VulnInfo, err error) {
 	const vulndbPath = "/tmp/vuln.db"
 	cmd := "rm -f " + vulndbPath
-	r := o.ssh(cmd, noSudo)
+	r := o.exec(cmd, noSudo)
 	if !r.isSuccess(0) {
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
 	}

 	cmd = util.PrependProxyEnv("pkg audit -F -r -f " + vulndbPath)
-	r = o.ssh(cmd, noSudo)
+	r = o.exec(cmd, noSudo)
 	if !r.isSuccess(0, 1) {
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
 	}
@@ -167,6 +159,7 @@ func (o *bsd) scanUnsecurePackages() (vulnInfos []models.VulnInfo, err error) {
 			CveID:            k,
 			Packages:         packs,
 			DistroAdvisories: disAdvs,
+			Confidence:       models.PkgAuditMatch,
 		})
 	}
 	return
--- a/scan/redhat.go
+++ b/scan/redhat.go
@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"regexp"
 	"sort"
-	"strconv"
 	"strings"
 	"time"

@@ -49,22 +48,39 @@ func newRedhat(c config.ServerInfo) *redhat {
 func detectRedhat(c config.ServerInfo) (itsMe bool, red osTypeInterface) {
 	red = newRedhat(c)

-	if r := sshExec(c, "ls /etc/fedora-release", noSudo); r.isSuccess() {
+	if r := exec(c, "ls /etc/fedora-release", noSudo); r.isSuccess() {
 		red.setDistro("fedora", "unknown")
-		Log.Warn("Fedora not tested yet: %s", r)
+		util.Log.Warn("Fedora not tested yet: %s", r)
 		return true, red
 	}

-	if r := sshExec(c, "ls /etc/redhat-release", noSudo); r.isSuccess() {
+	if r := exec(c, "ls /etc/oracle-release", noSudo); r.isSuccess() {
+		// Need to discover Oracle Linux first, because it provides an
+		// /etc/redhat-release that matches the upstream distribution
+		if r := exec(c, "cat /etc/oracle-release", noSudo); r.isSuccess() {
+			re := regexp.MustCompile(`(.*) release (\d[\d.]*)`)
+			result := re.FindStringSubmatch(strings.TrimSpace(r.Stdout))
+			if len(result) != 3 {
+				util.Log.Warn("Failed to parse Oracle Linux version: %s", r)
+				return true, red
+			}
+
+			release := result[2]
+			red.setDistro("oraclelinux", release)
+			return true, red
+		}
+	}
+
+	if r := exec(c, "ls /etc/redhat-release", noSudo); r.isSuccess() {
 		// https://www.rackaid.com/blog/how-to-determine-centos-or-red-hat-version/
 		// e.g.
 		// $ cat /etc/redhat-release
 		// CentOS release 6.5 (Final)
-		if r := sshExec(c, "cat /etc/redhat-release", noSudo); r.isSuccess() {
+		if r := exec(c, "cat /etc/redhat-release", noSudo); r.isSuccess() {
 			re := regexp.MustCompile(`(.*) release (\d[\d.]*)`)
 			result := re.FindStringSubmatch(strings.TrimSpace(r.Stdout))
 			if len(result) != 3 {
-				Log.Warn("Failed to parse RedHat/CentOS version: %s", r)
+				util.Log.Warn("Failed to parse RedHat/CentOS version: %s", r)
 				return true, red
 			}

@@ -80,10 +96,10 @@ func detectRedhat(c config.ServerInfo) (itsMe bool, red osTypeInterface) {
 		return true, red
 	}

-	if r := sshExec(c, "ls /etc/system-release", noSudo); r.isSuccess() {
+	if r := exec(c, "ls /etc/system-release", noSudo); r.isSuccess() {
 		family := "amazon"
 		release := "unknown"
-		if r := sshExec(c, "cat /etc/system-release", noSudo); r.isSuccess() {
+		if r := exec(c, "cat /etc/system-release", noSudo); r.isSuccess() {
 			fields := strings.Fields(r.Stdout)
 			if len(fields) == 5 {
 				release = fields[4]
@@ -93,89 +109,119 @@ func detectRedhat(c config.ServerInfo) (itsMe bool, red osTypeInterface) {
 		return true, red
 	}

-	Log.Debugf("Not RedHat like Linux. servername: %s", c.ServerName)
+	util.Log.Debugf("Not RedHat like Linux. servername: %s", c.ServerName)
 	return false, red
 }

 func (o *redhat) checkIfSudoNoPasswd() error {
-	r := o.ssh("yum --version", o.sudo())
-	if !r.isSuccess() {
-		o.log.Errorf("sudo error on %s", r)
-		return fmt.Errorf("Failed to sudo: %s", r)
+	if !o.sudo() {
+		o.log.Infof("sudo ... No need")
+		return nil
 	}
-	o.log.Infof("sudo ... OK")
+
+	type cmd struct {
+		cmd                 string
+		expectedStatusCodes []int
+	}
+	var cmds []cmd
+	var zero = []int{0}
+
+	switch o.Distro.Family {
+	case "centos":
+		cmds = []cmd{
+			{"yum --changelog --assumeno update yum", []int{0, 1}},
+		}
+
+	case "rhel", "oraclelinux":
+		majorVersion, err := o.Distro.MajorVersion()
+		if err != nil {
+			return fmt.Errorf("Not implemented yet: %s, err: %s", o.Distro, err)
+		}
+
+		if majorVersion < 6 {
+			cmds = []cmd{
+				{"yum --color=never repolist", zero},
+				{"yum --color=never check-update", []int{0, 100}},
+				{"yum --color=never list-security --security", zero},
+				{"yum --color=never info-security", zero},
+			}
+		} else {
+			cmds = []cmd{
+				{"yum --color=never repolist", zero},
+				{"yum --color=never check-update", []int{0, 100}},
+				{"yum --color=never --security updateinfo list updates", zero},
+				{"yum --color=never --security updateinfo updates", zero},
+			}
+		}
+	}
+
+	for _, c := range cmds {
+		cmd := util.PrependProxyEnv(c.cmd)
+		o.log.Infof("Checking... sudo %s", cmd)
+		r := o.exec(util.PrependProxyEnv(cmd), o.sudo())
+		if !r.isSuccess(c.expectedStatusCodes...) {
+			o.log.Errorf("Check sudo or proxy settings: %s", r)
+			return fmt.Errorf("Failed to sudo: %s", r)
+		}
+	}
+	o.log.Infof("Sudo... Pass")
 	return nil
 }

-// CentOS 5 ... yum-changelog
-// CentOS 6 ... yum-plugin-changelog
-// CentOS 7 ... yum-plugin-changelog
-// RHEL, Amazon ... no additinal packages needed
+// CentOS 6, 7 	... yum-plugin-changelog
+// RHEL 5     	... yum-security
+// RHEL 6, 7    ... -
+// Amazon 		... -
 func (o *redhat) checkDependencies() error {
-	switch o.Distro.Family {
-	case "rhel", "amazon":
-		//  o.log.Infof("Nothing to do")
+	var packName string
+	if o.Distro.Family == "amazon" {
 		return nil
+	}

-	case "centos":
-		var majorVersion int
-		if 0 < len(o.Distro.Release) {
-			majorVersion, _ = strconv.Atoi(strings.Split(o.Distro.Release, ".")[0])
-		} else {
-			return fmt.Errorf("Not implemented yet: %s", o.Distro)
-		}
+	majorVersion, err := o.Distro.MajorVersion()
+	if err != nil {
+		msg := fmt.Sprintf("Not implemented yet: %s, err: %s", o.Distro, err)
+		o.log.Errorf(msg)
+		return fmt.Errorf(msg)
+	}

-		var name = "yum-plugin-changelog"
+	if o.Distro.Family == "centos" {
 		if majorVersion < 6 {
-			name = "yum-changelog"
+			msg := fmt.Sprintf("CentOS %s is not supported", o.Distro.Release)
+			o.log.Errorf(msg)
+			return fmt.Errorf(msg)
 		}

-		cmd := "rpm -q " + name
-		if r := o.ssh(cmd, noSudo); r.isSuccess() {
+		// --assumeno option of yum is needed.
+		cmd := "yum -h | grep assumeno"
+		if r := o.exec(cmd, noSudo); !r.isSuccess() {
+			msg := fmt.Sprintf("Installed yum is old. Please update yum and then retry")
+			o.log.Errorf(msg)
+			return fmt.Errorf(msg)
+		}
+	}
+
+	switch o.Distro.Family {
+	case "centos":
+		packName = "yum-plugin-changelog"
+	case "rhel", "oraclelinux":
+		if majorVersion < 6 {
+			packName = "yum-security"
+		} else {
+			// yum-plugin-security is installed by default on RHEL6, 7
 			return nil
 		}
-		o.lackDependencies = []string{name}
-		return nil
-
 	default:
 		return fmt.Errorf("Not implemented yet: %s", o.Distro)
 	}
-}

-func (o *redhat) install() error {
-	for _, name := range o.lackDependencies {
-		cmd := util.PrependProxyEnv("yum install -y " + name)
-		if r := o.ssh(cmd, sudo); !r.isSuccess() {
-			return fmt.Errorf("Failed to SSH: %s", r)
-		}
-		o.log.Infof("Installed: %s", name)
-	}
-	return nil
-}
-
-func (o *redhat) checkRequiredPackagesInstalled() error {
-	if o.Distro.Family == "centos" {
-		var majorVersion int
-		if 0 < len(o.Distro.Release) {
-			majorVersion, _ = strconv.Atoi(strings.Split(o.Distro.Release, ".")[0])
-		} else {
-			msg := fmt.Sprintf("Not implemented yet: %s", o.Distro)
-			o.log.Errorf(msg)
-			return fmt.Errorf(msg)
-		}
-
-		var packName = "yum-plugin-changelog"
-		if majorVersion < 6 {
-			packName = "yum-changelog"
-		}
-
-		cmd := "rpm -q " + packName
-		if r := o.ssh(cmd, noSudo); !r.isSuccess() {
-			msg := fmt.Sprintf("%s is not installed", packName)
-			o.log.Errorf(msg)
-			return fmt.Errorf(msg)
-		}
+	cmd := "rpm -q " + packName
+	if r := o.exec(cmd, noSudo); !r.isSuccess() {
+		msg := fmt.Sprintf("%s is not installed", packName)
+		o.log.Errorf(msg)
+		return fmt.Errorf(msg)
 	}
+	o.log.Infof("Dependencies... Pass")
 	return nil
 }

@@ -199,7 +245,7 @@ func (o *redhat) scanPackages() error {

 func (o *redhat) scanInstalledPackages() (installedPackages models.PackageInfoList, err error) {
 	cmd := "rpm -qa --queryformat '%{NAME}\t%{VERSION}\t%{RELEASE}\n'"
-	r := o.ssh(cmd, noSudo)
+	r := o.exec(cmd, noSudo)
 	if r.isSuccess() {
 		//  e.g.
 		// openssl	1.0.1e	30.el6.11
@@ -236,7 +282,7 @@ func (o *redhat) parseScannedPackagesLine(line string) (models.PackageInfo, erro

 func (o *redhat) scanVulnInfos() ([]models.VulnInfo, error) {
 	if o.Distro.Family != "centos" {
-		// Amazon, RHEL has yum updateinfo as default
+		// Amazon, RHEL, Oracle Linux has yum updateinfo as default
 		// yum updateinfo can collenct vendor advisory information.
 		return o.scanUnsecurePackagesUsingYumPluginSecurity()
 	}
@@ -254,7 +300,7 @@ func (o *redhat) scanUnsecurePackagesUsingYumCheckUpdate() (models.VulnInfos, er
 		cmd = fmt.Sprintf(cmd, "")
 	}

-	r := o.ssh(util.PrependProxyEnv(cmd), sudo)
+	r := o.exec(util.PrependProxyEnv(cmd), noSudo)
 	if !r.isSuccess(0, 100) {
 		//returns an exit code of 100 if there are available updates.
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
@@ -284,11 +330,25 @@ func (o *redhat) scanUnsecurePackagesUsingYumCheckUpdate() (models.VulnInfos, er

 	// { packageName: changelog-lines }
 	var rpm2changelog map[string]*string
-	rpm2changelog, err = o.parseAllChangelog(allChangelog)
+	rpm2changelog, err = o.divideChangelogByPackage(allChangelog)
 	if err != nil {
 		return nil, fmt.Errorf("Failed to parseAllChangelog. err: %s", err)
 	}

+	for name, clog := range rpm2changelog {
+		for i, p := range o.Packages {
+			n := fmt.Sprintf("%s-%s-%s",
+				p.Name, p.NewVersion, p.NewRelease)
+			if name == n {
+				o.Packages[i].Changelog = models.Changelog{
+					Contents: *clog,
+					Method:   models.ChangelogExactMatchStr,
+				}
+				break
+			}
+		}
+	}
+
 	var results []PackInfoCveIDs
 	for i, packInfo := range packInfoList {
 		changelog := o.getChangelogCVELines(rpm2changelog, packInfo)
@@ -349,8 +409,9 @@ func (o *redhat) scanUnsecurePackagesUsingYumCheckUpdate() (models.VulnInfos, er
 	for k, v := range cveIDPackInfoMap {
 		// Amazon, RHEL do not use this method, so VendorAdvisory do not set.
 		vinfos = append(vinfos, models.VulnInfo{
-			CveID:    k,
-			Packages: v,
+			CveID:      k,
+			Packages:   v,
+			Confidence: models.ChangelogExactMatch,
 		})
 	}
 	return vinfos, nil
@@ -448,19 +509,20 @@ func (o *redhat) getChangelogCVELines(rpm2changelog map[string]*string, packInfo
 	return retLine
 }

-func (o *redhat) parseAllChangelog(allChangelog string) (map[string]*string, error) {
+func (o *redhat) divideChangelogByPackage(allChangelog string) (map[string]*string, error) {
 	var majorVersion int
-	if 0 < len(o.Distro.Release) && o.Distro.Family == "centos" {
-		majorVersion, _ = strconv.Atoi(strings.Split(o.Distro.Release, ".")[0])
-	} else {
-		return nil, fmt.Errorf("Not implemented yet: %s", o.getDistro())
+	var err error
+	if o.Distro.Family == "centos" {
+		majorVersion, err = o.Distro.MajorVersion()
+		if err != nil {
+			return nil, fmt.Errorf("Not implemented yet: %s, err: %s", o.Distro, err)
+		}
 	}

 	orglines := strings.Split(allChangelog, "\n")
 	tmpline := ""
 	var lines []string
 	var prev, now bool
-	var err error
 	for i := range orglines {
 		if majorVersion == 5 {
 			/* for CentOS5 (yum-util < 1.1.20) */
@@ -532,7 +594,7 @@ func (o *redhat) getAllChangelog(packInfoList models.PackageInfoList) (stdout st
 		packageNames += fmt.Sprintf("%s ", packInfo.Name)
 	}

-	command := "echo N | "
+	command := ""
 	if 0 < len(config.Conf.HTTPProxy) {
 		command += util.ProxyEnv()
 	}
@@ -544,16 +606,17 @@ func (o *redhat) getAllChangelog(packInfoList models.PackageInfoList) (stdout st
 	if config.Conf.SkipBroken {
 		yumopts += " --skip-broken"
 	}
-	// yum update --changelog doesn't have --color option.
-	command += fmt.Sprintf(" LANGUAGE=en_US.UTF-8 yum %s --changelog update ", yumopts) + packageNames

-	r := o.ssh(command, sudo)
+	// yum update --changelog doesn't have --color option.
+	command += fmt.Sprintf(" LANGUAGE=en_US.UTF-8 yum --changelog --assumeno update %s ", yumopts) + packageNames
+
+	r := o.exec(command, sudo)
 	if !r.isSuccess(0, 1) {
 		return "", fmt.Errorf(
 			"Failed to get changelog. status: %d, stdout: %s, stderr: %s",
 			r.ExitStatus, r.Stdout, r.Stderr)
 	}
-	return r.Stdout, nil
+	return strings.Replace(r.Stdout, "\r", "", -1), nil
 }

 type distroAdvisoryCveIDs struct {
@@ -562,7 +625,7 @@ type distroAdvisoryCveIDs struct {
 }

 // Scaning unsecure packages using yum-plugin-security.
-// Amazon, RHEL
+// Amazon, RHEL, Oracle Linux
 func (o *redhat) scanUnsecurePackagesUsingYumPluginSecurity() (models.VulnInfos, error) {
 	if o.Distro.Family == "centos" {
 		// CentOS has no security channel.
@@ -572,23 +635,31 @@ func (o *redhat) scanUnsecurePackagesUsingYumPluginSecurity() (models.VulnInfos,
 	}

 	cmd := "yum --color=never repolist"
-	r := o.ssh(util.PrependProxyEnv(cmd), o.sudo())
+	r := o.exec(util.PrependProxyEnv(cmd), o.sudo())
 	if !r.isSuccess() {
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
 	}

-	// get advisoryID(RHSA, ALAS) - package name,version
-	cmd = "yum --color=never updateinfo list available --security"
-	r = o.ssh(util.PrependProxyEnv(cmd), o.sudo())
+	// get advisoryID(RHSA, ALAS, ELSA) - package name,version
+	major, err := (o.Distro.MajorVersion())
+	if err != nil {
+		return nil, fmt.Errorf("Not implemented yet: %s, err: %s", o.Distro, err)
+	}
+
+	if (o.Distro.Family == "rhel" || o.Distro.Family == "oraclelinux") && major == 5 {
+		cmd = "yum --color=never list-security --security"
+	} else {
+		cmd = "yum --color=never --security updateinfo list updates"
+	}
+	r = o.exec(util.PrependProxyEnv(cmd), o.sudo())
 	if !r.isSuccess() {
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
 	}
 	advIDPackNamesList, err := o.parseYumUpdateinfoListAvailable(r.Stdout)

 	// get package name, version, rel to be upgrade.
-	//  cmd = "yum check-update --security"
 	cmd = "LANGUAGE=en_US.UTF-8 yum --color=never check-update"
-	r = o.ssh(util.PrependProxyEnv(cmd), o.sudo())
+	r = o.exec(util.PrependProxyEnv(cmd), o.sudo())
 	if !r.isSuccess(0, 100) {
 		//returns an exit code of 100 if there are available updates.
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
@@ -617,9 +688,13 @@ func (o *redhat) scanUnsecurePackagesUsingYumPluginSecurity() (models.VulnInfos,
 		dict[advIDPackNames.AdvisoryID] = packInfoList
 	}

-	// get advisoryID(RHSA, ALAS) - CVE IDs
-	cmd = "yum --color=never updateinfo --security update"
-	r = o.ssh(util.PrependProxyEnv(cmd), o.sudo())
+	// get advisoryID(RHSA, ALAS, ELSA) - CVE IDs
+	if (o.Distro.Family == "rhel" || o.Distro.Family == "oraclelinux") && major == 5 {
+		cmd = "yum --color=never info-security"
+	} else {
+		cmd = "yum --color=never --security updateinfo updates"
+	}
+	r = o.exec(util.PrependProxyEnv(cmd), o.sudo())
 	if !r.isSuccess() {
 		return nil, fmt.Errorf("Failed to SSH: %s", r)
 	}
@@ -631,7 +706,6 @@ func (o *redhat) scanUnsecurePackagesUsingYumPluginSecurity() (models.VulnInfos,

 	// All information collected.
 	// Convert to VulnInfos.
-	o.log.Info("Fetching CVE details...")
 	vinfos := models.VulnInfos{}
 	for _, advIDCveIDs := range advisoryCveIDsList {
 		for _, cveID := range advIDCveIDs.CveIDs {
@@ -653,6 +727,7 @@ func (o *redhat) scanUnsecurePackagesUsingYumPluginSecurity() (models.VulnInfos,
 					CveID:            cveID,
 					DistroAdvisories: []models.DistroAdvisory{advIDCveIDs.DistroAdvisory},
 					Packages:         dict[advIDCveIDs.DistroAdvisory.AdvisoryID],
+					Confidence:       models.YumUpdateSecurityMatch,
 				}
 				vinfos = append(vinfos, cpinfo)
 			}
@@ -714,7 +789,7 @@ func (o *redhat) parseYumUpdateinfo(stdout string) (result []distroAdvisoryCveID
 				// So use yum check-update && parse changelog
 				return result, fmt.Errorf(
 					"yum updateinfo is not suppported on  CentOS")
-			case "rhel", "amazon":
+			case "rhel", "amazon", "oraclelinux":
 				// nop
 			}

@@ -793,38 +868,6 @@ func (o *redhat) isRpmPackageNameLine(line string) (bool, error) {
 	return true, nil
 }

-// see test case
-func (o *redhat) parseYumUpdateinfoHeaderCentOS(line string) (packs []models.PackageInfo, err error) {
-	pkgs := strings.Split(strings.TrimSpace(line), ",")
-	for _, pkg := range pkgs {
-		packs = append(packs, models.PackageInfo{})
-		s := strings.Split(pkg, "-")
-		if len(s) == 3 {
-			packs[len(packs)-1].Name = s[0]
-			packs[len(packs)-1].Version = s[1]
-			packs[len(packs)-1].Release = s[2]
-		} else {
-			return packs, fmt.Errorf("CentOS: Unknown Header format: %s", line)
-		}
-	}
-	return
-}
-
-var yumHeaderPattern = regexp.MustCompile(`(ALAS-.+): (.+) priority package update for (.+)$`)
-
-func (o *redhat) parseYumUpdateinfoHeaderAmazon(line string) (a models.DistroAdvisory, names []string, err error) {
-	result := yumHeaderPattern.FindStringSubmatch(line)
-	if len(result) == 4 {
-		a.AdvisoryID = result[1]
-		a.Severity = result[2]
-		spaceSeparatedPacknames := result[3]
-		names = strings.Fields(spaceSeparatedPacknames)
-		return
-	}
-	err = fmt.Errorf("Amazon Linux: Unknown Header Format. %s", line)
-	return
-}
-
 var yumCveIDPattern = regexp.MustCompile(`(CVE-\d{4}-\d{4,})`)

 func (o *redhat) parseYumUpdateinfoLineToGetCveIDs(line string) []string {
@@ -907,14 +950,15 @@ func (o *redhat) extractPackNameVerRel(nameVerRel string) (name, ver, rel string
 	return
 }

-// parseYumUpdateinfoListAvailable collect AdvisorID(RHSA, ALAS), packages
+// parseYumUpdateinfoListAvailable collect AdvisorID(RHSA, ALAS, ELSA), packages
 func (o *redhat) parseYumUpdateinfoListAvailable(stdout string) (advisoryIDPacksList, error) {
 	result := []advisoryIDPacks{}
 	lines := strings.Split(stdout, "\n")
 	for _, line := range lines {

 		if !(strings.HasPrefix(line, "RHSA") ||
-			strings.HasPrefix(line, "ALAS")) {
+			strings.HasPrefix(line, "ALAS") ||
+			strings.HasPrefix(line, "ELSA")) {
 			continue
 		}

--- a/scan/redhat_test.go
+++ b/scan/redhat_test.go
@@ -91,47 +91,6 @@ func TestChangeSectionState(t *testing.T) {
 	}
 }

-func TestParseYumUpdateinfoHeader(t *testing.T) {
-	r := newRedhat(config.ServerInfo{})
-	var tests = []struct {
-		in  string
-		out []models.PackageInfo
-	}{
-		{
-			"     nodejs-0.10.36-3.el6,libuv-0.10.34-1.el6,v8-3.14.5.10-17.el6    ",
-			[]models.PackageInfo{
-				{
-					Name:    "nodejs",
-					Version: "0.10.36",
-					Release: "3.el6",
-				},
-				{
-					Name:    "libuv",
-					Version: "0.10.34",
-					Release: "1.el6",
-				},
-				{
-					Name:    "v8",
-					Version: "3.14.5.10",
-					Release: "17.el6",
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		if a, err := r.parseYumUpdateinfoHeaderCentOS(tt.in); err != nil {
-			t.Errorf("err: %s", err)
-		} else {
-			if !reflect.DeepEqual(a, tt.out) {
-				e := pp.Sprintf("%#v", tt.out)
-				a := pp.Sprintf("%#v", a)
-				t.Errorf("expected %s, actual %s", e, a)
-			}
-		}
-	}
-}
-
 func TestParseYumUpdateinfoLineToGetCveIDs(t *testing.T) {
 	r := newRedhat(config.ServerInfo{})
 	var tests = []struct {
@@ -385,6 +344,111 @@ func TestParseYumUpdateinfoToGetSeverity(t *testing.T) {
 	}
 }

+func TestParseYumUpdateinfoOL(t *testing.T) {
+	stdout := `===============================================================================
+   bind security update
+===============================================================================
+  Update ID : ELSA-2017-0276
+    Release : Oracle Linux 7
+       Type : security
+     Status : final
+     Issued : 2017-02-15
+       CVEs : CVE-2017-3135
+Description : [32:9.9.4-38.2]
+            : - Fix CVE-2017-3135 (ISC change 4557)
+            : - Fix and test caching CNAME before DNAME (ISC
+            :   change 4558)
+   Severity : Moderate
+   
+===============================================================================
+   openssl security update
+===============================================================================
+  Update ID : ELSA-2017-0286
+    Release : Oracle Linux 7
+       Type : security
+     Status : final
+     Issued : 2017-02-15
+       CVEs : CVE-2016-8610
+	    : CVE-2017-3731
+Description : [1.0.1e-48.4]
+            : - fix CVE-2017-3731 - DoS via truncated packets
+            :   with RC4-MD5 cipher
+            : - fix CVE-2016-8610 - DoS of single-threaded
+            :   servers via excessive alerts
+   Severity : Moderate
+   
+===============================================================================
+   Unbreakable Enterprise kernel security update
+===============================================================================
+  Update ID : ELSA-2017-3520
+    Release : Oracle Linux 7
+       Type : security
+     Status : final
+     Issued : 2017-02-15
+       CVEs : CVE-2017-6074
+Description : kernel-uek
+            : [4.1.12-61.1.28]
+            : - dccp: fix freeing skb too early for
+            :   IPV6_RECVPKTINFO (Andrey Konovalov)  [Orabug:
+            :   25598257]  {CVE-2017-6074}
+   Severity : Important
+
+	`
+	issued, _ := time.Parse("2006-01-02", "2017-02-15")
+
+	r := newRedhat(config.ServerInfo{})
+	r.Distro = config.Distro{Family: "oraclelinux"}
+
+	var tests = []struct {
+		in  string
+		out []distroAdvisoryCveIDs
+	}{
+		{
+			stdout,
+			[]distroAdvisoryCveIDs{
+				{
+					DistroAdvisory: models.DistroAdvisory{
+						AdvisoryID: "ELSA-2017-0276",
+						Severity:   "Moderate",
+						Issued:     issued,
+					},
+					CveIDs: []string{"CVE-2017-3135"},
+				},
+				{
+					DistroAdvisory: models.DistroAdvisory{
+						AdvisoryID: "ELSA-2017-0286",
+						Severity:   "Moderate",
+						Issued:     issued,
+					},
+					CveIDs: []string{
+						"CVE-2016-8610",
+						"CVE-2017-3731",
+					},
+				},
+				{
+					DistroAdvisory: models.DistroAdvisory{
+						AdvisoryID: "ELSA-2017-3520",
+						Severity:   "Important",
+						Issued:     issued,
+					},
+					CveIDs: []string{"CVE-2017-6074"},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		actual, _ := r.parseYumUpdateinfo(tt.in)
+		for i, advisoryCveIDs := range actual {
+			if !reflect.DeepEqual(tt.out[i], advisoryCveIDs) {
+				e := pp.Sprintf("%v", tt.out[i])
+				a := pp.Sprintf("%v", advisoryCveIDs)
+				t.Errorf("[%d] Alas is not same. \nexpected: %s\nactual: %s",
+					i, e, a)
+			}
+		}
+	}
+}
+
 func TestParseYumUpdateinfoRHEL(t *testing.T) {

 	stdout := `===============================================================================
@@ -804,31 +868,6 @@ if-not-architecture        100-200                         amzn-main
 	}
 }

-func TestParseYumUpdateinfoAmazonLinuxHeader(t *testing.T) {
-	r := newRedhat(config.ServerInfo{})
-	var tests = []struct {
-		in  string
-		out models.DistroAdvisory
-	}{
-		{
-			"Amazon Linux AMI 2014.03 - ALAS-2015-598: low priority package update for grep",
-			models.DistroAdvisory{
-				AdvisoryID: "ALAS-2015-598",
-				Severity:   "low",
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		a, _, _ := r.parseYumUpdateinfoHeaderAmazon(tt.in)
-		if !reflect.DeepEqual(a, tt.out) {
-			e := pp.Sprintf("%v", tt.out)
-			a := pp.Sprintf("%v", a)
-			t.Errorf("expected %s, actual %s", e, a)
-		}
-	}
-}
-
 func TestParseYumUpdateinfoListAvailable(t *testing.T) {
 	r := newRedhat(config.ServerInfo{})
 	rhelStdout := `RHSA-2015:2315 Moderate/Sec.  NetworkManager-1:1.0.6-27.el7.x86_64
@@ -1137,7 +1176,7 @@ func TestGetChangelogCVELines(t *testing.T) {
 		Release: "6.7",
 	}
 	for _, tt := range testsCentos6 {
-		rpm2changelog, err := r.parseAllChangelog(stdoutCentos6)
+		rpm2changelog, err := r.divideChangelogByPackage(stdoutCentos6)
 		if err != nil {
 			t.Errorf("err: %s", err)
 		}
@@ -1223,7 +1262,7 @@ func TestGetChangelogCVELines(t *testing.T) {
 		Release: "5.6",
 	}
 	for _, tt := range testsCentos5 {
-		rpm2changelog, err := r.parseAllChangelog(stdoutCentos5)
+		rpm2changelog, err := r.divideChangelogByPackage(stdoutCentos5)
 		if err != nil {
 			t.Errorf("err: %s", err)
 		}
--- a/scan/serverapi.go
+++ b/scan/serverapi.go
@@ -18,45 +18,35 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package scan

 import (
-	"bufio"
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 	"time"

-	"github.com/Sirupsen/logrus"
 	"github.com/future-architect/vuls/cache"
 	"github.com/future-architect/vuls/config"
 	"github.com/future-architect/vuls/models"
 	"github.com/future-architect/vuls/report"
+	"github.com/future-architect/vuls/util"
 )

-// Log for localhsot
-var Log *logrus.Entry
-
-var servers []osTypeInterface
+var servers, errServers []osTypeInterface

 // Base Interface of redhat, debian, freebsd
 type osTypeInterface interface {
 	setServerInfo(config.ServerInfo)
 	getServerInfo() config.ServerInfo
-
 	setDistro(string, string)
 	getDistro() config.Distro
+	detectPlatform()
+	getPlatform() models.Platform

 	// checkDependencies checks if dependencies are installed on the target server.
 	checkDependencies() error
-	getLackDependencies() []string
-
 	checkIfSudoNoPasswd() error
-	detectPlatform() error
-	getPlatform() models.Platform

-	checkRequiredPackagesInstalled() error
 	scanPackages() error
-	install() error
-	convertToModel() (models.ScanResult, error)
+	convertToModel() models.ScanResult

 	runningContainers() ([]config.Container, error)
 	exitedContainers() ([]config.Container, error)
@@ -89,30 +79,34 @@ func detectOS(c config.ServerInfo) (osType osTypeInterface) {

 	itsMe, osType, fatalErr = detectDebian(c)
 	if fatalErr != nil {
-		osType.setServerInfo(c)
-		osType.setErrs([]error{fatalErr})
+		osType.setErrs([]error{
+			fmt.Errorf("Failed to detect OS: %s", fatalErr)})
 		return
-	} else if itsMe {
-		Log.Debugf("Debian like Linux. Host: %s:%s", c.Host, c.Port)
+	}
+
+	if itsMe {
+		util.Log.Debugf("Debian like Linux. Host: %s:%s", c.Host, c.Port)
 		return
 	}

 	if itsMe, osType = detectRedhat(c); itsMe {
-		Log.Debugf("Redhat like Linux. Host: %s:%s", c.Host, c.Port)
+		util.Log.Debugf("Redhat like Linux. Host: %s:%s", c.Host, c.Port)
 		return
 	}
+
 	if itsMe, osType = detectFreebsd(c); itsMe {
-		Log.Debugf("FreeBSD. Host: %s:%s", c.Host, c.Port)
+		util.Log.Debugf("FreeBSD. Host: %s:%s", c.Host, c.Port)
 		return
 	}
-	osType.setServerInfo(c)
+
+	//TODO darwin https://github.com/mizzy/specinfra/blob/master/lib/specinfra/helper/detect_os/darwin.rb
 	osType.setErrs([]error{fmt.Errorf("Unknown OS Type")})
 	return
 }

 // PrintSSHableServerNames print SSH-able servernames
 func PrintSSHableServerNames() {
-	Log.Info("SSH-able servers are below...")
+	util.Log.Info("Scannable servers are below...")
 	for _, s := range servers {
 		if s.getServerInfo().IsContainer() {
 			fmt.Printf("%s@%s ",
@@ -127,67 +121,74 @@ func PrintSSHableServerNames() {
 }

 // InitServers detect the kind of OS distribution of target servers
-func InitServers(localLogger *logrus.Entry) error {
-	Log = localLogger
-	servers = detectServerOSes()
+func InitServers() error {
+	servers, errServers = detectServerOSes()
 	if len(servers) == 0 {
 		return fmt.Errorf("No scannable servers")
 	}

-	containers := detectContainerOSes()
+	actives, inactives := detectContainerOSes()
 	if config.Conf.ContainersOnly {
-		servers = containers
+		servers = actives
+		errServers = inactives
 	} else {
-		servers = append(servers, containers...)
+		servers = append(servers, actives...)
+		errServers = append(errServers, inactives...)
 	}
 	return nil
 }

-func detectServerOSes() (sshAbleOses []osTypeInterface) {
-	Log.Info("Detecting OS of servers... ")
+func detectServerOSes() (servers, errServers []osTypeInterface) {
+	util.Log.Info("Detecting OS of servers... ")
 	osTypeChan := make(chan osTypeInterface, len(config.Conf.Servers))
 	defer close(osTypeChan)
 	for _, s := range config.Conf.Servers {
 		go func(s config.ServerInfo) {
 			defer func() {
 				if p := recover(); p != nil {
-					Log.Debugf("Panic: %s on %s", p, s.ServerName)
+					util.Log.Debugf("Panic: %s on %s", p, s.ServerName)
 				}
 			}()
 			osTypeChan <- detectOS(s)
 		}(s)
 	}

-	var oses []osTypeInterface
 	timeout := time.After(30 * time.Second)
 	for i := 0; i < len(config.Conf.Servers); i++ {
 		select {
 		case res := <-osTypeChan:
-			oses = append(oses, res)
 			if 0 < len(res.getErrs()) {
-				Log.Errorf("(%d/%d) Failed: %s, err: %s",
+				errServers = append(errServers, res)
+				util.Log.Errorf("(%d/%d) Failed: %s, err: %s",
 					i+1, len(config.Conf.Servers),
 					res.getServerInfo().ServerName,
 					res.getErrs())
 			} else {
-				Log.Infof("(%d/%d) Detected: %s: %s",
+				servers = append(servers, res)
+				util.Log.Infof("(%d/%d) Detected: %s: %s",
 					i+1, len(config.Conf.Servers),
 					res.getServerInfo().ServerName,
 					res.getDistro())
 			}
 		case <-timeout:
 			msg := "Timed out while detecting servers"
-			Log.Error(msg)
-			for servername := range config.Conf.Servers {
+			util.Log.Error(msg)
+			for servername, sInfo := range config.Conf.Servers {
 				found := false
-				for _, o := range oses {
+				for _, o := range append(servers, errServers...) {
 					if servername == o.getServerInfo().ServerName {
 						found = true
 						break
 					}
 				}
 				if !found {
-					Log.Errorf("(%d/%d) Timed out: %s",
+					u := &unknown{}
+					u.setServerInfo(sInfo)
+					u.setErrs([]error{
+						fmt.Errorf("Timed out"),
+					})
+					errServers = append(errServers, u)
+					util.Log.Errorf("(%d/%d) Timed out: %s",
 						i+1, len(config.Conf.Servers),
 						servername)
 					i++
@@ -195,24 +196,18 @@ func detectServerOSes() (sshAbleOses []osTypeInterface) {
 			}
 		}
 	}
-
-	for _, o := range oses {
-		if len(o.getErrs()) == 0 {
-			sshAbleOses = append(sshAbleOses, o)
-		}
-	}
 	return
 }

-func detectContainerOSes() (actives []osTypeInterface) {
-	Log.Info("Detecting OS of containers... ")
+func detectContainerOSes() (actives, inactives []osTypeInterface) {
+	util.Log.Info("Detecting OS of containers... ")
 	osTypesChan := make(chan []osTypeInterface, len(servers))
 	defer close(osTypesChan)
 	for _, s := range servers {
 		go func(s osTypeInterface) {
 			defer func() {
 				if p := recover(); p != nil {
-					Log.Debugf("Panic: %s on %s",
+					util.Log.Debugf("Panic: %s on %s",
 						p, s.getServerInfo().GetServerName())
 				}
 			}()
@@ -220,7 +215,6 @@ func detectContainerOSes() (actives []osTypeInterface) {
 		}(s)
 	}

-	var oses []osTypeInterface
 	timeout := time.After(30 * time.Second)
 	for i := 0; i < len(servers); i++ {
 		select {
@@ -228,42 +222,44 @@ func detectContainerOSes() (actives []osTypeInterface) {
 			for _, osi := range res {
 				sinfo := osi.getServerInfo()
 				if 0 < len(osi.getErrs()) {
-					Log.Errorf("Failed: %s err: %s", sinfo.ServerName, osi.getErrs())
+					inactives = append(inactives, osi)
+					util.Log.Errorf("Failed: %s err: %s", sinfo.ServerName, osi.getErrs())
 					continue
 				}
-				oses = append(oses, osi)
-				Log.Infof("Detected: %s@%s: %s",
+				actives = append(actives, osi)
+				util.Log.Infof("Detected: %s@%s: %s",
 					sinfo.Container.Name, sinfo.ServerName, osi.getDistro())
 			}
 		case <-timeout:
 			msg := "Timed out while detecting containers"
-			Log.Error(msg)
-			for servername := range config.Conf.Servers {
+			util.Log.Error(msg)
+			for servername, sInfo := range config.Conf.Servers {
 				found := false
-				for _, o := range oses {
+				for _, o := range append(actives, inactives...) {
 					if servername == o.getServerInfo().ServerName {
 						found = true
 						break
 					}
 				}
 				if !found {
-					Log.Errorf("Timed out: %s", servername)
+					u := &unknown{}
+					u.setServerInfo(sInfo)
+					u.setErrs([]error{
+						fmt.Errorf("Timed out"),
+					})
+					inactives = append(inactives)
+					util.Log.Errorf("Timed out: %s", servername)

 				}
 			}
 		}
 	}
-	for _, o := range oses {
-		if len(o.getErrs()) == 0 {
-			actives = append(actives, o)
-		}
-	}
 	return
 }

 func detectContainerOSesOnServer(containerHost osTypeInterface) (oses []osTypeInterface) {
 	containerHostInfo := containerHost.getServerInfo()
-	if len(containerHostInfo.Containers) == 0 {
+	if len(containerHostInfo.Containers.Includes) == 0 {
 		return
 	}

@@ -275,12 +271,24 @@ func detectContainerOSesOnServer(containerHost osTypeInterface) (oses []osTypeIn
 		return append(oses, containerHost)
 	}

-	if containerHostInfo.Containers[0] == "${running}" {
+	if containerHostInfo.Containers.Includes[0] == "${running}" {
 		for _, containerInfo := range running {
+
+			found := false
+			for _, ex := range containerHost.getServerInfo().Containers.Excludes {
+				if containerInfo.Name == ex || containerInfo.ContainerID == ex {
+					found = true
+				}
+			}
+			if found {
+				continue
+			}
+
 			copied := containerHostInfo
 			copied.SetContainer(config.Container{
 				ContainerID: containerInfo.ContainerID,
 				Name:        containerInfo.Name,
+				Image:       containerInfo.Image,
 			})
 			os := detectOS(copied)
 			oses = append(oses, os)
@@ -297,7 +305,7 @@ func detectContainerOSesOnServer(containerHost osTypeInterface) (oses []osTypeIn
 	}

 	var exited, unknown []string
-	for _, container := range containerHostInfo.Containers {
+	for _, container := range containerHostInfo.Containers.Includes {
 		found := false
 		for _, c := range running {
 			if c.ContainerID == container || c.Name == container {
@@ -333,29 +341,28 @@ func detectContainerOSesOnServer(containerHost osTypeInterface) (oses []osTypeIn
 	return oses
 }

+// CheckDependencies checks dependencies are installed on target servers.
+func CheckDependencies(timeoutSec int) {
+	parallelExec(func(o osTypeInterface) error {
+		return o.checkDependencies()
+	}, timeoutSec)
+	return
+}
+
 // CheckIfSudoNoPasswd checks whether vuls can sudo with nopassword via SSH
-func CheckIfSudoNoPasswd(localLogger *logrus.Entry) error {
-	timeoutSec := 15
-	errs := parallelSSHExec(func(o osTypeInterface) error {
+func CheckIfSudoNoPasswd(timeoutSec int) {
+	parallelExec(func(o osTypeInterface) error {
 		return o.checkIfSudoNoPasswd()
 	}, timeoutSec)
-
-	if 0 < len(errs) {
-		return fmt.Errorf(fmt.Sprintf("%s", errs))
-	}
-	return nil
+	return
 }

 // DetectPlatforms detects the platform of each servers.
-func DetectPlatforms(localLogger *logrus.Entry) {
-	errs := detectPlatforms()
-	if 0 < len(errs) {
-		// Only logging
-		Log.Warnf("Failed to detect platforms. err: %v", errs)
-	}
+func DetectPlatforms() {
+	detectPlatforms()
 	for i, s := range servers {
 		if s.getServerInfo().IsContainer() {
-			Log.Infof("(%d/%d) %s on %s is running on %s",
+			util.Log.Infof("(%d/%d) %s on %s is running on %s",
 				i+1, len(servers),
 				s.getServerInfo().Container.Name,
 				s.getServerInfo().ServerName,
@@ -363,7 +370,7 @@ func DetectPlatforms(localLogger *logrus.Entry) {
 			)

 		} else {
-			Log.Infof("(%d/%d) %s is running on %s",
+			util.Log.Infof("(%d/%d) %s is running on %s",
 				i+1, len(servers),
 				s.getServerInfo().ServerName,
 				s.getPlatform().Name,
@@ -373,155 +380,73 @@ func DetectPlatforms(localLogger *logrus.Entry) {
 	return
 }

-func detectPlatforms() []error {
+func detectPlatforms() {
 	timeoutSec := 1 * 60
-	return parallelSSHExec(func(o osTypeInterface) error {
-		return o.detectPlatform()
+	parallelExec(func(o osTypeInterface) error {
+		o.detectPlatform()
+		// Logging only if platform can not be specified
+		return nil
 	}, timeoutSec)
-}
-
-// Prepare installs requred packages to scan vulnerabilities.
-func Prepare() []error {
-	errs := parallelSSHExec(func(o osTypeInterface) error {
-		if err := o.checkDependencies(); err != nil {
-			return err
-		}
-		return nil
-	})
-	if len(errs) != 0 {
-		return errs
-	}
-
-	var targets []osTypeInterface
-	for _, s := range servers {
-		deps := s.getLackDependencies()
-		if len(deps) != 0 {
-			targets = append(targets, s)
-		}
-	}
-	if len(targets) == 0 {
-		Log.Info("No need to install dependencies")
-		return nil
-	}
-
-	Log.Info("The following servers need dependencies installed")
-	for _, s := range targets {
-		for _, d := range s.getLackDependencies() {
-			Log.Infof("  - %s on %s", d, s.getServerInfo().GetServerName())
-		}
-	}
-
-	if !config.Conf.AssumeYes {
-		Log.Info("Is this ok to install dependencies on the servers? [y/N]")
-
-		reader := bufio.NewReader(os.Stdin)
-		for {
-			text, err := reader.ReadString('\n')
-			if err != nil {
-				return []error{err}
-			}
-			switch strings.TrimSpace(text) {
-			case "", "N", "n":
-				return nil
-			case "y", "Y":
-				goto yes
-			default:
-				Log.Info("Please enter y or N")
-			}
-		}
-	}
-
-yes:
-	servers = targets
-	errs = parallelSSHExec(func(o osTypeInterface) error {
-		if err := o.install(); err != nil {
-			return err
-		}
-		return nil
-	})
-	if len(errs) != 0 {
-		return errs
-	}
-	Log.Info("All dependencies were installed correctly")
-	return nil
+	return
 }

 // Scan scan
-func Scan() []error {
+func Scan() error {
 	if len(servers) == 0 {
-		return []error{fmt.Errorf("No server defined. Check the configuration")}
+		return fmt.Errorf("No server defined. Check the configuration")
 	}

-	Log.Info("Check required packages for scanning...")
-	if errs := checkRequiredPackagesInstalled(); errs != nil {
-		Log.Error("Please execute with [prepare] subcommand to install required packages before scanning")
-		return errs
+	if err := setupChangelogCache(); err != nil {
+		return err
 	}
-
-	if err := setupCangelogCache(); err != nil {
-		return []error{err}
-	}
-
 	defer func() {
 		if cache.DB != nil {
 			cache.DB.Close()
 		}
 	}()

-	Log.Info("Scanning vulnerable OS packages...")
+	util.Log.Info("Scanning vulnerable OS packages...")
 	scannedAt := time.Now()
 	dir, err := ensureResultDir(scannedAt)
 	if err != nil {
-		return []error{err}
+		return err
 	}
-	if errs := scanVulns(dir, scannedAt); errs != nil {
-		return errs
+	if err := scanVulns(dir, scannedAt); err != nil {
+		return err
 	}

 	return nil
 }

-func setupCangelogCache() error {
+func setupChangelogCache() error {
 	needToSetupCache := false
 	for _, s := range servers {
 		switch s.getDistro().Family {
-		case "ubuntu", "debian":
+		case "ubuntu", "debian", "raspbian":
 			needToSetupCache = true
 			break
 		}
 	}
 	if needToSetupCache {
-		if err := cache.SetupBolt(config.Conf.CacheDBPath, Log); err != nil {
+		if err := cache.SetupBolt(config.Conf.CacheDBPath, util.Log); err != nil {
 			return err
 		}
 	}
 	return nil
 }

-func checkRequiredPackagesInstalled() []error {
-	timeoutSec := 30 * 60
-	return parallelSSHExec(func(o osTypeInterface) error {
-		return o.checkRequiredPackagesInstalled()
-	}, timeoutSec)
-}
-
-func scanVulns(jsonDir string, scannedAt time.Time) []error {
+func scanVulns(jsonDir string, scannedAt time.Time) error {
 	var results models.ScanResults
 	timeoutSec := 120 * 60
-	errs := parallelSSHExec(func(o osTypeInterface) error {
-		if err := o.scanPackages(); err != nil {
-			return err
-		}
+	parallelExec(func(o osTypeInterface) error {
+		return o.scanPackages()
+	}, timeoutSec)

-		r, err := o.convertToModel()
-		if err != nil {
-			return err
-		}
+	for _, s := range append(servers, errServers...) {
+		r := s.convertToModel()
 		r.ScannedAt = scannedAt
 		results = append(results, r)
-
-		return nil
-	}, timeoutSec)
+	}

 	config.Conf.FormatJSON = true
 	ws := []report.ResultWriter{
@@ -529,14 +454,9 @@ func scanVulns(jsonDir string, scannedAt time.Time) []error {
 	}
 	for _, w := range ws {
 		if err := w.Write(results...); err != nil {
-			return []error{
-				fmt.Errorf("Failed to write summary report: %s", err),
-			}
+			return fmt.Errorf("Failed to write summary report: %s", err)
 		}
 	}
-	if errs != nil {
-		return errs
-	}

 	report.StdoutWriter{}.WriteScanSummary(results...)
 	return nil
--- a/scan/unknownDistro.go
+++ b/scan/unknownDistro.go
@@ -0,0 +1,35 @@
+/* Vuls - Vulnerability Scanner
+Copyright (C) 2016  Future Architect, Inc. Japan.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package scan
+
+// inherit OsTypeInterface
+type unknown struct {
+	base
+}
+
+func (o *unknown) checkIfSudoNoPasswd() error {
+	return nil
+}
+
+func (o unknown) checkDependencies() error {
+	return nil
+}
+
+func (o *unknown) scanPackages() error {
+	return nil
+}
--- a/setup/docker/README.md
+++ b/setup/docker/README.md
@@ -44,10 +44,6 @@ vuls v0.0.xxx xxxx
 $ docker rmi vuls/go-cve-dictionary
 ```

-```
-$ docker rmi vuls/vuls
-```
-
 - vuls

 ```
@@ -89,14 +85,14 @@ vuls v0.1.xxx xxxx

 1. fetch nvd (vuls/go-cve-dictionary)
 1. configuration (vuls/vuls)
-1. prepare (vuls/vuls)
+1. configtest (vuls/vuls)
 1. scan (vuls/vuls)
 1. vulsrepo (vuls/vulsrepo)

 ## Step1. Fetch NVD

 ```console
-$ for i in {2002..2016}; do \
+$ for i in `seq 2002 $(date +"%Y")`; do \
    docker run --rm -it \
    -v $PWD:/vuls \
    -v $PWD/go-cve-dictionary-log:/var/log/vuls \
@@ -117,7 +113,7 @@ port        = "22"
 user        = "vuls-user"
 keyPath     = "/root/.ssh/id_rsa" # path to ssh private key in docker
 ```
-　
+

 ```console
 $ docker run --rm \
@@ -128,14 +124,14 @@ $ docker run --rm \
    -config=./config.toml # path to config.toml in docker
 ```

-## Step3. Prepare
+## Step3. Configtest

 ```console
-$ docker run --rm \
+$ docker run --rm -it\
    -v ~/.ssh:/root/.ssh:ro \
    -v $PWD:/vuls \
    -v $PWD/vuls-log:/var/log/vuls \
-    vuls/vuls prepare \
+    vuls/vuls configtest \
    -config=./config.toml # path to config.toml in docker
 ```

--- a/setup/docker/go-cve-dictionary/latest/README.md
+++ b/setup/docker/go-cve-dictionary/latest/README.md
@@ -43,7 +43,7 @@ $ docker run --rm vuls/go-cve-dictionary -v
 ## fetchnvd

 ```console
-$ for i in {2002..2016}; do \
+$ for i in `seq 2002 $(date +"%Y")`; do \
    docker run --rm -it \
    -v $PWD:/vuls \
    -v $PWD/go-cve-dictionary-log:/var/log/vuls \
--- a/setup/docker/vuls/latest/README.md
+++ b/setup/docker/vuls/latest/README.md
@@ -39,7 +39,7 @@ Please see the [Documentation](https://github.com/future-architect/vuls)
 $ docker run  --rm  vuls/vuls -v
 ```

-## configtest
+## config

 Create config.toml referring to [this](https://github.com/future-architect/vuls#configuration).

@@ -52,25 +52,16 @@ port        = "22"
 user        = "vuls-user"
 keyPath     = "/root/.ssh/id_rsa"  # path to ssh private key in docker
 ```
-　
+
+
+## configtest

 ```console
-$ docker run --rm \
+$ docker run --rm -it \
    -v ~/.ssh:/root/.ssh:ro \
    -v $PWD:/vuls \
    -v $PWD/vuls-log:/var/log/vuls \
-    vuls/vuls configtest
-```
-
-
-## prepare
-
-```console
-$ docker run --rm \
-    -v ~/.ssh:/root/.ssh:ro \
-    -v $PWD:/vuls \
-    -v $PWD/vuls-log:/var/log/vuls \
-    vuls/vuls prepare \
+    vuls/vuls configtest \
    -config=./config.toml # path to config.toml in docker
 ```

--- a/util/logutil.go
+++ b/util/logutil.go
@@ -29,6 +29,9 @@ import (
 	formatter "github.com/kotakanbe/logrus-prefixed-formatter"
 )

+// Log for localhsot
+var Log *logrus.Entry
+
 // NewCustomLogger creates logrus
 func NewCustomLogger(c config.ServerInfo) *logrus.Entry {
 	log := logrus.New()
@@ -40,13 +43,14 @@ func NewCustomLogger(c config.ServerInfo) *logrus.Entry {
 	}

 	// File output
-	logDir := "/var/log/vuls"
-	if runtime.GOOS == "windows" {
-		logDir = filepath.Join(os.Getenv("APPDATA"), "vuls")
+	logDir := GetDefaultLogDir()
+	if 0 < len(config.Conf.LogDir) {
+		logDir = config.Conf.LogDir
 	}
+
 	if _, err := os.Stat(logDir); os.IsNotExist(err) {
-		if err := os.Mkdir(logDir, 0666); err != nil {
-			logrus.Errorf("Failed to create log directory: %s", err)
+		if err := os.Mkdir(logDir, 0700); err != nil {
+			log.Errorf("Failed to create log directory: %s", err)
 		}
 	}

@@ -70,3 +74,12 @@ func NewCustomLogger(c config.ServerInfo) *logrus.Entry {
 	fields := logrus.Fields{"prefix": whereami}
 	return log.WithFields(fields)
 }
+
+// GetDefaultLogDir returns default log directory
+func GetDefaultLogDir() string {
+	defaultLogDir := "/var/log/vuls"
+	if runtime.GOOS == "windows" {
+		defaultLogDir = filepath.Join(os.Getenv("APPDATA"), "vuls")
+	}
+	return defaultLogDir
+}
--- a/util/util.go
+++ b/util/util.go
@@ -95,7 +95,7 @@ func URLPathParamJoin(baseURL string, paths []string, params map[string]string)

 // ProxyEnv returns shell environment variables to set proxy
 func ProxyEnv() string {
-	httpProxyEnv := "env"
+	httpProxyEnv := ""
 	keys := []string{
 		"http_proxy",
 		"https_proxy",
--- a/util/util_test.go
+++ b/util/util_test.go
@@ -105,14 +105,14 @@ func TestPrependHTTPProxyEnv(t *testing.T) {
 				"http://proxy.co.jp:8080",
 				"yum check-update",
 			},
-			`env http_proxy="http://proxy.co.jp:8080" https_proxy="http://proxy.co.jp:8080" HTTP_PROXY="http://proxy.co.jp:8080" HTTPS_PROXY="http://proxy.co.jp:8080" yum check-update`,
+			` http_proxy="http://proxy.co.jp:8080" https_proxy="http://proxy.co.jp:8080" HTTP_PROXY="http://proxy.co.jp:8080" HTTPS_PROXY="http://proxy.co.jp:8080" yum check-update`,
 		},
 		{
 			[]string{
 				"http://proxy.co.jp:8080",
 				"",
 			},
-			`env http_proxy="http://proxy.co.jp:8080" https_proxy="http://proxy.co.jp:8080" HTTP_PROXY="http://proxy.co.jp:8080" HTTPS_PROXY="http://proxy.co.jp:8080" `,
+			` http_proxy="http://proxy.co.jp:8080" https_proxy="http://proxy.co.jp:8080" HTTP_PROXY="http://proxy.co.jp:8080" HTTPS_PROXY="http://proxy.co.jp:8080" `,
 		},
 		{
 			[]string{
Author	SHA1	Message	Date
Kota Kanbe	b0d9c0b550	Update Changelog	2017-03-24 14:55:28 +09:00
Kota Kanbe	9255132f9b	Bump up version	2017-03-24 14:37:48 +09:00
大沼	d5c0092fa3	fix typo (#394 )	2017-03-24 00:25:23 +09:00
Teppei Fukuda	c7019debb9	Notify the difference from the previous scan result (#392 ) add diff option	2017-03-23 23:58:05 +09:00
Kota Kanbe	7131270cad	Add timeout option to configtest (#400 )	2017-03-23 20:52:25 +09:00
Kota Kanbe	af5a1204bc	Update README (#387 ) Update Tutorial in README	2017-03-21 10:47:19 +09:00
Kota Kanbe	58afcfc49a	Fix nil-ponter in TUI (#388 )	2017-03-17 16:46:42 +09:00
Avi Miller	986762ca85	Add Oracle Linux support (#386 ) Adding support for Oracle Linux	2017-03-16 17:07:43 +09:00
Kota Kanbe	6342cf79f5	Merge pull request #383 from usiusi360/Fix_README Fix README	2017-03-15 17:47:36 +09:00
Kota Kanbe	5fbf67f971	Merge pull request #384 from future-architect/mysql Fix Bug of Mysql Backend	2017-03-15 16:51:25 +09:00
Kota Kanbe	e441e5a696	Fix Bug of Mysql Backend	2017-03-15 16:44:49 +09:00
usiusi360	d201efb029	Fix README	2017-03-15 13:53:42 +09:00
Kota Kanbe	25960126c7	Fix README	2017-03-15 12:35:50 +09:00
Kota Kanbe	63d5a6f584	Merge pull request #382 from beuno/patch-1 s/dictinary/dictionary typo	2017-03-15 10:32:36 +09:00
Martin Albisetti	2030951a8f	s/dictinary/dictionary typo	2017-03-14 16:50:36 -03:00
Kota Kanbe	cd841462cd	Merge pull request #381 from future-architect/container-excluded Change container scan format in config.toml	2017-03-14 20:32:22 +09:00
Kota Kanbe	735aa835a6	Change container scan setting in config.toml	2017-03-14 20:07:51 +09:00
Kota Kanbe	92e213ca32	Merge pull request #379 from future-architect/fix-scan-confidence-on-debian Fix scan confidence on Ubuntu/Debian/Raspbian #362	2017-03-13 21:03:12 +09:00
Kota Kanbe	d077c29716	Fix scan confidence on Ubuntu/Debian/Raspbian #362	2017-03-13 20:55:23 +09:00
Kota Kanbe	d6eba48a50	Merge pull request #377 from IMAI-Yuji/IMAI-Yuji-patch-1 Fix Japanese typo	2017-03-13 17:27:11 +09:00
Kota Kanbe	2a1608d1d2	Merge pull request #378 from future-architect/obsolete-centos5 Obsolete CentOS5 support	2017-03-13 17:04:36 +09:00
Kota Kanbe	cc7d3dc2aa	Obsolete CentOS5	2017-03-13 16:57:43 +09:00
Kota Kanbe	a5c4c682f5	Merge pull request #375 from future-architect/deprecate-prepare Deprecate prepare subcommand to minimize the root authority defined by /etc/sudoers	2017-03-13 15:59:35 +09:00
Kota Kanbe	688cfd6872	Deprecate prepare subcommand to minimize the root authority #375	2017-03-13 13:21:01 +09:00
Yuji IMAI	7e268dbae1	Fix Japanese typo	2017-03-10 11:34:53 +09:00
Kota Kanbe	ce6a4231ef	Deprecate prepare subcommand to minimize the root authority defined by /etc/sudoers	2017-03-07 18:09:10 +09:00
Kota Kanbe	e1de8ab626	Merge pull request #370 from ohsawa0515/support_iam_role Support IAM role for report to S3.	2017-03-07 14:07:32 +09:00
Kota Kanbe	0058eaf357	Merge pull request #374 from future-architect/package-count Fix updatalbe packages count #373	2017-03-07 14:03:19 +09:00
Kota Kanbe	732d95098a	Fix updatalbe packages count #373	2017-03-07 13:49:25 +09:00
Shuichi Ohsawa	52f0943207	Add ec2 roles credentials.	2017-03-07 12:37:31 +09:00
Kota Kanbe	41f99f2b65	Merge pull request #372 from future-architect/sudo-check-update-rhel sudo yum check-update on RHEL	2017-03-06 15:16:38 +09:00
Kota Kanbe	1f9e5c6263	sudo yum check-update on RHEL	2017-03-06 14:43:02 +09:00
Kota Kanbe	2f3eddd2ab	Merge pull request #369 from knqyf263/change_option Change ssh option from -t to -tt	2017-03-06 14:37:29 +09:00
knqyf263	619a0ee700	Change ssh option from -t to -tt	2017-03-03 11:20:57 +09:00
Kota Kanbe	b1b5c2c9a0	Merge pull request #356 from future-architect/changelog Output changelog in report, TUI and JSON for Ubuntu/Debian/CentOS	2017-03-02 22:28:29 +09:00
Kota Kanbe	a86035c0bf	Output changelog in report, TUI and JSON for Ubuntu/Debian/CentOS	2017-03-02 22:22:35 +09:00
Kota Kanbe	c66b0f4db4	Merge pull request #364 from knqyf263/increase_width Increase the width of RequestPty	2017-03-01 12:15:23 +09:00
knqyf263	a4cf4bd314	Increase the width of RequestPty	2017-02-28 14:29:12 +09:00
Kota Kanbe	f1cd9383c1	Merge pull request #358 from ymomoi/remove-unused-import remove unused import line.	2017-02-28 14:23:55 +09:00
Kota Kanbe	6fa57abe10	Merge pull request #363 from knqyf263/support_travis Add .travis.yml	2017-02-28 13:08:42 +09:00
knqyf263	6e77c714b5	Add .travis.yml	2017-02-27 21:42:22 +09:00
Yasunari Momoi	fbab020e6e	remove unused import line.	2017-02-25 04:48:28 +09:00
Kota Kanbe	5581a5cce7	Merge pull request #354 from future-architect/mistook-english Fix candidate to confidence.	2017-02-23 12:07:44 +09:00
Kota Kanbe	b4be11775e	Fix candidate to confidence.	2017-02-23 12:05:13 +09:00
Kota Kanbe	b079f5e52e	Update README.ja.md	2017-02-22 21:15:01 +09:00
Kota Kanbe	f9bf470a37	Update README.md	2017-02-22 21:13:54 +09:00
Kota Kanbe	9d783dd2ab	Merge pull request #350 from future-architect/show-false-positive Output confidence score of detection accuracy and detection method to JSON or Reporting	2017-02-22 20:57:39 +09:00
Kota Kanbe	1b9aafbbaf	Output confidence ranking of detection accuracy to JSON or Reporting	2017-02-22 20:51:58 +09:00
Kota Kanbe	1d3ee6a241	Merge pull request #328 from federacy/leniant_changelog_parsing_for_debian Add leniancy to the version matching for debian to account for versio…	2017-02-22 20:43:46 +09:00
Kota Kanbe	2f9c3071a6	Merge pull request #351 from hasegawa-tomoki/patch-1 Improve kanji character	2017-02-21 15:48:24 +09:00
HASEGAWA Tomoki	4b0be4f115	Fix typo(?)	2017-02-21 15:45:17 +09:00
Kota Kanbe	1419c7c8c6	Merge pull request #348 from knqyf263/add_template Add PULL_REQUEST_TEMPLATE.md	2017-02-20 15:37:44 +09:00
knqyf263	851cecdd73	Add PULL_REQUEST_TEMPLATE.md	2017-02-19 23:36:22 +09:00
Kota Kanbe	753da3aad7	Merge pull request #347 from knqyf263/update_readme Update README	2017-02-19 09:57:28 +09:00
Kota Kanbe	65c10d6d8e	Merge pull request #346 from knqyf263/send_cc Bug fix: not send e-mail to cc address	2017-02-19 09:56:20 +09:00
Kota Kanbe	1b8b423131	Merge pull request #345 from future-architect/avoid-null Avoid null slice being null in JSON	2017-02-19 09:37:36 +09:00
Kota Kanbe	55b1264c7d	Avoid null slice being null in JSON	2017-02-19 09:34:24 +09:00
knqyf263	902a1888d4	Update README	2017-02-17 18:33:11 +09:00
knqyf263	98151f7d0e	Bug fix: not send e-mail to cc address	2017-02-16 22:25:04 +09:00
Kota Kanbe	a6f0c559f8	Merge pull request #332 from kazuminn/add-err-handling add error handling	2017-02-16 18:06:59 +09:00
kazuminn	e7ec5b841d	due to miss error handling I fixed it according to the review	2017-02-16 12:49:13 +09:00
Kota Kanbe	d6f72ac0f3	Merge pull request #343 from knqyf263/fix_typo Fix typo	2017-02-16 12:01:03 +09:00
Kota Kanbe	7e3a10025a	Merge pull request #344 from future-architect/fix-testcase Fix test case	2017-02-16 11:33:07 +09:00
Kota Kanbe	e16ec15226	Fix test case	2017-02-16 11:32:18 +09:00
Kota Kanbe	6935b56c9d	Merge pull request #308 from lapthorn/update-readme Update readme	2017-02-16 07:54:51 +09:00
Alan Lapthorn	0e3a0b64e7	Update READMEs Fix typo Fix typo in comment	2017-02-15 22:53:03 +00:00
knqyf263	74e6aee236	Fix typo	2017-02-15 23:51:46 +09:00
Kota Kanbe	db0602b7b8	Merge pull request #296 from galigalikun/update-readme update readme	2017-02-15 22:08:51 +09:00
Kota Kanbe	c9b7c3f179	Merge pull request #331 from knqyf263/add_one-email Add -format-one-email option	2017-02-15 21:58:14 +09:00
knqyf263	5bd9f4afb4	Add -format-one-email option	2017-02-15 18:31:51 +09:00
Kota Kanbe	9d2ba5912e	Merge pull request #340 from future-architect/freebsd-version Change the command used for os detection from uname to freebsd-version	2017-02-15 14:39:31 +09:00
Kota Kanbe	9986c4a6f3	Change the command used for os detection from uname to freebsd-version	2017-02-15 14:34:53 +09:00
Kota Kanbe	df2c9697ef	Merge pull request #339 from future-architect/gnu-makefile Rename Makefile to GNUmakefile #313	2017-02-15 14:13:45 +09:00
Kota Kanbe	ab0388e882	Rename Makefile to GNUmakefile #313	2017-02-15 14:07:43 +09:00
Kota Kanbe	c05d8a36eb	Merge pull request #338 from future-architect/update-readme Update README	2017-02-14 12:47:33 +09:00
Kota Kanbe	492753d905	Update README	2017-02-14 12:45:28 +09:00
Kota Kanbe	6e08bd23f4	Merge pull request #330 from knqyf263/support_raspbian Support Raspbian	2017-02-14 12:15:28 +09:00
Kota Kanbe	a687c97808	Merge pull request #337 from future-architect/fix-error-handling Fix error handling of detectOS	2017-02-14 11:58:43 +09:00
Kota Kanbe	c6864289cb	Fix error handling of detectOS	2017-02-14 11:54:06 +09:00
Kota Kanbe	97d85258c5	Merge pull request #309 from future-architect/continue_scan_on_error Continue scanning even when some hosts have tech issues	2017-02-14 11:10:13 +09:00
knqyf263	bee25f5aa2	Support Raspbian	2017-02-13 22:15:09 +09:00
Kota Kanbe	386b97d2be	Continue scanning even when some hosts have tech issues see #264	2017-02-13 21:55:55 +09:00
Kota Kanbe	00660485b7	Merge pull request #324 from federacy/aptitude_changelog_more_to_cat aptitude changelog defaults to using more, which is not interactive a…	2017-02-13 14:54:12 +09:00
Kota Kanbe	1e8f24dedb	Merge pull request #326 from federacy/add_image_info_for_docker Add image information for docker containers	2017-02-13 13:48:11 +09:00
Kota Kanbe	2be190f863	Merge pull request #322 from knqyf263/delete_sudo_echo Do not use sudo when echo	2017-02-13 12:19:16 +09:00
Kota Kanbe	ec7c6e6c85	Merge pull request #317 from federacy/fix_cve_dictionary_url_conditional Don't check for a CVE DB when CVE Dictionary URL is defined	2017-02-13 10:49:36 +09:00
Kota Kanbe	c52bc53fd8	Merge pull request #314 from justyns/fixcontainertypo Fix typo contianer -> container	2017-02-13 10:43:47 +09:00
James Sulinski	981631503a	Add leniancy to the version matching for debian to account for versions without the "+" when package maintainers aren't using them.	2017-02-10 11:38:46 -08:00
Kota Kanbe	48de3a6a4f	Merge pull request #319 from federacy/nosudo_for_debian_scans Reduce privilege requirements for commands that don't need sudo on Ubuntu/Debian	2017-02-10 19:40:34 +09:00
Kota Kanbe	d1983a6978	Merge pull request #329 from future-architect/retry-exceeded-slack Fix infinite retry at size overrun error in Slack report	2017-02-10 18:41:22 +09:00
Kota Kanbe	f821a26aec	Fix infinite retry at size overrun error in Slack report	2017-02-10 18:40:29 +09:00
James Sulinski	3380e905de	Add image information for docker containers	2017-02-09 01:05:12 -08:00
James Sulinski	b5c2718756	aptitude changelog defaults to using more, which is not interactive and breaks docker scans. Set PAGER=cat before running to default to cat.	2017-02-09 00:54:47 -08:00
James Sulinski	a03a803b89	Reduce privilege requirements for commands that don't need sudo	2017-02-09 00:47:08 -08:00
knqyf263	e743177ae6	Do not use sudo when echo	2017-02-09 17:43:15 +09:00
James Sulinski	6e12c69953	Don't check for a CVE DB when CVE Dictionary URL is defined	2017-02-09 00:36:23 -08:00
Justyn Shull	019ab77466	Fix typo contianer -> container	2017-02-08 17:17:12 -06:00
Kota Kanbe	1730caf124	Merge pull request #306 from knqyf263/update_lock Update glide.lock to fix import error	2017-01-30 17:50:03 +09:00
knqyf263	59d1533795	Update glide.lock to fix import error	2017-01-30 17:49:23 +09:00
Kota Kanbe	a6278ab7ea	Merge pull request #305 from future-architect/fix-changelog-cache Fix the changelog cache logic for ubuntu/debian	2017-01-28 04:16:04 +09:00
Kota Kanbe	42a6004c7d	Fix the changelog cache logic for ubuntu/debian	2017-01-28 04:08:57 +09:00
Kota Kanbe	6084c1b1d3	Merge pull request #304 from future-architect/fix-yum-updateinfo-opts Fix yum updateinfo options	2017-01-27 18:50:17 +09:00
Kota Kanbe	c96fbc1dba	Fix yum updateinfo options see #281	2017-01-27 18:42:14 +09:00
Kota Kanbe	5546a8b093	Merge pull request #303 from future-architect/glide Update glide.lock to fix create-log-dir error.	2017-01-26 21:37:23 +09:00
Kota Kanbe	6b76b38dcd	Update glide.lock to fix create-log-dir error. see https://github.com/kotakanbe/go-cve-dictionary/pull/40	2017-01-26 21:34:44 +09:00
Kota Kanbe	941e50b460	Merge pull request #302 from future-architect/log-dir Fix a bug in logging (file output) at scan command	2017-01-26 17:22:45 +09:00
Kota Kanbe	5a10e5c9ff	Fix a bug in logging (file output) at scan command Log of localhost was not output to file. #301	2017-01-26 17:21:03 +09:00
Kota Kanbe	883fe13756	Merge pull request #301 from knqyf263/add_logdir Add -log-dir option	2017-01-26 16:51:31 +09:00
knqyf263	2e7c34cf9f	Add -log-dir option	2017-01-26 15:36:30 +09:00
Kota Kanbe	9216efbd2f	Merge pull request #300 from knqyf263/use_assumeno Use --assumeno option	2017-01-24 15:07:58 +09:00
teppei-fukuda	6c8100e5b6	Use --assumeno option	2017-01-24 12:28:39 +09:00
Kota Kanbe	e7ef50bedf	Update README.md	2017-01-24 01:17:05 +09:00
Kota Kanbe	386ca3565a	Merge pull request #299 from future-architect/fix-pipe-problem Add -pipe flag #294	2017-01-24 01:13:48 +09:00
Kota Kanbe	2d854cd64d	Add -pipe flag #294 Solved the problem of trying to read from STDIN and stopping on the way when running from CRON or AWS Lambda.	2017-01-24 01:06:22 +09:00
Kota Kanbe	49b4b8be22	Update README.md	2017-01-23 18:47:42 +09:00
Kota Kanbe	db975ebfee	Merge pull request #297 from knqyf263/update_readme Update docker README	2017-01-23 18:36:31 +09:00
Kota Kanbe	d60a41139b	Merge pull request #298 from knqyf263/check_echo Check whether echo is executable with nopasswd	2017-01-23 17:42:17 +09:00
knqyf263	f62d869d27	Check whether echo is executable with nopasswd	2017-01-22 23:15:25 +09:00
knqyf263	6cbe3cdb93	Update docker README	2017-01-21 22:04:57 +09:00
akaishi takeshi	b13e7b9da4	update readme	2017-01-18 14:34:23 +09:00
Kota Kanbe	8fe34c8474	Fix architecture image file	2017-01-17 00:32:53 +09:00
Kota Kanbe	bef29be50f	Merge pull request #291 from future-architect/localscan Add local scan mode(Scan without SSH when target server is localhost)	2017-01-17 00:22:09 +09:00
Kota Kanbe	20275a1063	Add local scan mode. If the scan target server is localhost, Don't use SSH. #210	2017-01-17 00:16:46 +09:00
Kota Kanbe	910385b084	Merge pull request #288 from jiazio/add-lxd-support Add LXD support	2017-01-16 16:43:51 +09:00
Kota Kanbe	8e779374a7	Merge pull request #293 from future-architect/fix-rhel5 Fix RHEL5 scan stopped halfway	2017-01-13 06:41:26 +09:00
Kota Kanbe	44fc6f728e	Fix RHEL5 scan stopped halfway	2017-01-13 06:40:03 +09:00
Kota Kanbe	1f62dcf22a	Merge pull request #292 from future-architect/fix-bug-amazon-linux Fix amazon linux scan stopped halfway	2017-01-13 04:59:34 +09:00
Kota Kanbe	0416c3b561	Fix amazon linux scan stopped halfway	2017-01-13 04:56:59 +09:00
Kota Kanbe	a6912cae76	Merge pull request #289 from future-architect/rhel5 Support RHEL5	2017-01-10 16:34:37 +09:00
Kota Kanbe	63dfe8a952	Support RHEL5	2017-01-10 16:32:06 +09:00
Kota Kanbe	62d1b761bd	Update CHANGELOG	2017-01-10 16:24:02 +09:00
jiazio	6ecd70220b	Add LXD support	2017-01-06 22:11:13 +09:00