Mirrors/sftpgo
1
0
Fork 0
mirror of https://github.com/drakkan/sftpgo.git synced 2025-12-07 06:40:54 +03:00
Code Issues Packages Projects Releases Wiki Activity

Add connectionID to as many entries as possible

Browse Source 
Signed-off-by: Jo Vandeginste <Jo.Vandeginste@kuleuven.be>
This commit is contained in:
Jo Vandeginste
2019-09-05 16:21:35 +02:00
committed by drakkan
parent 53d70b68d8
commit 0737c672f5
20 changed files with 156 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
api/api_test.go
View File

@@ -58,7 +58,7 @@ func TestMain(m *testing.M) {
err := dataprovider.Initialize(providerConf, configDir) err := dataprovider.Initialize(providerConf, configDir)
if err != nil { if err != nil {
logger.Warn(logSender, "error initializing data provider: %v", err) logger.Warn(logSender, "", "error initializing data provider: %v", err)
os.Exit(1) os.Exit(1)
} }
dataProvider := dataprovider.GetProvider() dataProvider := dataprovider.GetProvider()
@@ -72,7 +72,7 @@ func TestMain(m *testing.M) {
api.SetDataProvider(dataProvider) api.SetDataProvider(dataProvider)
go func() { go func() {
logger.Debug(logSender, "initializing HTTP server with config %+v", httpdConf) logger.Debug(logSender, "", "initializing HTTP server with config %+v", httpdConf)
s := &http.Server{ s := &http.Server{
Addr: fmt.Sprintf("%s:%d", httpdConf.BindAddress, httpdConf.BindPort), Addr: fmt.Sprintf("%s:%d", httpdConf.BindAddress, httpdConf.BindPort),
Handler: router, Handler: router,
@@ -81,7 +81,7 @@ func TestMain(m *testing.M) {
MaxHeaderBytes: 1 << 20, // 1MB MaxHeaderBytes: 1 << 20, // 1MB
} }
if err := s.ListenAndServe(); err != nil { if err := s.ListenAndServe(); err != nil {
logger.Error(logSender, "could not start HTTP server: %v", err) logger.Error(logSender, "", "could not start HTTP server: %v", err)
} }
}() }()

4
api/quota.go
View File

@@ -31,10 +31,10 @@ func startQuotaScan(w http.ResponseWriter, r *http.Request) {
go func() { go func() {
numFiles, size, _, err := utils.ScanDirContents(user.HomeDir) numFiles, size, _, err := utils.ScanDirContents(user.HomeDir)
if err != nil { if err != nil {
logger.Warn(logSender, "error scanning user home dir %v: %v", user.HomeDir, err) logger.Warn(logSender, "", "error scanning user home dir %v: %v", user.HomeDir, err)
} else { } else {
err := dataprovider.UpdateUserQuota(dataProvider, user, numFiles, size, true) err := dataprovider.UpdateUserQuota(dataProvider, user, numFiles, size, true)
logger.Debug(logSender, "user dir scanned, user: %v, dir: %v, error: %v", user.Username, user.HomeDir, err) logger.Debug(logSender, "", "user dir scanned, user: %v, dir: %v, error: %v", user.Username, user.HomeDir, err)
} }
sftpd.RemoveQuotaScan(user.Username) sftpd.RemoveQuotaScan(user.Username)
}() }()

14
cmd/serve.go
View File

@@ -127,7 +127,7 @@ func startServe() {
logLevel = zerolog.InfoLevel logLevel = zerolog.InfoLevel
} }
logger.InitLogger(logFilePath, logMaxSize, logMaxBackups, logMaxAge, logCompress, logLevel) logger.InitLogger(logFilePath, logMaxSize, logMaxBackups, logMaxAge, logCompress, logLevel)
logger.Info(logSender, "starting SFTPGo, config dir: %v, config file: %v, log max size: %v log max backups: %v "+ logger.Info(logSender, "", "starting SFTPGo, config dir: %v, config file: %v, log max size: %v log max backups: %v "+
"log max age: %v log verbose: %v, log compress: %v", configDir, configFile, logMaxSize, logMaxBackups, logMaxAge, "log max age: %v log verbose: %v, log compress: %v", configDir, configFile, logMaxSize, logMaxBackups, logMaxAge,
logVerbose, logCompress) logVerbose, logCompress)
config.LoadConfig(configDir, configFile) config.LoadConfig(configDir, configFile)
@@ -135,7 +135,7 @@ func startServe() {
err := dataprovider.Initialize(providerConf, configDir) err := dataprovider.Initialize(providerConf, configDir)
if err != nil { if err != nil {
logger.Error(logSender, "error initializing data provider: %v", err) logger.Error(logSender, "", "error initializing data provider: %v", err)
logger.ErrorToConsole("error initializing data provider: %v", err) logger.ErrorToConsole("error initializing data provider: %v", err)
os.Exit(1) os.Exit(1)
} }
@@ -149,9 +149,9 @@ func startServe() {
shutdown := make(chan bool) shutdown := make(chan bool)
go func() { go func() {
logger.Debug(logSender, "initializing SFTP server with config %+v", sftpdConf) logger.Debug(logSender, "", "initializing SFTP server with config %+v", sftpdConf)
if err := sftpdConf.Initialize(configDir); err != nil { if err := sftpdConf.Initialize(configDir); err != nil {
logger.Error(logSender, "could not start SFTP server: %v", err) logger.Error(logSender, "", "could not start SFTP server: %v", err)
logger.ErrorToConsole("could not start SFTP server: %v", err) logger.ErrorToConsole("could not start SFTP server: %v", err)
} }
shutdown <- true shutdown <- true
@@ -162,7 +162,7 @@ func startServe() {
api.SetDataProvider(dataProvider) api.SetDataProvider(dataProvider)
go func() { go func() {
logger.Debug(logSender, "initializing HTTP server with config %+v", httpdConf) logger.Debug(logSender, "", "initializing HTTP server with config %+v", httpdConf)
s := &http.Server{ s := &http.Server{
Addr: fmt.Sprintf("%s:%d", httpdConf.BindAddress, httpdConf.BindPort), Addr: fmt.Sprintf("%s:%d", httpdConf.BindAddress, httpdConf.BindPort),
Handler: router, Handler: router,
@@ -171,13 +171,13 @@ func startServe() {
MaxHeaderBytes: 1 << 20, // 1MB MaxHeaderBytes: 1 << 20, // 1MB
} }
if err := s.ListenAndServe(); err != nil { if err := s.ListenAndServe(); err != nil {
logger.Error(logSender, "could not start HTTP server: %v", err) logger.Error(logSender, "", "could not start HTTP server: %v", err)
logger.ErrorToConsole("could not start HTTP server: %v", err) logger.ErrorToConsole("could not start HTTP server: %v", err)
} }
shutdown <- true shutdown <- true
}() }()
} else { } else {
logger.Debug(logSender, "HTTP server not started, disabled in config file") logger.Debug(logSender, "", "HTTP server not started, disabled in config file")
logger.DebugToConsole("HTTP server not started, disabled in config file") logger.DebugToConsole("HTTP server not started, disabled in config file")
} }

8
config/config.go
View File

@@ -114,13 +114,13 @@ func LoadConfig(configDir, configName string) error {
viper.AddConfigPath(".") viper.AddConfigPath(".")
viper.SetConfigName(configName) viper.SetConfigName(configName)
if err = viper.ReadInConfig(); err != nil { if err = viper.ReadInConfig(); err != nil {
logger.Warn(logSender, "error loading configuration file: %v. Default configuration will be used: %+v", err, globalConf) logger.Warn(logSender, "", "error loading configuration file: %v. Default configuration will be used: %+v", err, globalConf)
logger.WarnToConsole("error loading configuration file: %v. Default configuration will be used.", err) logger.WarnToConsole("error loading configuration file: %v. Default configuration will be used.", err)
return err return err
} }
err = viper.Unmarshal(&globalConf) err = viper.Unmarshal(&globalConf)
if err != nil { if err != nil {
logger.Warn(logSender, "error parsing configuration file: %v. Default configuration will be used: %+v", err, globalConf) logger.Warn(logSender, "", "error parsing configuration file: %v. Default configuration will be used: %+v", err, globalConf)
logger.WarnToConsole("error parsing configuration file: %v. Default configuration will be used.", err) logger.WarnToConsole("error parsing configuration file: %v. Default configuration will be used.", err)
return err return err
} }
@@ -131,9 +131,9 @@ func LoadConfig(configDir, configName string) error {
err = fmt.Errorf("Invalid upload_mode 0 and 1 are supported, configured: %v reset upload_mode to 0", err = fmt.Errorf("Invalid upload_mode 0 and 1 are supported, configured: %v reset upload_mode to 0",
globalConf.SFTPD.UploadMode) globalConf.SFTPD.UploadMode)
globalConf.SFTPD.UploadMode = 0 globalConf.SFTPD.UploadMode = 0
logger.Warn(logSender, "Configuration error: %v", err) logger.Warn(logSender, "", "Configuration error: %v", err)
logger.WarnToConsole("Configuration error: %v", err) logger.WarnToConsole("Configuration error: %v", err)
} }
logger.Debug(logSender, "config file used: '%v', config loaded: %+v", viper.ConfigFileUsed(), globalConf) logger.Debug(logSender, "", "config file used: '%v', config loaded: %+v", viper.ConfigFileUsed(), globalConf)
return err return err
} }

14
dataprovider/bolt.go
View File

@@ -34,13 +34,13 @@ func initializeBoltProvider(basePath string) error {
FreelistType: bolt.FreelistArrayType, FreelistType: bolt.FreelistArrayType,
Timeout: 5 * time.Second}) Timeout: 5 * time.Second})
if err == nil { if err == nil {
logger.Debug(logSender, "bolt key store handle created") logger.Debug(logSender, "", "bolt key store handle created")
err = dbHandle.Update(func(tx *bolt.Tx) error { err = dbHandle.Update(func(tx *bolt.Tx) error {
_, e := tx.CreateBucketIfNotExists(usersBucket) _, e := tx.CreateBucketIfNotExists(usersBucket)
return e return e
}) })
if err != nil { if err != nil {
logger.Warn(logSender, "error creating users bucket: %v", err) logger.Warn(logSender, "", "error creating users bucket: %v", err)
return err return err
} }
err = dbHandle.Update(func(tx *bolt.Tx) error { err = dbHandle.Update(func(tx *bolt.Tx) error {
@@ -48,12 +48,12 @@ func initializeBoltProvider(basePath string) error {
return e return e
}) })
if err != nil { if err != nil {
logger.Warn(logSender, "error creating username idx bucket: %v", err) logger.Warn(logSender, "", "error creating username idx bucket: %v", err)
return err return err
} }
provider = BoltProvider{dbHandle: dbHandle} provider = BoltProvider{dbHandle: dbHandle}
} else { } else {
logger.Warn(logSender, "error creating bolt key/value store handler: %v", err) logger.Warn(logSender, "", "error creating bolt key/value store handler: %v", err)
} }
return err return err
} }
@@ -65,7 +65,7 @@ func (p BoltProvider) validateUserAndPass(username string, password string) (Use
} }
user, err := p.userExists(username) user, err := p.userExists(username)
if err != nil { if err != nil {
logger.Warn(logSender, "error authenticating user: %v, error: %v", username, err) logger.Warn(logSender, "", "error authenticating user: %v, error: %v", username, err)
return user, err return user, err
} }
return checkUserAndPass(user, password) return checkUserAndPass(user, password)
@@ -78,7 +78,7 @@ func (p BoltProvider) validateUserAndPubKey(username string, pubKey string) (Use
} }
user, err := p.userExists(username) user, err := p.userExists(username)
if err != nil { if err != nil {
logger.Warn(logSender, "error authenticating user: %v, error: %v", username, err) logger.Warn(logSender, "", "error authenticating user: %v, error: %v", username, err)
return user, err return user, err
} }
return checkUserAndPubKey(user, pubKey) return checkUserAndPubKey(user, pubKey)
@@ -140,7 +140,7 @@ func (p BoltProvider) updateQuota(username string, filesAdd int, sizeAdd int64,
func (p BoltProvider) getUsedQuota(username string) (int, int64, error) { func (p BoltProvider) getUsedQuota(username string) (int, int64, error) {
user, err := p.userExists(username) user, err := p.userExists(username)
if err != nil { if err != nil {
logger.Warn(logSender, "unable to get quota for user '%v' error: %v", username, err) logger.Warn(logSender, "", "unable to get quota for user '%v' error: %v", username, err)
return 0, 0, err return 0, 0, err
} }
return user.UsedQuotaFiles, user.UsedQuotaSize, err return user.UsedQuotaFiles, user.UsedQuotaSize, err

8
dataprovider/dataprovider.go
View File

@@ -275,19 +275,19 @@ func checkUserAndPass(user User, password string) (User, error) {
if strings.HasPrefix(user.Password, argonPwdPrefix) { if strings.HasPrefix(user.Password, argonPwdPrefix) {
match, err = argon2id.ComparePasswordAndHash(password, user.Password) match, err = argon2id.ComparePasswordAndHash(password, user.Password)
if err != nil { if err != nil {
logger.Warn(logSender, "error comparing password with argon hash: %v", err) logger.Warn(logSender, "", "error comparing password with argon hash: %v", err)
return user, err return user, err
} }
} else if strings.HasPrefix(user.Password, bcryptPwdPrefix) { } else if strings.HasPrefix(user.Password, bcryptPwdPrefix) {
if err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil { if err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
logger.Warn(logSender, "error comparing password with bcrypt hash: %v", err) logger.Warn(logSender, "", "error comparing password with bcrypt hash: %v", err)
return user, err return user, err
} }
match = true match = true
} else if utils.IsStringPrefixInSlice(user.Password, pbkdfPwdPrefixes) { } else if utils.IsStringPrefixInSlice(user.Password, pbkdfPwdPrefixes) {
match, err = comparePbkdf2PasswordAndHash(password, user.Password) match, err = comparePbkdf2PasswordAndHash(password, user.Password)
if err != nil { if err != nil {
logger.Warn(logSender, "error comparing password with pbkdf2 sha256 hash: %v", err) logger.Warn(logSender, "", "error comparing password with pbkdf2 sha256 hash: %v", err)
return user, err return user, err
} }
} }
@@ -304,7 +304,7 @@ func checkUserAndPubKey(user User, pubKey string) (User, error) {
for i, k := range user.PublicKeys { for i, k := range user.PublicKeys {
storedPubKey, _, _, _, err := ssh.ParseAuthorizedKey([]byte(k)) storedPubKey, _, _, _, err := ssh.ParseAuthorizedKey([]byte(k))
if err != nil { if err != nil {
logger.Warn(logSender, "error parsing stored public key %d for user %v: %v", i, user.Username, err) logger.Warn(logSender, "", "error parsing stored public key %d for user %v: %v", i, user.Username, err)
return user, err return user, err
} }
if string(storedPubKey.Marshal()) == pubKey { if string(storedPubKey.Marshal()) == pubKey {

8
dataprovider/mysql.go
View File

@@ -26,13 +26,13 @@ func initializeMySQLProvider() error {
dbHandle, err := sql.Open("mysql", connectionString) dbHandle, err := sql.Open("mysql", connectionString)
if err == nil { if err == nil {
numCPU := runtime.NumCPU() numCPU := runtime.NumCPU()
logger.Debug(logSender, "mysql database handle created, connection string: '%v', pool size: %v", connectionString, numCPU) logger.Debug(logSender, "", "mysql database handle created, connection string: '%v', pool size: %v", connectionString, numCPU)
dbHandle.SetMaxIdleConns(numCPU) dbHandle.SetMaxIdleConns(numCPU)
dbHandle.SetMaxOpenConns(numCPU) dbHandle.SetMaxOpenConns(numCPU)
dbHandle.SetConnMaxLifetime(1800 * time.Second) dbHandle.SetConnMaxLifetime(1800 * time.Second)
provider = MySQLProvider{dbHandle: dbHandle} provider = MySQLProvider{dbHandle: dbHandle}
} else { } else {
logger.Warn(logSender, "error creating mysql database handler, connection string: '%v', error: %v", connectionString, err) logger.Warn(logSender, "", "error creating mysql database handler, connection string: '%v', error: %v", connectionString, err)
} }
return err return err
} }
@@ -52,7 +52,7 @@ func (p MySQLProvider) getUserByID(ID int64) (User, error) {
func (p MySQLProvider) updateQuota(username string, filesAdd int, sizeAdd int64, reset bool) error { func (p MySQLProvider) updateQuota(username string, filesAdd int, sizeAdd int64, reset bool) error {
tx, err := p.dbHandle.Begin() tx, err := p.dbHandle.Begin()
if err != nil { if err != nil {
logger.Warn(logSender, "error starting transaction to update quota for user %v: %v", username, err) logger.Warn(logSender, "", "error starting transaction to update quota for user %v: %v", username, err)
return err return err
} }
err = sqlCommonUpdateQuota(username, filesAdd, sizeAdd, reset, p.dbHandle) err = sqlCommonUpdateQuota(username, filesAdd, sizeAdd, reset, p.dbHandle)
@@ -62,7 +62,7 @@ func (p MySQLProvider) updateQuota(username string, filesAdd int, sizeAdd int64,
err = tx.Rollback() err = tx.Rollback()
} }
if err != nil { if err != nil {
logger.Warn(logSender, "error closing transaction to update quota for user %v: %v", username, err) logger.Warn(logSender, "", "error closing transaction to update quota for user %v: %v", username, err)
} }
return err return err
} }

8
dataprovider/pgsql.go
View File

@@ -25,12 +25,12 @@ func initializePGSQLProvider() error {
dbHandle, err := sql.Open("postgres", connectionString) dbHandle, err := sql.Open("postgres", connectionString)
if err == nil { if err == nil {
numCPU := runtime.NumCPU() numCPU := runtime.NumCPU()
logger.Debug(logSender, "postgres database handle created, connection string: '%v', pool size: %v", connectionString, numCPU) logger.Debug(logSender, "", "postgres database handle created, connection string: '%v', pool size: %v", connectionString, numCPU)
dbHandle.SetMaxIdleConns(numCPU) dbHandle.SetMaxIdleConns(numCPU)
dbHandle.SetMaxOpenConns(numCPU) dbHandle.SetMaxOpenConns(numCPU)
provider = PGSQLProvider{dbHandle: dbHandle} provider = PGSQLProvider{dbHandle: dbHandle}
} else { } else {
logger.Warn(logSender, "error creating postgres database handler, connection string: '%v', error: %v", connectionString, err) logger.Warn(logSender, "", "error creating postgres database handler, connection string: '%v', error: %v", connectionString, err)
} }
return err return err
} }
@@ -50,7 +50,7 @@ func (p PGSQLProvider) getUserByID(ID int64) (User, error) {
func (p PGSQLProvider) updateQuota(username string, filesAdd int, sizeAdd int64, reset bool) error { func (p PGSQLProvider) updateQuota(username string, filesAdd int, sizeAdd int64, reset bool) error {
tx, err := p.dbHandle.Begin() tx, err := p.dbHandle.Begin()
if err != nil { if err != nil {
logger.Warn(logSender, "error starting transaction to update quota for user %v: %v", username, err) logger.Warn(logSender, "", "error starting transaction to update quota for user %v: %v", username, err)
return err return err
} }
err = sqlCommonUpdateQuota(username, filesAdd, sizeAdd, reset, p.dbHandle) err = sqlCommonUpdateQuota(username, filesAdd, sizeAdd, reset, p.dbHandle)
@@ -60,7 +60,7 @@ func (p PGSQLProvider) updateQuota(username string, filesAdd int, sizeAdd int64,
err = tx.Rollback() err = tx.Rollback()
} }
if err != nil { if err != nil {
logger.Warn(logSender, "error closing transaction to update quota for user %v: %v", username, err) logger.Warn(logSender, "", "error closing transaction to update quota for user %v: %v", username, err)
} }
return err return err
} }

28
dataprovider/sqlcommon.go
View File

@@ -15,7 +15,7 @@ func getUserByUsername(username string, dbHandle *sql.DB) (User, error) {
q := getUserByUsernameQuery() q := getUserByUsernameQuery()
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Debug(logSender, "error preparing database query %v: %v", q, err) logger.Debug(logSender, "", "error preparing database query %v: %v", q, err)
return user, err return user, err
} }
defer stmt.Close() defer stmt.Close()
@@ -31,7 +31,7 @@ func sqlCommonValidateUserAndPass(username string, password string, dbHandle *sq
} }
user, err := getUserByUsername(username, dbHandle) user, err := getUserByUsername(username, dbHandle)
if err != nil { if err != nil {
logger.Warn(logSender, "error authenticating user: %v, error: %v", username, err) logger.Warn(logSender, "", "error authenticating user: %v, error: %v", username, err)
return user, err return user, err
} }
return checkUserAndPass(user, password) return checkUserAndPass(user, password)
@@ -44,7 +44,7 @@ func sqlCommonValidateUserAndPubKey(username string, pubKey string, dbHandle *sq
} }
user, err := getUserByUsername(username, dbHandle) user, err := getUserByUsername(username, dbHandle)
if err != nil { if err != nil {
logger.Warn(logSender, "error authenticating user: %v, error: %v", username, err) logger.Warn(logSender, "", "error authenticating user: %v, error: %v", username, err)
return user, err return user, err
} }
return checkUserAndPubKey(user, pubKey) return checkUserAndPubKey(user, pubKey)
@@ -55,7 +55,7 @@ func sqlCommonGetUserByID(ID int64, dbHandle *sql.DB) (User, error) {
q := getUserByIDQuery() q := getUserByIDQuery()
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Debug(logSender, "error preparing database query %v: %v", q, err) logger.Debug(logSender, "", "error preparing database query %v: %v", q, err)
return user, err return user, err
} }
defer stmt.Close() defer stmt.Close()
@@ -68,16 +68,16 @@ func sqlCommonUpdateQuota(username string, filesAdd int, sizeAdd int64, reset bo
q := getUpdateQuotaQuery(reset) q := getUpdateQuotaQuery(reset)
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Debug(logSender, "error preparing database query %v: %v", q, err) logger.Debug(logSender, "", "error preparing database query %v: %v", q, err)
return err return err
} }
defer stmt.Close() defer stmt.Close()
_, err = stmt.Exec(sizeAdd, filesAdd, utils.GetTimeAsMsSinceEpoch(time.Now()), username) _, err = stmt.Exec(sizeAdd, filesAdd, utils.GetTimeAsMsSinceEpoch(time.Now()), username)
if err == nil { if err == nil {
logger.Debug(logSender, "quota updated for user %v, files increment: %v size increment: %v is reset? %v", logger.Debug(logSender, "", "quota updated for user %v, files increment: %v size increment: %v is reset? %v",
username, filesAdd, sizeAdd, reset) username, filesAdd, sizeAdd, reset)
} else { } else {
logger.Warn(logSender, "error updating quota for username %v: %v", username, err) logger.Warn(logSender, "", "error updating quota for username %v: %v", username, err)
} }
return err return err
} }
@@ -86,7 +86,7 @@ func sqlCommonGetUsedQuota(username string, dbHandle *sql.DB) (int, int64, error
q := getQuotaQuery() q := getQuotaQuery()
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Warn(logSender, "error preparing database query %v: %v", q, err) logger.Warn(logSender, "", "error preparing database query %v: %v", q, err)
return 0, 0, err return 0, 0, err
} }
defer stmt.Close() defer stmt.Close()
@@ -95,7 +95,7 @@ func sqlCommonGetUsedQuota(username string, dbHandle *sql.DB) (int, int64, error
var usedSize int64 var usedSize int64
err = stmt.QueryRow(username).Scan(&usedSize, &usedFiles) err = stmt.QueryRow(username).Scan(&usedSize, &usedFiles)
if err != nil { if err != nil {
logger.Warn(logSender, "error getting user quota: %v, error: %v", username, err) logger.Warn(logSender, "", "error getting user quota: %v, error: %v", username, err)
return 0, 0, err return 0, 0, err
} }
return usedFiles, usedSize, err return usedFiles, usedSize, err
@@ -106,7 +106,7 @@ func sqlCommonCheckUserExists(username string, dbHandle *sql.DB) (User, error) {
q := getUserByUsernameQuery() q := getUserByUsernameQuery()
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Warn(logSender, "error preparing database query %v: %v", q, err) logger.Warn(logSender, "", "error preparing database query %v: %v", q, err)
return user, err return user, err
} }
defer stmt.Close() defer stmt.Close()
@@ -122,7 +122,7 @@ func sqlCommonAddUser(user User, dbHandle *sql.DB) error {
q := getAddUserQuery() q := getAddUserQuery()
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Warn(logSender, "error preparing database query %v: %v", q, err) logger.Warn(logSender, "", "error preparing database query %v: %v", q, err)
return err return err
} }
defer stmt.Close() defer stmt.Close()
@@ -147,7 +147,7 @@ func sqlCommonUpdateUser(user User, dbHandle *sql.DB) error {
q := getUpdateUserQuery() q := getUpdateUserQuery()
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Warn(logSender, "error preparing database query %v: %v", q, err) logger.Warn(logSender, "", "error preparing database query %v: %v", q, err)
return err return err
} }
defer stmt.Close() defer stmt.Close()
@@ -168,7 +168,7 @@ func sqlCommonDeleteUser(user User, dbHandle *sql.DB) error {
q := getDeleteUserQuery() q := getDeleteUserQuery()
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Warn(logSender, "error preparing database query %v: %v", q, err) logger.Warn(logSender, "", "error preparing database query %v: %v", q, err)
return err return err
} }
defer stmt.Close() defer stmt.Close()
@@ -181,7 +181,7 @@ func sqlCommonGetUsers(limit int, offset int, order string, username string, dbH
q := getUsersQuery(order, username) q := getUsersQuery(order, username)
stmt, err := dbHandle.Prepare(q) stmt, err := dbHandle.Prepare(q)
if err != nil { if err != nil {
logger.Warn(logSender, "error preparing database query %v: %v", q, err) logger.Warn(logSender, "", "error preparing database query %v: %v", q, err)
return nil, err return nil, err
} }
defer stmt.Close() defer stmt.Close()

6
dataprovider/sqlite.go
View File

@@ -25,7 +25,7 @@ func initializeSQLiteProvider(basePath string) error {
} }
fi, err := os.Stat(dbPath) fi, err := os.Stat(dbPath)
if err != nil { if err != nil {
logger.Warn(logSender, "sqlite database file does not exists, please be sure to create and initialize"+ logger.Warn(logSender, "", "sqlite database file does not exists, please be sure to create and initialize"+
" a database before starting sftpgo") " a database before starting sftpgo")
return err return err
} }
@@ -39,11 +39,11 @@ func initializeSQLiteProvider(basePath string) error {
} }
dbHandle, err := sql.Open("sqlite3", connectionString) dbHandle, err := sql.Open("sqlite3", connectionString)
if err == nil { if err == nil {
logger.Debug(logSender, "sqlite database handle created, connection string: '%v'", connectionString) logger.Debug(logSender, "", "sqlite database handle created, connection string: '%v'", connectionString)
dbHandle.SetMaxOpenConns(1) dbHandle.SetMaxOpenConns(1)
provider = SQLiteProvider{dbHandle: dbHandle} provider = SQLiteProvider{dbHandle: dbHandle}
} else { } else {
logger.Warn(logSender, "error creating sqlite database handler, connection string: '%v', error: %v", connectionString, err) logger.Warn(logSender, "", "error creating sqlite database handler, connection string: '%v', error: %v", connectionString, err)
} }
return err return err
} }

