initial commit

Author: fhs

.hgignore

@@ -0,0 +1,3 @@
+syntax: glob
+*.8
+*.a

LICENSE

@@ -0,0 +1,19 @@
+Copyright © 2010 Fazlul Shahriar <[email protected]>.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

netrc/Makefile

@@ -0,0 +1,10 @@
+# Copyright © 2010 Fazlul Shahriar <[email protected]>.
+# See LICENSE file for license details.
+
+include $(GOROOT)/src/Make.$(GOARCH)
+
+TARG=go-netrc.googlecode.com/hg/netrc
+GOFILES=\
+	netrc.go\
+
+include $(GOROOT)/src/Make.pkg

netrc/example.netrc

@@ -0,0 +1,14 @@
+machine mail.google.com
+	login [email protected]
+	account gmail
+	password somethingSecret
+
+machine ray login demo password mypassword
+
+macdef allput
+put src/*
+
+default
+	login anonymous
+	password [email protected]
+

netrc/netrc.go

@@ -0,0 +1,270 @@
+// Copyright © 2010 Fazlul Shahriar <[email protected]>.
+// See LICENSE file for license details.
+
+// This package implements a parser for netrc file format.
+//
+// A netrc file usually resides in $HOME/.netrc and is traditionally used
+// by the ftp(1) program to look up login information (username, password,
+// etc.) of remote system(s). The file format is (loosely) described in
+// this man page: http://linux.die.net/man/5/netrc .
+package netrc
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"unicode"
+	"utf8"
+)
+
+const (
+	tkMachine = iota
+	tkDefault
+	tkLogin
+	tkPassword
+	tkAccount
+	tkMacdef
+)
+
+var tokenNames = []string{
+	"Machine",
+	"Default",
+	"Login",
+	"Password",
+	"Account",
+	"Macdef",
+}
+
+var keywords = map[string]int{
+	"machine":  tkMachine,
+	"default":  tkDefault,
+	"login":    tkLogin,
+	"password": tkPassword,
+	"account":  tkAccount,
+	"macdef":   tkMacdef,
+}
+
+type Machine struct {
+	Name     string
+	Login    string
+	Password string
+	Account  string
+}
+
+type Macros map[string]string
+
+type token struct {
+	kind      int
+	macroName string
+	value     string
+}
+
+type filePos struct {
+	name string
+	line int
+}
+
+type Error struct {
+	Filename string
+	LineNum  int    // Line number
+	Msg      string // Error message
+}
+
+func (e *Error) String() string {
+	return fmt.Sprintf("%s:%d: %s", e.Filename, e.LineNum, e.Msg)
+}
+
+func getWord(b []byte, pos *filePos) (string, []byte) {
+	// Skip over leading whitespace
+	i := 0
+	for i < len(b) {
+		r, size := utf8.DecodeRune(b[i:])
+		if r == '\n' {
+			pos.line++
+		}
+		if !unicode.IsSpace(r) {
+			break
+		}
+		i += size
+	}
+	b = b[i:]
+
+	// Find end of word
+	i = bytes.IndexFunc(b, unicode.IsSpace)
+	if i < 0 {
+		i = len(b)
+	}
+	return string(b[0:i]), b[i:]
+}
+
+func getToken(b []byte, pos *filePos) ([]byte, *token, os.Error) {
+	word, b := getWord(b, pos)
+	if word == "" {
+		return b, nil, nil // EOF reached
+	}
+
+	t := new(token)
+	var ok bool
+	t.kind, ok = keywords[word]
+	if !ok {
+		return b, nil, &Error{pos.name, pos.line, "keyword expected; got " + word}
+	}
+	if t.kind == tkDefault {
+		return b, t, nil
+	}
+
+	word, b = getWord(b, pos)
+	if word == "" {
+		return b, nil, &Error{pos.name, pos.line, "word expected"}
+	}
+	if t.kind == tkMacdef {
+		t.macroName = word
+
+		// Macro value starts on next line. The rest of current line
+		// should contain nothing but whitespace
+		i := 0
+		for i < len(b) {
+			r, size := utf8.DecodeRune(b[i:])
+			if r == '\n' {
+				i += size
+				pos.line++
+				break
+			}
+			if !unicode.IsSpace(r) {
+				return b, nil, &Error{pos.name, pos.line, "unexpected word"}
+			}
+			i += size
+		}
+		b = b[i:]
+
+		// Find end of macro value
+		i = bytes.Index(b, []byte("\n\n"))
+		if i < 0 { // EOF reached
+			i = len(b)
+		}
+		t.value = string(b[0:i])
+
+		return b[i:], t, nil
+	}
+	t.value = word
+	return b, t, nil
+}
+
+func appendMach(mach []*Machine, m *Machine) []*Machine {
+	n := len(mach)
+	if n+1 > cap(mach) {
+		mach1 := make([]*Machine, 2*cap(mach)+10)
+		copy(mach1[0:n], mach)
+		mach = mach1[0:n]
+	}
+	mach = mach[0 : n+1]
+	mach[n] = m
+	return mach
+}
+
+func parse(r io.Reader, pos *filePos) ([]*Machine, Macros, os.Error) {
+	// TODO(fhs): Clear memory containing password.
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	mach := make([]*Machine, 0, 20)
+	mac := make(Macros, 10)
+	var defaultSeen bool
+	var m *Machine
+	var t *token
+	for {
+		b, t, err = getToken(b, pos)
+		if err != nil {
+			return nil, nil, err
+		}
+		if t == nil {
+			break
+		}
+		switch t.kind {
+		case tkMacdef:
+			mac[t.macroName] = t.value
+		case tkDefault:
+			if defaultSeen {
+				return nil, nil, &Error{pos.name, pos.line, "multiple default token"}
+			}
+			if m != nil {
+				mach, m = appendMach(mach, m), nil
+			}
+			m = new(Machine)
+			m.Name = ""
+			defaultSeen = true
+		case tkMachine:
+			if m != nil {
+				mach, m = appendMach(mach, m), nil
+			}
+			m = new(Machine)
+			m.Name = t.value
+		case tkLogin:
+			if m == nil || m.Login != "" {
+				return nil, nil, &Error{pos.name, pos.line, "unexpected token login "}
+			}
+			m.Login = t.value
+		case tkPassword:
+			if m == nil || m.Password != "" {
+				return nil, nil, &Error{pos.name, pos.line, "unexpected token password"}
+			}
+			m.Password = t.value
+		case tkAccount:
+			if m == nil || m.Account != "" {
+				return nil, nil, &Error{pos.name, pos.line, "unexpected token account"}
+			}
+			m.Account = t.value
+		}
+	}
+	if m != nil {
+		mach, m = appendMach(mach, m), nil
+	}
+	return mach, mac, nil
+}
+
+// ParseFile parses the netrc file identified by filename and returns the set of
+// machine information and macros defined in it. The ``default'' machine,
+// which is intended to be used when no machine name matches, is identified
+// by an empty machine name. There can be only one ``default'' machine.
+//
+// If there is a parsing error, an Error is returned.
+func ParseFile(filename string) ([]*Machine, Macros, os.Error) {
+	// TODO(fhs): Check if file is readable by anyone besides the user if there is password in it.
+	fd, err := os.Open(filename, os.O_RDONLY, 0)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer fd.Close()
+	return parse(fd, &filePos{filename, 1})
+}
+
+
+// ParseFile parses the netrc file identified by filename and returns
+// the Machine named by name. If no Machine with name name is found, the
+// ``default'' machine is returned.
+func FindMachine(filename string, name string) (*Machine, os.Error) {
+	mach, _, err := ParseFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	var def, m *Machine
+	for _, m = range mach {
+		if m.Name == name {
+			return m, nil
+		}
+		if m.Name == "" {
+			def = m
+		}
+	}
+	if m == nil && def == nil {
+		return nil, os.NewError("no machine found")
+	}
+	if m != nil {
+		return m, nil
+	}
+	return def, nil
+}

netrc/netrc_test.go

@@ -0,0 +1,43 @@
+// Copyright © 2010 Fazlul Shahriar <[email protected]>.
+// See LICENSE file for license details.
+
+package netrc_test
+
+import (
+	. "go-netrc.googlecode.com/hg/netrc"
+	"testing"
+)
+
+func eqMach(a *Machine, b *Machine) bool {
+	return a.Name == b.Name &&
+		a.Login == b.Login &&
+		a.Password == b.Password &&
+		a.Account == b.Account
+}
+
+func TestParse(t *testing.T) {
+	mach, mac, err := ParseFile("example.netrc")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedMach := []*Machine{
+		&Machine{"mail.google.com", "[email protected]", "somethingSecret", "gmail"},
+		&Machine{"ray", "demo", "mypassword", ""},
+		&Machine{"", "anonymous", "[email protected]", ""},
+	}
+	for i, e := range expectedMach {
+		if !eqMach(e, mach[i]) {
+			t.Errorf("bad machine; expected %v, got %v\n", e, mach[i])
+		}
+	}
+
+	expectedMac := Macros{
+		"allput": "put src/*",
+	}
+	for k, v := range expectedMac {
+		if v != mac[k] {
+			t.Errorf("bad macro for %s; expected %s, got %s\n", k, v, mac[k])
+		}
+	}
+}