Logging factory

src/main/java/com/hierynomus/sshj/transport/IdentificationStringParser.java

@@ -17,20 +17,21 @@
 
 import net.schmizz.sshj.common.Buffer;
 import net.schmizz.sshj.common.ByteArrayUtils;
+import net.schmizz.sshj.common.LoggerFactory;
 import net.schmizz.sshj.transport.TransportException;
 import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.util.Arrays;
 
 public class IdentificationStringParser {
-    private static final Logger logger = LoggerFactory.getLogger(IdentificationStringParser.class);
+    private final Logger log;
     private final Buffer.PlainBuffer buffer;
 
     private byte[] EXPECTED_START_BYTES = new byte[] {'S', 'S', 'H', '-'};
 
-    public IdentificationStringParser(Buffer.PlainBuffer buffer) {
+    public IdentificationStringParser(LoggerFactory loggerFactory, Buffer.PlainBuffer buffer) {
+	this.log = loggerFactory.getLogger(IdentificationStringParser.class);
         this.buffer = buffer;
     }
 
@@ -65,16 +66,16 @@ private String readIdentification(Buffer.PlainBuffer lineBuffer) throws Buffer.B
         byte[] bytes = new byte[lineBuffer.available()];
         lineBuffer.readRawBytes(bytes);
         if (bytes.length > 255) {
-            logger.error("Incorrect identification String received, line was longer than expected: {}", new String(bytes));
-            logger.error("Just for good measure, bytes were: {}", ByteArrayUtils.printHex(bytes, 0, bytes.length));
+            log.error("Incorrect identification String received, line was longer than expected: {}", new String(bytes));
+            log.error("Just for good measure, bytes were: {}", ByteArrayUtils.printHex(bytes, 0, bytes.length));
             throw new TransportException("Incorrect identification: line too long: " + ByteArrayUtils.printHex(bytes, 0, bytes.length));
         }
         if (bytes[bytes.length - 2] != '\r') {
             String ident = new String(bytes, 0, bytes.length - 1);
-            logger.warn("Server identification has bad line ending, was expecting a '\\r\\n' however got: '{}' (hex: {})", (char) (bytes[bytes.length - 2] & 0xFF), Integer.toHexString(bytes[bytes.length - 2] & 0xFF));
-            logger.warn("Will treat the identification of this server '{}' leniently", ident);
+            log.warn("Server identification has bad line ending, was expecting a '\\r\\n' however got: '{}' (hex: {})", (char) (bytes[bytes.length - 2] & 0xFF), Integer.toHexString(bytes[bytes.length - 2] & 0xFF));
+            log.warn("Will treat the identification of this server '{}' leniently", ident);
             return ident;
-            // logger.error("Data received up til here was: {}", new String(bytes));
+            // log.error("Data received up til here was: {}", new String(bytes));
             // throw new TransportException("Incorrect identification: bad line ending: " + ByteArrayUtils.toHex(bytes, 0, bytes.length));
         }
 

src/main/java/net/schmizz/concurrent/Event.java

@@ -18,6 +18,8 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
 
+import net.schmizz.sshj.common.LoggerFactory;
+
 /**
  * An event can be set, cleared, or awaited, similar to Python's {@code threading.event}. The key difference is that a
  * waiter may be delivered an exception of parameterized type {@code T}.
@@ -42,8 +44,8 @@ public String toString() {
      * @param name    name of this event
      * @param chainer {@link ExceptionChainer} that will be used for chaining exceptions
      */
-    public Event(String name, ExceptionChainer<T> chainer) {
-        promise = new Promise<Object, T>(name, chainer);
+    public Event(String name, ExceptionChainer<T> chainer, LoggerFactory loggerFactory) {
+        promise = new Promise<Object, T>(name, chainer, loggerFactory);
     }
 
     /**
@@ -53,8 +55,8 @@ public Event(String name, ExceptionChainer<T> chainer) {
      * @param chainer {@link ExceptionChainer} that will be used for chaining exceptions
      * @param lock    lock to use
      */
-    public Event(String name, ExceptionChainer<T> chainer, ReentrantLock lock) {
-        promise = new Promise<Object, T>(name, chainer, lock);
+    public Event(String name, ExceptionChainer<T> chainer, ReentrantLock lock, LoggerFactory loggerFactory) {
+        promise = new Promise<Object, T>(name, chainer, lock, loggerFactory);
     }
 
     /** Sets this event to be {@code true}. Short for {@code set(true)}. */

src/main/java/net/schmizz/concurrent/Promise.java

@@ -16,13 +16,14 @@
 package net.schmizz.concurrent;
 
 import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 
+import net.schmizz.sshj.common.LoggerFactory;
+
 /**
  * Represents promised data of the parameterized type {@code V} and allows waiting on it. An exception may also be
  * delivered to a waiter, and will be of the parameterized type {@code T}.
@@ -32,8 +33,7 @@
  */
 public class Promise<V, T extends Throwable> {
 
-    private final Logger log = LoggerFactory.getLogger(getClass());
-
+    private final Logger log;
     private final String name;
     private final ExceptionChainer<T> chainer;
     private final ReentrantLock lock;
@@ -49,8 +49,8 @@ public class Promise<V, T extends Throwable> {
      * @param name    name of this promise
      * @param chainer {@link ExceptionChainer} that will be used for chaining exceptions
      */
-    public Promise(String name, ExceptionChainer<T> chainer) {
-        this(name, chainer, null);
+    public Promise(String name, ExceptionChainer<T> chainer, LoggerFactory loggerFactory) {
+        this(name, chainer, null, loggerFactory);
     }
 
     /**
@@ -60,10 +60,11 @@ public Promise(String name, ExceptionChainer<T> chainer) {
      * @param chainer {@link ExceptionChainer} that will be used for chaining exceptions
      * @param lock    lock to use
      */
-    public Promise(String name, ExceptionChainer<T> chainer, ReentrantLock lock) {
+    public Promise(String name, ExceptionChainer<T> chainer, ReentrantLock lock, LoggerFactory loggerFactory) {
         this.name = name;
         this.chainer = chainer;
         this.lock = lock == null ? new ReentrantLock() : lock;
+	this.log = loggerFactory.getLogger(getClass());
         this.cond = this.lock.newCondition();
     }
 

src/main/java/net/schmizz/keepalive/KeepAlive.java

@@ -22,14 +22,14 @@
 import org.slf4j.LoggerFactory;
 
 public abstract class KeepAlive extends Thread {
-    protected final Logger log = LoggerFactory.getLogger(getClass());
-
+    protected final Logger log;
     protected final ConnectionImpl conn;
 
     protected int keepAliveInterval = 0;
 
     protected KeepAlive(ConnectionImpl conn, String name) {
         this.conn = conn;
+        log = conn.getTransport().getConfig().getLoggerFactory().getLogger(getClass());
         setName(name);
     }
 

src/main/java/net/schmizz/sshj/AbstractService.java

@@ -22,14 +22,13 @@
 import net.schmizz.sshj.transport.Transport;
 import net.schmizz.sshj.transport.TransportException;
 import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /** An abstract class for {@link Service} that implements common or default functionality. */
 public abstract class AbstractService
         implements Service {
 
     /** Logger */
-    protected final Logger log = LoggerFactory.getLogger(getClass());
+    protected final Logger log;
 
     /** Assigned name of this service */
     protected final String name;
@@ -39,6 +38,7 @@ public abstract class AbstractService
     public AbstractService(String name, Transport trans) {
         this.name = name;
         this.trans = trans;
+	log = trans.getConfig().getLoggerFactory().getLogger(getClass());
     }
 
     @Override

src/main/java/net/schmizz/sshj/Config.java

@@ -17,6 +17,7 @@
 
 import net.schmizz.keepalive.KeepAliveProvider;
 import net.schmizz.sshj.common.Factory;
+import net.schmizz.sshj.common.LoggerFactory;
 import net.schmizz.sshj.signature.Signature;
 import net.schmizz.sshj.transport.cipher.Cipher;
 import net.schmizz.sshj.transport.compression.Compression;
@@ -175,4 +176,14 @@ public interface Config {
      * @param waitForServerIdentBeforeSendingClientIdent Whether to wait for the server ident.
      */
     void setWaitForServerIdentBeforeSendingClientIdent(boolean waitForServerIdentBeforeSendingClientIdent);
+
+    /**
+     * Sets the LoggerFactory to use.
+     */
+    void setLoggerFactory(LoggerFactory loggerFactory);
+
+    /**
+     * @return The LoggerFactory the SSHClient will use.
+     */
+    LoggerFactory getLoggerFactory();
 }

src/main/java/net/schmizz/sshj/ConfigImpl.java

@@ -16,6 +16,7 @@
 package net.schmizz.sshj;
 
 import net.schmizz.keepalive.KeepAliveProvider;
+import net.schmizz.sshj.common.LoggerFactory;
 import net.schmizz.sshj.common.Factory;
 import net.schmizz.sshj.signature.Signature;
 import net.schmizz.sshj.transport.cipher.Cipher;
@@ -45,6 +46,7 @@ public class ConfigImpl
     private List<Factory.Named<FileKeyProvider>> fileKeyProviderFactories;
 
     private boolean waitForServerIdentBeforeSendingClientIdent = false;
+    private LoggerFactory loggerFactory;
 
     @Override
     public List<Factory.Named<Cipher>> getCipherFactories() {
@@ -169,4 +171,14 @@ public boolean isWaitForServerIdentBeforeSendingClientIdent() {
     public void setWaitForServerIdentBeforeSendingClientIdent(boolean waitForServerIdentBeforeSendingClientIdent) {
         this.waitForServerIdentBeforeSendingClientIdent = waitForServerIdentBeforeSendingClientIdent;
     }
+
+    @Override
+    public LoggerFactory getLoggerFactory() {
+        return loggerFactory;
+    }
+
+    @Override
+    public void setLoggerFactory(LoggerFactory loggerFactory) {
+        this.loggerFactory = loggerFactory;
+    }
 }

src/main/java/net/schmizz/sshj/DefaultConfig.java

@@ -20,6 +20,7 @@
 import com.hierynomus.sshj.transport.cipher.StreamCiphers;
 import net.schmizz.keepalive.KeepAliveProvider;
 import net.schmizz.sshj.common.Factory;
+import net.schmizz.sshj.common.LoggerFactory;
 import net.schmizz.sshj.common.SecurityUtils;
 import net.schmizz.sshj.signature.SignatureDSA;
 import net.schmizz.sshj.signature.SignatureECDSA;
@@ -35,7 +36,6 @@
 import net.schmizz.sshj.userauth.keyprovider.PKCS8KeyFile;
 import net.schmizz.sshj.userauth.keyprovider.PuTTYKeyFile;
 import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.Arrays;
 import java.util.Iterator;
@@ -67,11 +67,12 @@
 public class DefaultConfig
         extends ConfigImpl {
 
-    private final Logger log = LoggerFactory.getLogger(getClass());
-
     private static final String VERSION = "SSHJ_0_17_2";
 
+    private Logger log;
+
     public DefaultConfig() {
+        setLoggerFactory(LoggerFactory.DEFAULT);
         setVersion(VERSION);
         final boolean bouncyCastleRegistered = SecurityUtils.isBouncyCastleRegistered();
         initKeyExchangeFactories(bouncyCastleRegistered);
@@ -84,6 +85,30 @@ public DefaultConfig() {
         setKeepAliveProvider(KeepAliveProvider.HEARTBEAT);
     }
 
+    /**
+     * Default SLF4J-based implementation of the SSHJ LoggerFactory.
+     */
+    public static class DefaultLoggerFactory implements LoggerFactory {
+        private DefaultLoggerFactory() {
+        }
+
+        @Override
+        public Logger getLogger(String name) {
+            return org.slf4j.LoggerFactory.getLogger(name);
+        }
+
+        @Override
+        public Logger getLogger(Class<?> clazz) {
+            return org.slf4j.LoggerFactory.getLogger(clazz);
+        }
+    }
+
+    @Override
+    public void setLoggerFactory(LoggerFactory loggerFactory) {
+	super.setLoggerFactory(loggerFactory);
+	log = loggerFactory.getLogger(getClass());
+    }
+
     protected void initKeyExchangeFactories(boolean bouncyCastleRegistered) {
         if (bouncyCastleRegistered)
             setKeyExchangeFactories(new Curve25519SHA256.Factory(),
@@ -141,7 +166,8 @@ protected void initCipherFactories() {
                 BlockCiphers.TwofishCBC(),
                 StreamCiphers.Arcfour(),
                 StreamCiphers.Arcfour128(),
-                StreamCiphers.Arcfour256()));
+                StreamCiphers.Arcfour256())
+        );
 
         boolean warn = false;
         // Ref. https://issues.apache.org/jira/browse/SSHD-24
@@ -167,17 +193,26 @@ protected void initCipherFactories() {
     }
 
     protected void initSignatureFactories() {
-        setSignatureFactories(new SignatureECDSA.Factory(), new SignatureRSA.Factory(), new SignatureDSA.Factory(), new SignatureEdDSA.Factory());
+        setSignatureFactories(
+                new SignatureECDSA.Factory(),
+                new SignatureRSA.Factory(),
+                new SignatureDSA.Factory(),
+                new SignatureEdDSA.Factory()
+        );
     }
 
     protected void initMACFactories() {
-        setMACFactories(new HMACSHA1.Factory(), new HMACSHA196.Factory(), new HMACMD5.Factory(),
-                new HMACMD596.Factory(), new HMACSHA2256.Factory(), new HMACSHA2512.Factory());
+        setMACFactories(
+                new HMACSHA1.Factory(),
+                new HMACSHA196.Factory(),
+                new HMACMD5.Factory(),
+                new HMACMD596.Factory(),
+                new HMACSHA2256.Factory(),
+                new HMACSHA2512.Factory()
+        );
     }
 
     protected void initCompressionFactories() {
         setCompressionFactories(new NoneCompression.Factory());
     }
-
-
 }

src/main/java/net/schmizz/sshj/SSHClient.java

@@ -16,6 +16,7 @@
 package net.schmizz.sshj;
 
 import net.schmizz.sshj.common.Factory;
+import net.schmizz.sshj.common.LoggerFactory;
 import net.schmizz.sshj.common.SSHException;
 import net.schmizz.sshj.common.SecurityUtils;
 import net.schmizz.sshj.connection.Connection;
@@ -54,7 +55,6 @@
 import net.schmizz.sshj.xfer.scp.SCPFileTransfer;
 import org.ietf.jgss.Oid;
 import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import javax.security.auth.login.LoginContext;
 import java.io.Closeable;
@@ -114,7 +114,8 @@ public class SSHClient
     public static final int DEFAULT_PORT = 22;
 
     /** Logger */
-    protected final Logger log = LoggerFactory.getLogger(getClass());
+    protected final LoggerFactory loggerFactory;
+    protected final Logger log;
 
     /** Transport layer */
     protected final Transport trans;
@@ -139,6 +140,8 @@ public SSHClient() {
      */
     public SSHClient(Config config) {
         super(DEFAULT_PORT);
+	loggerFactory = config.getLoggerFactory();
+	log = loggerFactory.getLogger(getClass());
         this.trans = new TransportImpl(config, this);
         this.auth = new UserAuthImpl(trans);
         this.conn = new ConnectionImpl(trans, config.getKeepAliveProvider());
@@ -211,6 +214,7 @@ public void auth(String username, Iterable<AuthMethod> methods)
         checkConnected();
         final Deque<UserAuthException> savedEx = new LinkedList<>();
         for (AuthMethod method: methods) {
+            method.setLoggerFactory(loggerFactory);
             try {
                 if (auth.authenticate(username, (Service) conn, method, trans.getTimeoutMs()))
                     return;
@@ -626,7 +630,7 @@ public void loadKnownHosts()
      */
     public void loadKnownHosts(File location)
             throws IOException {
-        addHostKeyVerifier(new OpenSSHKnownHosts(location));
+        addHostKeyVerifier(new OpenSSHKnownHosts(location, loggerFactory));
     }
 
     /**
@@ -644,7 +648,7 @@ public void loadKnownHosts(File location)
      */
     public LocalPortForwarder newLocalPortForwarder(LocalPortForwarder.Parameters parameters,
                                                     ServerSocket serverSocket) {
-        LocalPortForwarder forwarder = new LocalPortForwarder(conn, parameters, serverSocket);
+        LocalPortForwarder forwarder = new LocalPortForwarder(conn, parameters, serverSocket, loggerFactory);
         forwarders.add(forwarder);
         return forwarder;
     }
@@ -673,7 +677,7 @@ public X11Forwarder registerX11Forwarder(ConnectListener listener) {
     public SCPFileTransfer newSCPFileTransfer() {
         checkConnected();
         checkAuthenticated();
-        return new SCPFileTransfer(this);
+        return new SCPFileTransfer(this, loggerFactory);
     }
 
     /**