16
logger/logger.go
View File

@@ -59,23 +59,23 @@ func InitLogger(logFilePath string, logMaxSize int, logMaxBackups int, logMaxAge
} }
// Debug logs at debug level for the specified sender // Debug logs at debug level for the specified sender
func Debug(sender string, format string, v ...interface{}) { func Debug(sender string, connectionID string, format string, v ...interface{}) {
logger.Debug().Str("sender", sender).Msg(fmt.Sprintf(format, v...)) logger.Debug().Str("sender", sender).Str("connection_id", connectionID).Msg(fmt.Sprintf(format, v...))
} }
// Info logs at info level for the specified sender // Info logs at info level for the specified sender
func Info(sender string, format string, v ...interface{}) { func Info(sender string, connectionID string, format string, v ...interface{}) {
logger.Info().Str("sender", sender).Msg(fmt.Sprintf(format, v...)) logger.Info().Str("sender", sender).Str("connection_id", connectionID).Msg(fmt.Sprintf(format, v...))
} }
// Warn logs at warn level for the specified sender // Warn logs at warn level for the specified sender
func Warn(sender string, format string, v ...interface{}) { func Warn(sender string, connectionID string, format string, v ...interface{}) {
logger.Warn().Str("sender", sender).Msg(fmt.Sprintf(format, v...)) logger.Warn().Str("sender", sender).Str("connection_id", connectionID).Msg(fmt.Sprintf(format, v...))
} }
// Error logs at error level for the specified sender // Error logs at error level for the specified sender
func Error(sender string, format string, v ...interface{}) { func Error(sender string, connectionID string, format string, v ...interface{}) {
logger.Error().Str("sender", sender).Msg(fmt.Sprintf(format, v...)) logger.Error().Str("sender", sender).Str("connection_id", connectionID).Msg(fmt.Sprintf(format, v...))
} }
// DebugToConsole logs at debug level to stdout // DebugToConsole logs at debug level to stdout

