Naming warnings from golint are fixed

Author: notorca

cmd.go

@@ -859,7 +859,7 @@ func (cmd commandAuth) Execute(conn *Conn, param string) {
 	log.Println(param, conn)
 	if param == "TLS" && conn.tlsConfig != nil {
 		conn.writeMessage(234, "AUTH command OK")
-		err := conn.upgradeToTls()
+		err := conn.upgradeToTLS()
 		if err != nil {
 			conn.logger.Printf("Error upgrading conection to TLS %v", err)
 		}

conn.go

@@ -28,7 +28,7 @@ type Conn struct {
 	logger        *Logger
 	server        *Server
 	tlsConfig     *tls.Config
-	sessionId     string
+	sessionID     string
 	namePrefix    string
 	reqUser       string
 	user          string
@@ -48,7 +48,7 @@ func (conn *Conn) IsLogin() bool {
 }
 
 // returns a random 20 char string that can be used as a unique session ID
-func newSessionId() string {
+func newSessionID() string {
 	hash := sha256.New()
 	_, err := io.CopyN(hash, rand.Reader, 50)
 	if err != nil {
@@ -100,39 +100,39 @@ func (conn *Conn) Close() {
 	}
 }
 
-func (Conn *Conn) upgradeToTls() error {
-	Conn.logger.Print("Upgrading connectiion to TLS")
-	tlsConn := tls.Server(Conn.conn, Conn.tlsConfig)
+func (conn *Conn) upgradeToTLS() error {
+	conn.logger.Print("Upgrading connectiion to TLS")
+	tlsConn := tls.Server(conn.conn, conn.tlsConfig)
 	err := tlsConn.Handshake()
 	if err == nil {
-		Conn.conn = tlsConn
-		Conn.controlReader = bufio.NewReader(tlsConn)
-		Conn.controlWriter = bufio.NewWriter(tlsConn)
-		Conn.tls = true
+		conn.conn = tlsConn
+		conn.controlReader = bufio.NewReader(tlsConn)
+		conn.controlWriter = bufio.NewWriter(tlsConn)
+		conn.tls = true
 	}
 	return err
 }
 
 // receiveLine accepts a single line FTP command and co-ordinates an
 // appropriate response.
-func (Conn *Conn) receiveLine(line string) {
-	command, param := Conn.parseLine(line)
-	Conn.logger.PrintCommand(command, param)
+func (conn *Conn) receiveLine(line string) {
+	command, param := conn.parseLine(line)
+	conn.logger.PrintCommand(command, param)
 	cmdObj := commands[strings.ToUpper(command)]
 	if cmdObj == nil {
-		Conn.writeMessage(500, "Command not found")
+		conn.writeMessage(500, "Command not found")
 		return
 	}
 	if cmdObj.RequireParam() && param == "" {
-		Conn.writeMessage(553, "action aborted, required param missing")
-	} else if cmdObj.RequireAuth() && Conn.user == "" {
-		Conn.writeMessage(530, "not logged in")
+		conn.writeMessage(553, "action aborted, required param missing")
+	} else if cmdObj.RequireAuth() && conn.user == "" {
+		conn.writeMessage(530, "not logged in")
 	} else {
-		cmdObj.Execute(Conn, param)
+		cmdObj.Execute(conn, param)
 	}
 }
 
-func (Conn *Conn) parseLine(line string) (string, string) {
+func (conn *Conn) parseLine(line string) (string, string) {
 	params := strings.SplitN(strings.Trim(line, "\r\n"), " ", 2)
 	if len(params) == 1 {
 		return params[0], ""
@@ -141,11 +141,11 @@ func (Conn *Conn) parseLine(line string) (string, string) {
 }
 
 // writeMessage will send a standard FTP response back to the client.
-func (Conn *Conn) writeMessage(code int, message string) (wrote int, err error) {
-	Conn.logger.PrintResponse(code, message)
+func (conn *Conn) writeMessage(code int, message string) (wrote int, err error) {
+	conn.logger.PrintResponse(code, message)
 	line := fmt.Sprintf("%d %s\r\n", code, message)
-	wrote, err = Conn.controlWriter.WriteString(line)
-	Conn.controlWriter.Flush()
+	wrote, err = conn.controlWriter.WriteString(line)
+	conn.controlWriter.Flush()
 	return
 }
 
@@ -166,43 +166,43 @@ func (Conn *Conn) writeMessage(code int, message string) (wrote int, err error)
 // The driver implementation is responsible for deciding how to treat this path.
 // Obviously they MUST NOT just read the path off disk. The probably want to
 // prefix the path with something to scope the users access to a sandbox.
-func (Conn *Conn) buildPath(filename string) (fullPath string) {
+func (conn *Conn) buildPath(filename string) (fullPath string) {
 	if len(filename) > 0 && filename[0:1] == "/" {
 		fullPath = filepath.Clean(filename)
 	} else if len(filename) > 0 && filename != "-a" {
-		fullPath = filepath.Clean(Conn.namePrefix + "/" + filename)
+		fullPath = filepath.Clean(conn.namePrefix + "/" + filename)
 	} else {
-		fullPath = filepath.Clean(Conn.namePrefix)
+		fullPath = filepath.Clean(conn.namePrefix)
 	}
 	fullPath = strings.Replace(fullPath, "//", "/", -1)
 	return
 }
 
 // sendOutofbandData will send a string to the client via the currently open
 // data socket. Assumes the socket is open and ready to be used.
-func (Conn *Conn) sendOutofbandData(data []byte) {
+func (conn *Conn) sendOutofbandData(data []byte) {
 	bytes := len(data)
-	if Conn.dataConn != nil {
-		Conn.dataConn.Write(data)
-		Conn.dataConn.Close()
-		Conn.dataConn = nil
+	if conn.dataConn != nil {
+		conn.dataConn.Write(data)
+		conn.dataConn.Close()
+		conn.dataConn = nil
 	}
 	message := "Closing data connection, sent " + strconv.Itoa(bytes) + " bytes"
-	Conn.writeMessage(226, message)
+	conn.writeMessage(226, message)
 }
 
-func (Conn *Conn) sendOutofBandDataWriter(data io.ReadCloser) error {
-	Conn.lastFilePos = 0
-	bytes, err := io.Copy(Conn.dataConn, data)
+func (conn *Conn) sendOutofBandDataWriter(data io.ReadCloser) error {
+	conn.lastFilePos = 0
+	bytes, err := io.Copy(conn.dataConn, data)
 	if err != nil {
-		Conn.dataConn.Close()
-		Conn.dataConn = nil
+		conn.dataConn.Close()
+		conn.dataConn = nil
 		return err
 	}
 	message := "Closing data connection, sent " + strconv.Itoa(int(bytes)) + " bytes"
-	Conn.writeMessage(226, message)
-	Conn.dataConn.Close()
-	Conn.dataConn = nil
+	conn.writeMessage(226, message)
+	conn.dataConn.Close()
+	conn.dataConn = nil
 
 	return nil
 }

logger.go

@@ -7,17 +7,17 @@ import (
 
 // Use an instance of this to log in a standard format
 type Logger struct {
-	sessionId string
+	sessionID string
 }
 
 func newLogger(id string) *Logger {
 	l := new(Logger)
-	l.sessionId = id
+	l.sessionID = id
 	return l
 }
 
 func (logger *Logger) Print(message interface{}) {
-	log.Printf("%s   %s", logger.sessionId, message)
+	log.Printf("%s   %s", logger.sessionID, message)
 }
 
 func (logger *Logger) Printf(format string, v ...interface{}) {
@@ -26,12 +26,12 @@ func (logger *Logger) Printf(format string, v ...interface{}) {
 
 func (logger *Logger) PrintCommand(command string, params string) {
 	if command == "PASS" {
-		log.Printf("%s > PASS ****", logger.sessionId)
+		log.Printf("%s > PASS ****", logger.sessionID)
 	} else {
-		log.Printf("%s > %s %s", logger.sessionId, command, params)
+		log.Printf("%s > %s %s", logger.sessionID, command, params)
 	}
 }
 
 func (logger *Logger) PrintResponse(code int, message string) {
-	log.Printf("%s < %d %s", logger.sessionId, code, message)
+	log.Printf("%s < %d %s", logger.sessionID, code, message)
 }

server.go

@@ -123,7 +123,7 @@ func NewServer(opts *ServerOpts) *Server {
 	opts = serverOptsWithDefaults(opts)
 	s := new(Server)
 	s.ServerOpts = opts
-	s.listenTo = buildTcpString(opts.Hostname, opts.Port)
+	s.listenTo = buildTCPString(opts.Hostname, opts.Port)
 	s.name = opts.Name
 	s.driverFactory = opts.Factory
 	s.logger = newLogger("")
@@ -143,8 +143,8 @@ func (server *Server) newConn(tcpConn net.Conn, driver Driver) *Conn {
 	c.driver = driver
 	c.auth = server.Auth
 	c.server = server
-	c.sessionId = newSessionId()
-	c.logger = newLogger(c.sessionId)
+	c.sessionID = newSessionID()
+	c.logger = newLogger(c.sessionID)
 	c.tlsConfig = server.tlsConfig
 	driver.Init(c)
 	return c
@@ -173,59 +173,59 @@ func simpleTLSConfig(certFile, keyFile string) (*tls.Config, error) {
 // errors are trying to bind to a privileged port or something else is already
 // listening on the same port.
 //
-func (Server *Server) ListenAndServe() error {
+func (server *Server) ListenAndServe() error {
 	var listener net.Listener
 	var err error
 
-	if Server.ServerOpts.TLS {
-		Server.tlsConfig, err = simpleTLSConfig(Server.CertFile, Server.KeyFile)
+	if server.ServerOpts.TLS {
+		server.tlsConfig, err = simpleTLSConfig(server.CertFile, server.KeyFile)
 		if err != nil {
 			return err
 		}
 
-		if Server.ServerOpts.ExplicitFTPS {
-			listener, err = net.Listen("tcp", Server.listenTo)
+		if server.ServerOpts.ExplicitFTPS {
+			listener, err = net.Listen("tcp", server.listenTo)
 		} else {
-			listener, err = tls.Listen("tcp", Server.listenTo, Server.tlsConfig)
+			listener, err = tls.Listen("tcp", server.listenTo, server.tlsConfig)
 		}
 	} else {
-		listener, err = net.Listen("tcp", Server.listenTo)
+		listener, err = net.Listen("tcp", server.listenTo)
 	}
 	if err != nil {
 		return err
 	}
 
-	Server.logger.Printf("%s listening on %d", Server.Name, Server.Port)
+	server.logger.Printf("%s listening on %d", server.Name, server.Port)
 
-	Server.listener = listener
+	server.listener = listener
 	for {
-		tcpConn, err := Server.listener.Accept()
+		tcpConn, err := server.listener.Accept()
 		if err != nil {
-			Server.logger.Printf("listening error: %v", err)
+			server.logger.Printf("listening error: %v", err)
 			break
 		}
-		driver, err := Server.driverFactory.NewDriver()
+		driver, err := server.driverFactory.NewDriver()
 		if err != nil {
-			Server.logger.Printf("Error creating driver, aborting client connection: %v", err)
+			server.logger.Printf("Error creating driver, aborting client connection: %v", err)
 			tcpConn.Close()
 		} else {
-			ftpConn := Server.newConn(tcpConn, driver)
+			ftpConn := server.newConn(tcpConn, driver)
 			go ftpConn.Serve()
 		}
 	}
 	return nil
 }
 
 // Gracefully stops a server. Already connected clients will retain their connections
-func (Server *Server) Shutdown() error {
-	if Server.listener != nil {
-		return Server.listener.Close()
+func (server *Server) Shutdown() error {
+	if server.listener != nil {
+		return server.listener.Close()
 	}
 	// server wasnt even started
 	return nil
 }
 
-func buildTcpString(hostname string, port int) (result string) {
+func buildTCPString(hostname string, port int) (result string) {
 	if strings.Contains(hostname, ":") {
 		// ipv6
 		if port == 0 {

socket.go

@@ -34,7 +34,7 @@ type ftpActiveSocket struct {
 }
 
 func newActiveSocket(host string, port int, logger *Logger) (DataSocket, error) {
-	connectTo := buildTcpString(host, port)
+	connectTo := buildTCPString(host, port)
 	logger.Print("Opening active data connection to " + connectTo)
 	raddr, err := net.ResolveTCPAddr("tcp", connectTo)
 	if err != nil {