66
sftpd/handler.go
View File

@@ -62,11 +62,11 @@ func (c Connection) Fileread(request *sftp.Request) (io.ReaderAt, error) {
file, err := os.Open(p) file, err := os.Open(p)
if err != nil { if err != nil {
logger.Error(logSender, "could not open file %#v for reading: %v", p, err) logger.Error(logSender, c.ID, "could not open file %#v for reading: %v", p, err)
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
logger.Debug(logSender, "fileread requested for path: %#v, user: %v", p, c.User.Username) logger.Debug(logSender, c.ID, "fileread requested for path: %#v, user: %v", p, c.User.Username)
transfer := Transfer{ transfer := Transfer{
file: file, file: file,
@@ -113,13 +113,13 @@ func (c Connection) Filewrite(request *sftp.Request) (io.WriterAt, error) {
} }
if statErr != nil { if statErr != nil {
logger.Error(logSender, "error performing file stat %#v: %v", p, statErr) logger.Error(logSender, c.ID, "error performing file stat %#v: %v", p, statErr)
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
// This happen if we upload a file that has the same name of an existing directory // This happen if we upload a file that has the same name of an existing directory
if stat.IsDir() { if stat.IsDir() {
logger.Warn(logSender, "attempted to open a directory for writing to: %#v", p) logger.Warn(logSender, c.ID, "attempted to open a directory for writing to: %#v", p)
return nil, sftp.ErrSshFxOpUnsupported return nil, sftp.ErrSshFxOpUnsupported
} }
@@ -141,7 +141,7 @@ func (c Connection) Filecmd(request *sftp.Request) error {
return sftp.ErrSshFxOpUnsupported return sftp.ErrSshFxOpUnsupported
} }
logger.Debug(logSender, "new cmd, method: %v user: %v sourcePath: %#v, targetPath: %#v", request.Method, c.User.Username, logger.Debug(logSender, c.ID, "new cmd, method: %v user: %v sourcePath: %#v, targetPath: %#v", request.Method, c.User.Username,
p, target) p, target)
switch request.Method { switch request.Method {
@@ -204,11 +204,11 @@ func (c Connection) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
return nil, sftp.ErrSshFxPermissionDenied return nil, sftp.ErrSshFxPermissionDenied
} }
logger.Debug(logSender, "requested list file for dir: %#v user: %v", p, c.User.Username) logger.Debug(logSender, c.ID, "requested list file for dir: %#v user: %v", p, c.User.Username)
files, err := ioutil.ReadDir(p) files, err := ioutil.ReadDir(p)
if err != nil { if err != nil {
logger.Error(logSender, "error listing directory: %#v", err) logger.Error(logSender, c.ID, "error listing directory: %#v", err)
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
@@ -218,12 +218,12 @@ func (c Connection) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
return nil, sftp.ErrSshFxPermissionDenied return nil, sftp.ErrSshFxPermissionDenied
} }
logger.Debug(logSender, "requested stat for file: %#v user: %v", p, c.User.Username) logger.Debug(logSender, c.ID, "requested stat for file: %#v user: %v", p, c.User.Username)
s, err := os.Stat(p) s, err := os.Stat(p)
if os.IsNotExist(err) { if os.IsNotExist(err) {
return nil, sftp.ErrSshFxNoSuchFile return nil, sftp.ErrSshFxNoSuchFile
} else if err != nil { } else if err != nil {
logger.Error(logSender, "error running STAT on file: %#v", err) logger.Error(logSender, c.ID, "error running STAT on file: %#v", err)
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
@@ -253,7 +253,7 @@ func (c Connection) handleSFTPRename(sourcePath string, targetPath string) error
return sftp.ErrSshFxPermissionDenied return sftp.ErrSshFxPermissionDenied
} }
if err := os.Rename(sourcePath, targetPath); err != nil { if err := os.Rename(sourcePath, targetPath); err != nil {
logger.Error(logSender, "failed to rename file, source: %#v target: %#v: %v", sourcePath, targetPath, err) logger.Error(logSender, c.ID, "failed to rename file, source: %#v target: %#v: %v", sourcePath, targetPath, err)
return sftp.ErrSshFxFailure return sftp.ErrSshFxFailure
} }
logger.CommandLog(renameLogSender, sourcePath, targetPath, c.User.Username, c.ID, c.protocol) logger.CommandLog(renameLogSender, sourcePath, targetPath, c.User.Username, c.ID, c.protocol)
@@ -268,11 +268,11 @@ func (c Connection) handleSFTPRmdir(path string) error {
numFiles, size, fileList, err := utils.ScanDirContents(path) numFiles, size, fileList, err := utils.ScanDirContents(path)
if err != nil { if err != nil {
logger.Error(logSender, "failed to remove directory %#v, scanning error: %v", path, err) logger.Error(logSender, c.ID, "failed to remove directory %#v, scanning error: %v", path, err)
return sftp.ErrSshFxFailure return sftp.ErrSshFxFailure
} }
if err := os.RemoveAll(path); err != nil { if err := os.RemoveAll(path); err != nil {
logger.Error(logSender, "failed to remove directory %#v: %v", path, err) logger.Error(logSender, c.ID, "failed to remove directory %#v: %v", path, err)
return sftp.ErrSshFxFailure return sftp.ErrSshFxFailure
} }
@@ -289,7 +289,7 @@ func (c Connection) handleSFTPSymlink(sourcePath string, targetPath string) erro
return sftp.ErrSshFxPermissionDenied return sftp.ErrSshFxPermissionDenied
} }
if err := os.Symlink(sourcePath, targetPath); err != nil { if err := os.Symlink(sourcePath, targetPath); err != nil {
logger.Warn(logSender, "failed to create symlink %#v -> %#v: %v", sourcePath, targetPath, err) logger.Warn(logSender, c.ID, "failed to create symlink %#v -> %#v: %v", sourcePath, targetPath, err)
return sftp.ErrSshFxFailure return sftp.ErrSshFxFailure
} }
@@ -303,7 +303,7 @@ func (c Connection) handleSFTPMkdir(path string) error {
} }
if err := c.createMissingDirs(filepath.Join(path, "testfile")); err != nil { if err := c.createMissingDirs(filepath.Join(path, "testfile")); err != nil {
logger.Error(logSender, "error making missing dir for path %#v: %v", path, err) logger.Error(logSender, c.ID, "error making missing dir for path %#v: %v", path, err)
return sftp.ErrSshFxFailure return sftp.ErrSshFxFailure
} }
logger.CommandLog(mkdirLogSender, path, "", c.User.Username, c.ID, c.protocol) logger.CommandLog(mkdirLogSender, path, "", c.User.Username, c.ID, c.protocol)
@@ -319,12 +319,12 @@ func (c Connection) handleSFTPRemove(path string) error {
var fi os.FileInfo var fi os.FileInfo
var err error var err error
if fi, err = os.Lstat(path); err != nil { if fi, err = os.Lstat(path); err != nil {
logger.Error(logSender, "failed to remove a file %#v: stat error: %v", path, err) logger.Error(logSender, c.ID, "failed to remove a file %#v: stat error: %v", path, err)
return sftp.ErrSshFxFailure return sftp.ErrSshFxFailure
} }
size = fi.Size() size = fi.Size()
if err := os.Remove(path); err != nil { if err := os.Remove(path); err != nil {
logger.Error(logSender, "failed to remove a file/symlink %#v: %v", path, err) logger.Error(logSender, c.ID, "failed to remove a file/symlink %#v: %v", path, err)
return sftp.ErrSshFxFailure return sftp.ErrSshFxFailure
} }
@@ -339,7 +339,7 @@ func (c Connection) handleSFTPRemove(path string) error {
func (c Connection) handleSFTPUploadToNewFile(requestPath, filePath string) (io.WriterAt, error) { func (c Connection) handleSFTPUploadToNewFile(requestPath, filePath string) (io.WriterAt, error) {
if !c.hasSpace(true) { if !c.hasSpace(true) {
logger.Info(logSender, "denying file write due to space limit") logger.Info(logSender, c.ID, "denying file write due to space limit")
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
@@ -351,13 +351,13 @@ func (c Connection) handleSFTPUploadToNewFile(requestPath, filePath string) (io.
err := c.createMissingDirs(requestPath) err := c.createMissingDirs(requestPath)
if err != nil { if err != nil {
logger.Error(logSender, "error making missing dir for path %#v: %v", requestPath, err) logger.Error(logSender, c.ID, "error making missing dir for path %#v: %v", requestPath, err)
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
file, err := os.Create(filePath) file, err := os.Create(filePath)
if err != nil { if err != nil {
logger.Error(logSender, "error creating file %#v: %v", requestPath, err) logger.Error(logSender, c.ID, "error creating file %#v: %v", requestPath, err)
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
@@ -384,7 +384,7 @@ func (c Connection) handleSFTPUploadToExistingFile(pflags sftp.FileOpenFlags, re
fileSize int64) (io.WriterAt, error) { fileSize int64) (io.WriterAt, error) {
var err error var err error
if !c.hasSpace(false) { if !c.hasSpace(false) {
logger.Info(logSender, "denying file write due to space limit") logger.Info(logSender, c.ID, "denying file write due to space limit")
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
@@ -392,7 +392,7 @@ func (c Connection) handleSFTPUploadToExistingFile(pflags sftp.FileOpenFlags, re
if osFlags&os.O_TRUNC == 0 { if osFlags&os.O_TRUNC == 0 {
// see https://github.com/pkg/sftp/issues/295 // see https://github.com/pkg/sftp/issues/295
logger.Info(logSender, "upload resume is not supported, returning error for file: %#v user: %v", requestPath, logger.Info(logSender, c.ID, "upload resume is not supported, returning error for file: %#v user: %v", requestPath,
c.User.Username) c.User.Username)
return nil, sftp.ErrSshFxOpUnsupported return nil, sftp.ErrSshFxOpUnsupported
} }
@@ -400,7 +400,7 @@ func (c Connection) handleSFTPUploadToExistingFile(pflags sftp.FileOpenFlags, re
if uploadMode == uploadModeAtomic { if uploadMode == uploadModeAtomic {
err = os.Rename(requestPath, filePath) err = os.Rename(requestPath, filePath)
if err != nil { if err != nil {
logger.Error(logSender, "error renaming existing file for atomic upload, source: %#v, dest: %#v, err: %v", logger.Error(logSender, c.ID, "error renaming existing file for atomic upload, source: %#v, dest: %#v, err: %v",
requestPath, filePath, err) requestPath, filePath, err)
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
@@ -408,7 +408,7 @@ func (c Connection) handleSFTPUploadToExistingFile(pflags sftp.FileOpenFlags, re
// we use 0666 so the umask is applied // we use 0666 so the umask is applied
file, err := os.OpenFile(filePath, osFlags, 0666) file, err := os.OpenFile(filePath, osFlags, 0666)
if err != nil { if err != nil {
logger.Error(logSender, "error opening existing file, flags: %v, source: %#v, err: %v", pflags, filePath, err) logger.Error(logSender, c.ID, "error opening existing file, flags: %v, source: %#v, err: %v", pflags, filePath, err)
return nil, sftp.ErrSshFxFailure return nil, sftp.ErrSshFxFailure
} }
@@ -440,15 +440,15 @@ func (c Connection) hasSpace(checkFiles bool) bool {
numFile, size, err := dataprovider.GetUsedQuota(dataProvider, c.User.Username) numFile, size, err := dataprovider.GetUsedQuota(dataProvider, c.User.Username)
if err != nil { if err != nil {
if _, ok := err.(*dataprovider.MethodDisabledError); ok { if _, ok := err.(*dataprovider.MethodDisabledError); ok {
logger.Warn(logSender, "quota enforcement not possible for user %v: %v", c.User.Username, err) logger.Warn(logSender, c.ID, "quota enforcement not possible for user %v: %v", c.User.Username, err)
return true return true
} }
logger.Warn(logSender, "error getting used quota for %v: %v", c.User.Username, err) logger.Warn(logSender, c.ID, "error getting used quota for %v: %v", c.User.Username, err)
return false return false
} }
if (checkFiles && c.User.QuotaFiles > 0 && numFile >= c.User.QuotaFiles) || if (checkFiles && c.User.QuotaFiles > 0 && numFile >= c.User.QuotaFiles) ||
(c.User.QuotaSize > 0 && size >= c.User.QuotaSize) { (c.User.QuotaSize > 0 && size >= c.User.QuotaSize) {
logger.Debug(logSender, "quota exceed for user %v, num files: %v/%v, size: %v/%v check files: %v", logger.Debug(logSender, c.ID, "quota exceed for user %v, num files: %v/%v, size: %v/%v check files: %v",
c.User.Username, numFile, c.User.QuotaFiles, size, c.User.QuotaSize, checkFiles) c.User.Username, numFile, c.User.QuotaFiles, size, c.User.QuotaSize, checkFiles)
return false return false
} }
@@ -469,14 +469,14 @@ func (c Connection) buildPath(rawPath string) (string, error) {
// path chain until we hit a directory that _does_ exist and can be validated. // path chain until we hit a directory that _does_ exist and can be validated.
_, err = c.findFirstExistingDir(r) _, err = c.findFirstExistingDir(r)
if err != nil { if err != nil {
logger.Warn(logSender, "error resolving not existent path: %#v", err) logger.Warn(logSender, c.ID, "error resolving not existent path: %#v", err)
} }
return r, err return r, err
} }
err = c.isSubDir(p) err = c.isSubDir(p)
if err != nil { if err != nil {
logger.Warn(logSender, "Invalid path resolution, dir: %#v outside user home: %#v err: %v", p, c.User.HomeDir, err) logger.Warn(logSender, c.ID, "Invalid path resolution, dir: %#v outside user home: %#v err: %v", p, c.User.HomeDir, err)
} }
return r, err return r, err
} }
@@ -503,7 +503,7 @@ func (c Connection) findNonexistentDirs(path string) ([]string, error) {
} }
err = c.isSubDir(p) err = c.isSubDir(p)
if err != nil { if err != nil {
logger.Warn(logSender, "Error finding non existing dir: %v", err) logger.Warn(logSender, c.ID, "Error finding non existing dir: %v", err)
} }
return results, err return results, err
} }
@@ -512,7 +512,7 @@ func (c Connection) findNonexistentDirs(path string) ([]string, error) {
func (c Connection) findFirstExistingDir(path string) (string, error) { func (c Connection) findFirstExistingDir(path string) (string, error) {
results, err := c.findNonexistentDirs(path) results, err := c.findNonexistentDirs(path)
if err != nil { if err != nil {
logger.Warn(logSender, "unable to find non existent dirs: %v", err) logger.Warn(logSender, c.ID, "unable to find non existent dirs: %v", err)
return "", err return "", err
} }
var parent string var parent string
@@ -543,11 +543,11 @@ func (c Connection) isSubDir(sub string) error {
// home dir must exist and it is already a validated absolute path // home dir must exist and it is already a validated absolute path
parent, err := filepath.EvalSymlinks(c.User.HomeDir) parent, err := filepath.EvalSymlinks(c.User.HomeDir)
if err != nil { if err != nil {
logger.Warn(logSender, "invalid home dir %#v: %v", c.User.HomeDir, err) logger.Warn(logSender, c.ID, "invalid home dir %#v: %v", c.User.HomeDir, err)
return err return err
} }
if !strings.HasPrefix(sub, parent) { if !strings.HasPrefix(sub, parent) {
logger.Warn(logSender, "dir %#v is not inside: %#v ", sub, parent) logger.Warn(logSender, c.ID, "dir %#v is not inside: %#v ", sub, parent)
return fmt.Errorf("dir %#v is not inside: %#v", sub, parent) return fmt.Errorf("dir %#v is not inside: %#v", sub, parent)
} }
return nil return nil
@@ -562,7 +562,7 @@ func (c Connection) createMissingDirs(filePath string) error {
for i := range dirsToCreate { for i := range dirsToCreate {
d := dirsToCreate[last-i] d := dirsToCreate[last-i]
if err := os.Mkdir(d, 0777); err != nil { if err := os.Mkdir(d, 0777); err != nil {
logger.Error(logSender, "error creating missing dir: %#v", d) logger.Error(logSender, c.ID, "error creating missing dir: %#v", d)
return err return err
} }
utils.SetPathPermissions(d, c.User.GetUID(), c.User.GetGID()) utils.SetPathPermissions(d, c.User.GetUID(), c.User.GetGID())

40
sftpd/scp.go
View File

@@ -44,7 +44,7 @@ func (c *scpCommand) handle() error {
defer removeConnection(c.connection.ID) defer removeConnection(c.connection.ID)
destPath := c.getDestPath() destPath := c.getDestPath()
commandType := c.getCommandType() commandType := c.getCommandType()
logger.Debug(logSenderSCP, "handle scp command, args: %v user: %v command type: %v, dest path: %v", logger.Debug(logSenderSCP, c.connection.ID, "handle scp command, args: %v user: %v command type: %v, dest path: %#v",
c.args, c.connection.User.Username, commandType, destPath) c.args, c.connection.User.Username, commandType, destPath)
if commandType == "-t" { if commandType == "-t" {
// -t means "to", so upload // -t means "to", so upload
@@ -85,7 +85,7 @@ func (c *scpCommand) handleRecursiveUpload() error {
} }
if strings.HasPrefix(command, "E") { if strings.HasPrefix(command, "E") {
numDirs-- numDirs--
logger.Debug(logSenderSCP, "received end dir command, num dirs: %v", numDirs) logger.Debug(logSenderSCP, c.connection.ID, "received end dir command, num dirs: %v", numDirs)
if numDirs == 0 { if numDirs == 0 {
// upload is now complete send confirmation message // upload is now complete send confirmation message
err = c.sendConfirmationMessage() err = c.sendConfirmationMessage()
@@ -108,7 +108,7 @@ func (c *scpCommand) handleRecursiveUpload() error {
if err != nil { if err != nil {
return err return err
} }
logger.Debug(logSenderSCP, "received start dir command, num dirs: %v destPath: %v", numDirs, destPath) logger.Debug(logSenderSCP, c.connection.ID, "received start dir command, num dirs: %v destPath: %v", numDirs, destPath)
} else if strings.HasPrefix(command, "C") { } else if strings.HasPrefix(command, "C") {
err = c.handleUpload(c.getFileUploadDestPath(destPath, name), sizeToRead) err = c.handleUpload(c.getFileUploadDestPath(destPath, name), sizeToRead)
if err != nil { if err != nil {
@@ -127,14 +127,14 @@ func (c *scpCommand) handleCreateDir(dirPath string) error {
updateConnectionActivity(c.connection.ID) updateConnectionActivity(c.connection.ID)
if !c.connection.User.HasPerm(dataprovider.PermCreateDirs) { if !c.connection.User.HasPerm(dataprovider.PermCreateDirs) {
err := fmt.Errorf("Permission denied") err := fmt.Errorf("Permission denied")
logger.Warn(logSenderSCP, "error creating dir: %v, permission denied", dirPath) logger.Warn(logSenderSCP, c.connection.ID, "error creating dir: %v, permission denied", dirPath)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
p, err := c.connection.buildPath(dirPath) p, err := c.connection.buildPath(dirPath)
if err != nil { if err != nil {
logger.Warn(logSenderSCP, "error creating dir: %v, invalid file path, err: %v", dirPath, err) logger.Warn(logSenderSCP, c.connection.ID, "error creating dir: %v, invalid file path, err: %v", dirPath, err)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
@@ -191,7 +191,7 @@ func (c *scpCommand) getUploadFileData(sizeToRead int64, transfer *Transfer) err
func (c *scpCommand) handleUploadFile(requestPath, filePath string, sizeToRead int64, isNewFile bool) error { func (c *scpCommand) handleUploadFile(requestPath, filePath string, sizeToRead int64, isNewFile bool) error {
if !c.connection.hasSpace(true) { if !c.connection.hasSpace(true) {
err := fmt.Errorf("denying file write due to space limit") err := fmt.Errorf("denying file write due to space limit")
logger.Warn(logSenderSCP, "error uploading file: %v, err: %v", filePath, err) logger.Warn(logSenderSCP, c.connection.ID, "error uploading file: %v, err: %v", filePath, err)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
@@ -199,7 +199,7 @@ func (c *scpCommand) handleUploadFile(requestPath, filePath string, sizeToRead i
if _, err := os.Stat(filepath.Dir(requestPath)); os.IsNotExist(err) { if _, err := os.Stat(filepath.Dir(requestPath)); os.IsNotExist(err) {
if !c.connection.User.HasPerm(dataprovider.PermCreateDirs) { if !c.connection.User.HasPerm(dataprovider.PermCreateDirs) {
err := fmt.Errorf("Permission denied") err := fmt.Errorf("Permission denied")
logger.Warn(logSenderSCP, "error uploading file: %v, permission denied", requestPath) logger.Warn(logSenderSCP, c.connection.ID, "error uploading file: %v, permission denied", requestPath)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
@@ -238,14 +238,14 @@ func (c *scpCommand) handleUpload(uploadFilePath string, sizeToRead int64) error
updateConnectionActivity(c.connection.ID) updateConnectionActivity(c.connection.ID)
if !c.connection.User.HasPerm(dataprovider.PermUpload) { if !c.connection.User.HasPerm(dataprovider.PermUpload) {
err := fmt.Errorf("Permission denied") err := fmt.Errorf("Permission denied")
logger.Warn(logSenderSCP, "error uploading file: %v, permission denied", uploadFilePath) logger.Warn(logSenderSCP, c.connection.ID, "error uploading file: %v, permission denied", uploadFilePath)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
p, err := c.connection.buildPath(uploadFilePath) p, err := c.connection.buildPath(uploadFilePath)
if err != nil { if err != nil {
logger.Warn(logSenderSCP, "error uploading file: %v, err: %v", uploadFilePath, err) logger.Warn(logSenderSCP, c.connection.ID, "error uploading file: %v, err: %v", uploadFilePath, err)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
@@ -265,7 +265,7 @@ func (c *scpCommand) handleUpload(uploadFilePath string, sizeToRead int64) error
} }
if stat.IsDir() { if stat.IsDir() {
logger.Warn(logSenderSCP, "attempted to open a directory for writing to: %v", p) logger.Warn(logSenderSCP, c.connection.ID, "attempted to open a directory for writing to: %v", p)
err = fmt.Errorf("Attempted to open a directory for writing: %v", p) err = fmt.Errorf("Attempted to open a directory for writing: %v", p)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
@@ -315,7 +315,7 @@ func (c *scpCommand) sendDownloadProtocolMessages(dirPath string, stat os.FileIn
func (c *scpCommand) handleRecursiveDownload(dirPath string, stat os.FileInfo) error { func (c *scpCommand) handleRecursiveDownload(dirPath string, stat os.FileInfo) error {
var err error var err error
if c.isRecursive() { if c.isRecursive() {
logger.Debug(logSenderSCP, "recursive download, dir path: %v", dirPath) logger.Debug(logSenderSCP, c.connection.ID, "recursive download, dir path: %v", dirPath)
err = c.sendDownloadProtocolMessages(dirPath, stat) err = c.sendDownloadProtocolMessages(dirPath, stat)
if err != nil { if err != nil {
return err return err
@@ -425,21 +425,21 @@ func (c *scpCommand) handleDownload(filePath string) error {
if !c.connection.User.HasPerm(dataprovider.PermDownload) { if !c.connection.User.HasPerm(dataprovider.PermDownload) {
err := fmt.Errorf("Permission denied") err := fmt.Errorf("Permission denied")
logger.Warn(logSenderSCP, "error downloading file: %v, permission denied", filePath) logger.Warn(logSenderSCP, c.connection.ID, "error downloading file: %v, permission denied", filePath)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
p, err := c.connection.buildPath(filePath) p, err := c.connection.buildPath(filePath)
if err != nil { if err != nil {
err := fmt.Errorf("Invalid file path") err := fmt.Errorf("Invalid file path")
logger.Warn(logSenderSCP, "error downloading file: %v, invalid file path", filePath) logger.Warn(logSenderSCP, c.connection.ID, "error downloading file: %v, invalid file path", filePath)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
var stat os.FileInfo var stat os.FileInfo
if stat, err = os.Stat(p); os.IsNotExist(err) { if stat, err = os.Stat(p); os.IsNotExist(err) {
logger.Warn(logSenderSCP, "error downloading file: %v, err: %v", p, err) logger.Warn(logSenderSCP, c.connection.ID, "error downloading file: %v, err: %v", p, err)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return err return err
} }
@@ -579,7 +579,7 @@ func (c *scpCommand) sendConfirmationMessage() error {
func (c *scpCommand) sendProtocolMessage(message string) error { func (c *scpCommand) sendProtocolMessage(message string) error {
_, err := c.channel.Write([]byte(message)) _, err := c.channel.Write([]byte(message))
if err != nil { if err != nil {
logger.Warn(logSenderSCP, "error sending protocol message: %v, err: %v", message, err) logger.Warn(logSenderSCP, c.connection.ID, "error sending protocol message: %v, err: %v", message, err)
c.channel.Close() c.channel.Close()
} }
return err return err
@@ -594,7 +594,7 @@ func (c *scpCommand) sendExitStatus(err error) {
ex := exitStatusMsg{ ex := exitStatusMsg{
Status: status, Status: status,
} }
logger.Debug(logSenderSCP, "send exit status for command with args: %v user: %v err: %v", logger.Debug(logSenderSCP, c.connection.ID, "send exit status for command with args: %v user: %v err: %v",
c.args, c.connection.User.Username, err) c.args, c.connection.User.Username, err)
c.channel.SendRequest("exit-status", false, ssh.Marshal(&ex)) c.channel.SendRequest("exit-status", false, ssh.Marshal(&ex))
c.channel.Close() c.channel.Close()
@@ -645,7 +645,7 @@ func (c *scpCommand) parseUploadMessage(command string) (int64, string, error) {
if !strings.HasPrefix(command, "C") && !strings.HasPrefix(command, "D") { if !strings.HasPrefix(command, "C") && !strings.HasPrefix(command, "D") {
err = fmt.Errorf("unknown or invalid upload message: %v args: %v user: %v", err = fmt.Errorf("unknown or invalid upload message: %v args: %v user: %v",
command, c.args, c.connection.User.Username) command, c.args, c.connection.User.Username)
logger.Warn(logSenderSCP, "error: %v", err) logger.Warn(logSenderSCP, c.connection.ID, "error: %v", err)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return size, name, err return size, name, err
} }
@@ -653,20 +653,20 @@ func (c *scpCommand) parseUploadMessage(command string) (int64, string, error) {
if len(parts) == 3 { if len(parts) == 3 {
size, err = strconv.ParseInt(parts[1], 10, 64) size, err = strconv.ParseInt(parts[1], 10, 64)
if err != nil { if err != nil {
logger.Warn(logSenderSCP, "error getting size from upload message: %v", err) logger.Warn(logSenderSCP, c.connection.ID, "error getting size from upload message: %v", err)
c.sendErrorMessage(fmt.Sprintf("Error getting size: %v", err)) c.sendErrorMessage(fmt.Sprintf("Error getting size: %v", err))
return size, name, err return size, name, err
} }
name = parts[2] name = parts[2]
if len(name) == 0 { if len(name) == 0 {
err = fmt.Errorf("error getting name from upload message, cannot be empty") err = fmt.Errorf("error getting name from upload message, cannot be empty")
logger.Warn(logSenderSCP, "error: %v", err) logger.Warn(logSenderSCP, c.connection.ID, "error: %v", err)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return size, name, err return size, name, err
} }
} else { } else {
err = fmt.Errorf("Error splitting upload message: %v", command) err = fmt.Errorf("Error splitting upload message: %v", command)
logger.Warn(logSenderSCP, "error: %v", err) logger.Warn(logSenderSCP, c.connection.ID, "error: %v", err)
c.sendErrorMessage(err.Error()) c.sendErrorMessage(err.Error())
return size, name, err return size, name, err
} }

38
sftpd/server.go
View File

@@ -87,7 +87,7 @@ func (c Configuration) Initialize(configDir string) error {
if err == nil { if err == nil {
utils.SetUmask(int(umask), c.Umask) utils.SetUmask(int(umask), c.Umask)
} else { } else {
logger.Warn(logSender, "error reading umask, please fix your config file: %v", err) logger.Warn(logSender, "", "error reading umask, please fix your config file: %v", err)
logger.WarnToConsole("error reading umask, please fix your config file: %v", err) logger.WarnToConsole("error reading umask, please fix your config file: %v", err)
} }
serverConfig := &ssh.ServerConfig{ serverConfig := &ssh.ServerConfig{
@@ -122,7 +122,7 @@ func (c Configuration) Initialize(configDir string) error {
if !filepath.IsAbs(privateFile) { if !filepath.IsAbs(privateFile) {
privateFile = filepath.Join(configDir, privateFile) privateFile = filepath.Join(configDir, privateFile)
} }
logger.Info(logSender, "Loading private key: %s", privateFile) logger.Info(logSender, "", "Loading private key: %s", privateFile)
privateBytes, err := ioutil.ReadFile(privateFile) privateBytes, err := ioutil.ReadFile(privateFile)
if err != nil { if err != nil {
@@ -143,13 +143,13 @@ func (c Configuration) Initialize(configDir string) error {
listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", c.BindAddress, c.BindPort)) listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", c.BindAddress, c.BindPort))
if err != nil { if err != nil {
logger.Warn(logSender, "error starting listener on address %s:%d: %v", c.BindAddress, c.BindPort, err) logger.Warn(logSender, "", "error starting listener on address %s:%d: %v", c.BindAddress, c.BindPort, err)
return err return err
} }
actions = c.Actions actions = c.Actions
uploadMode = c.UploadMode uploadMode = c.UploadMode
logger.Info(logSender, "server listener registered address: %v", listener.Addr().String()) logger.Info(logSender, "", "server listener registered address: %v", listener.Addr().String())
if c.IdleTimeout > 0 { if c.IdleTimeout > 0 {
startIdleTimer(time.Duration(c.IdleTimeout) * time.Minute) startIdleTimer(time.Duration(c.IdleTimeout) * time.Minute)
} }
@@ -189,7 +189,7 @@ func (c Configuration) configureLoginBanner(serverConfig *ssh.ServerConfig, conf
} }
} else { } else {
logger.WarnToConsole("unable to read login banner file: %v", err) logger.WarnToConsole("unable to read login banner file: %v", err)
logger.Warn(logSender, "unable to read login banner file: %v", err) logger.Warn(logSender, "", "unable to read login banner file: %v", err)
} }
} }
return err return err
@@ -202,19 +202,19 @@ func (c Configuration) AcceptInboundConnection(conn net.Conn, config *ssh.Server
// Before beginning a handshake must be performed on the incoming net.Conn // Before beginning a handshake must be performed on the incoming net.Conn
sconn, chans, reqs, err := ssh.NewServerConn(conn, config) sconn, chans, reqs, err := ssh.NewServerConn(conn, config)
if err != nil { if err != nil {
logger.Warn(logSender, "failed to accept an incoming connection: %v", err) logger.Warn(logSender, "", "failed to accept an incoming connection: %v", err)
return return
} }
defer sconn.Close() defer sconn.Close()
logger.Debug(logSender, "accepted inbound connection, ip: %v", conn.RemoteAddr().String()) logger.Debug(logSender, "", "accepted inbound connection, ip: %v", conn.RemoteAddr().String())
var user dataprovider.User var user dataprovider.User
err = json.Unmarshal([]byte(sconn.Permissions.Extensions["user"]), &user) err = json.Unmarshal([]byte(sconn.Permissions.Extensions["user"]), &user)
if err != nil { if err != nil {
logger.Warn(logSender, "Unable to deserialize user info, cannot serve connection: %v", err) logger.Warn(logSender, "", "Unable to deserialize user info, cannot serve connection: %v", err)
return return
} }
@@ -237,14 +237,14 @@ func (c Configuration) AcceptInboundConnection(conn net.Conn, config *ssh.Server
// If its not a session channel we just move on because its not something we // If its not a session channel we just move on because its not something we
// know how to handle at this point. // know how to handle at this point.
if newChannel.ChannelType() != "session" { if newChannel.ChannelType() != "session" {
logger.Debug(logSender, "received an unknown channel type: %v", newChannel.ChannelType()) logger.Debug(logSender, connectionID, "received an unknown channel type: %v", newChannel.ChannelType())
newChannel.Reject(ssh.UnknownChannelType, "unknown channel type") newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
continue continue
} }
channel, requests, err := newChannel.Accept() channel, requests, err := newChannel.Accept()
if err != nil { if err != nil {
logger.Warn(logSender, "could not accept a channel: %v", err) logger.Warn(logSender, connectionID, "could not accept a channel: %v", err)
continue continue
} }
@@ -266,7 +266,7 @@ func (c Configuration) AcceptInboundConnection(conn net.Conn, config *ssh.Server
var msg execMsg var msg execMsg
if err := ssh.Unmarshal(req.Payload, &msg); err == nil { if err := ssh.Unmarshal(req.Payload, &msg); err == nil {
name, scpArgs, err := parseCommandPayload(msg.Command) name, scpArgs, err := parseCommandPayload(msg.Command)
logger.Debug(logSender, "new exec command: %v args: %v user: %v, error: %v", name, scpArgs, logger.Debug(logSender, connectionID, "new exec command: %v args: %v user: %v, error: %v", name, scpArgs,
connection.User.Username, err) connection.User.Username, err)
if err == nil && name == "scp" && len(scpArgs) >= 2 { if err == nil && name == "scp" && len(scpArgs) >= 2 {
ok = true ok = true
@@ -296,10 +296,10 @@ func (c Configuration) handleSftpConnection(channel io.ReadWriteCloser, connecti
server := sftp.NewRequestServer(channel, handler) server := sftp.NewRequestServer(channel, handler)
if err := server.Serve(); err == io.EOF { if err := server.Serve(); err == io.EOF {
logger.Debug(logSender, "connection closed, id: %v", connection.ID) logger.Debug(logSender, connection.ID, "connection closed, id: %v", connection.ID)
server.Close() server.Close()
} else if err != nil { } else if err != nil {
logger.Error(logSender, "sftp connection closed with error id %v: %v", connection.ID, err) logger.Error(logSender, connection.ID, "sftp connection closed with error id %v: %v", connection.ID, err)
} }
removeConnection(connection.ID) removeConnection(connection.ID)
@@ -317,12 +317,12 @@ func (c Configuration) createHandler(connection Connection) sftp.Handlers {
func loginUser(user dataprovider.User) (*ssh.Permissions, error) { func loginUser(user dataprovider.User) (*ssh.Permissions, error) {
if !filepath.IsAbs(user.HomeDir) { if !filepath.IsAbs(user.HomeDir) {
logger.Warn(logSender, "user %v has invalid home dir: %v. Home dir must be an absolute path, login not allowed", logger.Warn(logSender, "", "user %v has invalid home dir: %v. Home dir must be an absolute path, login not allowed",
user.Username, user.HomeDir) user.Username, user.HomeDir)
return nil, fmt.Errorf("Cannot login user with invalid home dir: %v", user.HomeDir) return nil, fmt.Errorf("Cannot login user with invalid home dir: %v", user.HomeDir)
} }
if _, err := os.Stat(user.HomeDir); os.IsNotExist(err) { if _, err := os.Stat(user.HomeDir); os.IsNotExist(err) {
logger.Debug(logSender, "home directory \"%v\" for user %v does not exist, try to create", user.HomeDir, user.Username) logger.Debug(logSender, "", "home directory \"%v\" for user %v does not exist, try to create", user.HomeDir, user.Username)
err := os.MkdirAll(user.HomeDir, 0777) err := os.MkdirAll(user.HomeDir, 0777)
if err == nil { if err == nil {
utils.SetPathPermissions(user.HomeDir, user.GetUID(), user.GetGID()) utils.SetPathPermissions(user.HomeDir, user.GetUID(), user.GetGID())
@@ -332,7 +332,7 @@ func loginUser(user dataprovider.User) (*ssh.Permissions, error) {
if user.MaxSessions > 0 { if user.MaxSessions > 0 {
activeSessions := getActiveSessions(user.Username) activeSessions := getActiveSessions(user.Username)
if activeSessions >= user.MaxSessions { if activeSessions >= user.MaxSessions {
logger.Debug(logSender, "authentication refused for user: %v, too many open sessions: %v/%v", user.Username, logger.Debug(logSender, "", "authentication refused for user: %v, too many open sessions: %v/%v", user.Username,
activeSessions, user.MaxSessions) activeSessions, user.MaxSessions)
return nil, fmt.Errorf("Too many open sessions: %v", activeSessions) return nil, fmt.Errorf("Too many open sessions: %v", activeSessions)
} }
@@ -340,7 +340,7 @@ func loginUser(user dataprovider.User) (*ssh.Permissions, error) {
json, err := json.Marshal(user) json, err := json.Marshal(user)
if err != nil { if err != nil {
logger.Warn(logSender, "error serializing user info: %v, authentication rejected", err) logger.Warn(logSender, "", "error serializing user info: %v, authentication rejected", err)
return nil, err return nil, err
} }
p := &ssh.Permissions{} p := &ssh.Permissions{}
@@ -355,8 +355,8 @@ func (c *Configuration) checkHostKeys(configDir string) error {
if len(c.Keys) == 0 { if len(c.Keys) == 0 {
autoFile := filepath.Join(configDir, defaultPrivateKeyName) autoFile := filepath.Join(configDir, defaultPrivateKeyName)
if _, err = os.Stat(autoFile); os.IsNotExist(err) { if _, err = os.Stat(autoFile); os.IsNotExist(err) {
logger.Info(logSender, "No host keys configured and %s does not exist; creating new private key for server", autoFile) logger.Info(logSender, "", "No host keys configured and %#v does not exist; creating new private key for server", autoFile)
logger.InfoToConsole("No host keys configured and %s does not exist; creating new private key for server", autoFile) logger.InfoToConsole("No host keys configured and %#v does not exist; creating new private key for server", autoFile)
err = c.generatePrivateKey(autoFile) err = c.generatePrivateKey(autoFile)
} }

28
sftpd/sftpd.go
View File

@@ -159,7 +159,7 @@ func RemoveQuotaScan(username string) error {
activeQuotaScans[indexToRemove] = activeQuotaScans[len(activeQuotaScans)-1] activeQuotaScans[indexToRemove] = activeQuotaScans[len(activeQuotaScans)-1]
activeQuotaScans = activeQuotaScans[:len(activeQuotaScans)-1] activeQuotaScans = activeQuotaScans[:len(activeQuotaScans)-1]
} else { } else {
logger.Warn(logSender, "quota scan to remove not found for user: %v", username) logger.Warn(logSender, "", "quota scan to remove not found for user: %v", username)
err = fmt.Errorf("quota scan to remove not found for user: %v", username) err = fmt.Errorf("quota scan to remove not found for user: %v", username)
} }
return err return err
@@ -173,7 +173,7 @@ func CloseActiveConnection(connectionID string) bool {
defer mutex.RUnlock() defer mutex.RUnlock()
for _, c := range openConnections { for _, c := range openConnections {
if c.ID == connectionID { if c.ID == connectionID {
logger.Debug(logSender, "closing connection with id: %v", connectionID) logger.Debug(logSender, "", "closing connection with id: %v", connectionID)
c.sshConn.Close() c.sshConn.Close()
result = true result = true
break break
@@ -231,7 +231,7 @@ func startIdleTimer(maxIdleTime time.Duration) {
idleTimeout = maxIdleTime idleTimeout = maxIdleTime
go func() { go func() {
for t := range idleConnectionTicker.C { for t := range idleConnectionTicker.C {
logger.Debug(logSender, "idle connections check ticker %v", t) logger.Debug(logSender, "", "idle connections check ticker %v", t)
CheckIdleConnections() CheckIdleConnections()
} }
}() }()
@@ -247,33 +247,33 @@ func CheckIdleConnections() {
if t.connectionID == c.ID { if t.connectionID == c.ID {
transferIdleTime := time.Since(t.lastActivity) transferIdleTime := time.Since(t.lastActivity)
if transferIdleTime < idleTime { if transferIdleTime < idleTime {
logger.Debug(logSender, "idle time: %v setted to transfer idle time: %v connection id: %v", logger.Debug(logSender, "", "idle time: %v setted to transfer idle time: %v connection id: %v",
idleTime, transferIdleTime, c.ID) idleTime, transferIdleTime, c.ID)
idleTime = transferIdleTime idleTime = transferIdleTime
} }
} }
} }
if idleTime > idleTimeout { if idleTime > idleTimeout {
logger.Debug(logSender, "close idle connection id: %v idle time: %v", c.ID, idleTime) logger.Debug(logSender, "", "close idle connection id: %v idle time: %v", c.ID, idleTime)
err := c.sshConn.Close() err := c.sshConn.Close()
logger.Debug(logSender, "idle connection closed id: %v, err: %v", c.ID, err) logger.Debug(logSender, "", "idle connection closed id: %v, err: %v", c.ID, err)
} }
} }
logger.Debug(logSender, "check idle connections ended") logger.Debug(logSender, "", "check idle connections ended")
} }
func addConnection(id string, conn Connection) { func addConnection(id string, conn Connection) {
mutex.Lock() mutex.Lock()
defer mutex.Unlock() defer mutex.Unlock()
openConnections[id] = conn openConnections[id] = conn
logger.Debug(logSender, "connection added, num open connections: %v", len(openConnections)) logger.Debug(logSender, id, "connection added, num open connections: %v", len(openConnections))
} }
func removeConnection(id string) { func removeConnection(id string) {
mutex.Lock() mutex.Lock()
defer mutex.Unlock() defer mutex.Unlock()
delete(openConnections, id) delete(openConnections, id)
logger.Debug(logSender, "connection removed, num open connections: %v", len(openConnections)) logger.Debug(logSender, id, "connection removed, num open connections: %v", len(openConnections))
} }
func addTransfer(transfer *Transfer) { func addTransfer(transfer *Transfer) {
@@ -297,7 +297,7 @@ func removeTransfer(transfer *Transfer) error {
activeTransfers[indexToRemove] = activeTransfers[len(activeTransfers)-1] activeTransfers[indexToRemove] = activeTransfers[len(activeTransfers)-1]
activeTransfers = activeTransfers[:len(activeTransfers)-1] activeTransfers = activeTransfers[:len(activeTransfers)-1]
} else { } else {
logger.Warn(logSender, "transfer to remove not found!") logger.Warn(logSender, "", "transfer to remove not found!")
err = fmt.Errorf("transfer to remove not found") err = fmt.Errorf("transfer to remove not found")
} }
return err return err
@@ -321,13 +321,13 @@ func executeAction(operation string, username string, path string, target string
if _, err = os.Stat(actions.Command); err == nil { if _, err = os.Stat(actions.Command); err == nil {
command := exec.Command(actions.Command, operation, username, path, target) command := exec.Command(actions.Command, operation, username, path, target)
err = command.Start() err = command.Start()
logger.Debug(logSender, "start command \"%v\" with arguments: %v, %v, %v, %v, error: %v", logger.Debug(logSender, "", "start command \"%v\" with arguments: %v, %v, %v, %v, error: %v",
actions.Command, operation, username, path, target, err) actions.Command, operation, username, path, target, err)
if err == nil { if err == nil {
go command.Wait() go command.Wait()
} }
} else { } else {
logger.Warn(logSender, "Invalid action command \"%v\" : %v", actions.Command, err) logger.Warn(logSender, "", "Invalid action command \"%v\" : %v", actions.Command, err)
} }
} }
if len(actions.HTTPNotificationURL) > 0 { if len(actions.HTTPNotificationURL) > 0 {
@@ -353,11 +353,11 @@ func executeAction(operation string, username string, path string, target string
respCode = resp.StatusCode respCode = resp.StatusCode
resp.Body.Close() resp.Body.Close()
} }
logger.Debug(logSender, "notified action to URL: %v status code: %v, elapsed: %v err: %v", logger.Debug(logSender, "", "notified action to URL: %v status code: %v, elapsed: %v err: %v",
url.String(), respCode, time.Since(startTime), err) url.String(), respCode, time.Since(startTime), err)
}() }()
} else { } else {
logger.Warn(logSender, "Invalid http_notification_url \"%v\" : %v", actions.HTTPNotificationURL, err) logger.Warn(logSender, "", "Invalid http_notification_url \"%v\" : %v", actions.HTTPNotificationURL, err)
} }
} }
return err return err

12
sftpd/sftpd_test.go
View File

@@ -97,7 +97,7 @@ func TestMain(m *testing.M) {
err := dataprovider.Initialize(providerConf, configDir) err := dataprovider.Initialize(providerConf, configDir)
if err != nil { if err != nil {
logger.Warn(logSender, "error initializing data provider: %v", err) logger.Warn(logSender, "", "error initializing data provider: %v", err)
os.Exit(1) os.Exit(1)
} }
dataProvider := dataprovider.GetProvider() dataProvider := dataprovider.GetProvider()
@@ -141,20 +141,20 @@ func TestMain(m *testing.M) {
scpPath, err = exec.LookPath("scp") scpPath, err = exec.LookPath("scp")
if err != nil { if err != nil {
logger.Warn(logSender, "unable to get scp command. SCP tests will be skipped, err: %v", err) logger.Warn(logSender, "", "unable to get scp command. SCP tests will be skipped, err: %v", err)
logger.WarnToConsole("unable to get scp command. SCP tests will be skipped, err: %v", err) logger.WarnToConsole("unable to get scp command. SCP tests will be skipped, err: %v", err)
scpPath = "" scpPath = ""
} }
go func() { go func() {
logger.Debug(logSender, "initializing SFTP server with config %+v", sftpdConf) logger.Debug(logSender, "", "initializing SFTP server with config %+v", sftpdConf)
if err := sftpdConf.Initialize(configDir); err != nil { if err := sftpdConf.Initialize(configDir); err != nil {
logger.Error(logSender, "could not start SFTP server: %v", err) logger.Error(logSender, "", "could not start SFTP server: %v", err)
} }
}() }()
go func() { go func() {
logger.Debug(logSender, "initializing HTTP server with config %+v", httpdConf) logger.Debug(logSender, "", "initializing HTTP server with config %+v", httpdConf)
s := &http.Server{ s := &http.Server{
Addr: fmt.Sprintf("%s:%d", httpdConf.BindAddress, httpdConf.BindPort), Addr: fmt.Sprintf("%s:%d", httpdConf.BindAddress, httpdConf.BindPort),
Handler: router, Handler: router,
@@ -163,7 +163,7 @@ func TestMain(m *testing.M) {
MaxHeaderBytes: 1 << 20, // 1MB MaxHeaderBytes: 1 << 20, // 1MB
} }
if err := s.ListenAndServe(); err != nil { if err := s.ListenAndServe(); err != nil {
logger.Error(logSender, "could not start HTTP server: %v", err) logger.Error(logSender, "", "could not start HTTP server: %v", err)
} }
}() }()

2
sftpd/transfer.go
View File

@@ -60,7 +60,7 @@ func (t *Transfer) Close() error {
err := t.file.Close() err := t.file.Close()
if t.transferType == transferUpload && t.file.Name() != t.path { if t.transferType == transferUpload && t.file.Name() != t.path {
err = os.Rename(t.file.Name(), t.path) err = os.Rename(t.file.Name(), t.path)
logger.Debug(logSender, "atomic upload completed, rename: \"%v\" -> \"%v\", error: %v", logger.Debug(logSender, t.connectionID, "atomic upload completed, rename: \"%v\" -> \"%v\", error: %v",
t.file.Name(), t.path, err) t.file.Name(), t.path, err)
} }
elapsed := time.Since(t.start).Nanoseconds() / 1000000 elapsed := time.Since(t.start).Nanoseconds() / 1000000

2
utils/umask_unix.go
View File

@@ -10,6 +10,6 @@ import (
// SetUmask sets umask on unix systems // SetUmask sets umask on unix systems
func SetUmask(umask int, configValue string) { func SetUmask(umask int, configValue string) {
logger.Debug(logSender, "set umask to %v (%v)", configValue, umask) logger.Debug(logSender, "", "set umask to %v (%v)", configValue, umask)
syscall.Umask(umask) syscall.Umask(umask)
} }

2
utils/umask_windows.go
View File

@@ -4,5 +4,5 @@ import "github.com/drakkan/sftpgo/logger"
// SetUmask does nothing on windows // SetUmask does nothing on windows
func SetUmask(umask int, configValue string) { func SetUmask(umask int, configValue string) {
logger.Debug(logSender, "umask not available on windows, configured value %v (%v)", configValue, umask) logger.Debug(logSender, "", "umask not available on windows, configured value %v (%v)", configValue, umask)
} }

2
utils/utils.go
View File

@@ -77,7 +77,7 @@ func isDirectory(path string) (bool, error) {
func SetPathPermissions(path string, uid int, gid int) { func SetPathPermissions(path string, uid int, gid int) {
if runtime.GOOS != "windows" { if runtime.GOOS != "windows" {
if err := os.Chown(path, uid, gid); err != nil { if err := os.Chown(path, uid, gid); err != nil {
logger.Warn(logSender, "error chowning path %v: %v", path, err) logger.Warn(logSender, "", "error chowning path %v: %v", path, err)
} }
} }
} }