serverless-ircd 0.1.0 → 0.2.0

package/webircgateway/pkg/irc/state.go

@@ -0,0 +1,79 @@
+package irc
+
+import (
+	"strings"
+	"sync"
+	"time"
+)
+
+type State struct {
+	LocalPort  int
+	RemotePort int
+	Username   string
+	Nick       string
+	RealName   string
+	Password   string
+	Account    string
+	Modes      map[string]string
+
+	channelsMutex sync.Mutex
+	Channels      map[string]*StateChannel
+	ISupport      *ISupport
+}
+
+type StateChannel struct {
+	Name   string
+	Modes  map[string]string
+	Joined time.Time
+}
+
+func NewState() *State {
+	return &State{
+		Channels: make(map[string]*StateChannel),
+		ISupport: &ISupport{
+			tokens: make(map[string]string),
+		},
+	}
+}
+
+func NewStateChannel(name string) *StateChannel {
+	return &StateChannel{
+		Name:   name,
+		Modes:  make(map[string]string),
+		Joined: time.Now(),
+	}
+}
+
+func (m *State) HasChannel(name string) (ok bool) {
+	m.channelsMutex.Lock()
+	_, ok = m.Channels[strings.ToLower(name)]
+	m.channelsMutex.Unlock()
+	return
+}
+
+func (m *State) GetChannel(name string) (channel *StateChannel) {
+	m.channelsMutex.Lock()
+	channel = m.Channels[strings.ToLower(name)]
+	m.channelsMutex.Unlock()
+	return
+}
+
+func (m *State) SetChannel(channel *StateChannel) {
+	m.channelsMutex.Lock()
+	m.Channels[strings.ToLower(channel.Name)] = channel
+	m.channelsMutex.Unlock()
+}
+
+func (m *State) RemoveChannel(name string) {
+	m.channelsMutex.Lock()
+	delete(m.Channels, strings.ToLower(name))
+	m.channelsMutex.Unlock()
+}
+
+func (m *State) ClearChannels() {
+	m.channelsMutex.Lock()
+	for i := range m.Channels {
+		delete(m.Channels, i)
+	}
+	m.channelsMutex.Unlock()
+}

package/webircgateway/pkg/proxy/proxy.go

@@ -0,0 +1,129 @@
+package proxy
+
+import (
+	"encoding/json"
+	"errors"
+	"io"
+	"net"
+)
+
+type KiwiProxyState int
+
+const KiwiProxyStateClosed KiwiProxyState = 0
+const KiwiProxyStateConnecting KiwiProxyState = 1
+const KiwiProxyStateHandshaking KiwiProxyState = 2
+const KiwiProxyStateConnected KiwiProxyState = 3
+
+type ConnError struct {
+	Msg  string
+	Type string
+}
+
+func (err *ConnError) Error() string {
+	return err.Msg
+}
+
+type KiwiProxyConnection struct {
+	Username       string
+	ProxyInterface string
+	DestHost       string
+	DestPort       int
+	DestTLS        bool
+	State          KiwiProxyState
+	Conn           *net.Conn
+}
+
+func MakeKiwiProxyConnection() *KiwiProxyConnection {
+	return &KiwiProxyConnection{
+		State: KiwiProxyStateClosed,
+	}
+}
+
+func (c *KiwiProxyConnection) Close() error {
+	if c.State == KiwiProxyStateClosed {
+		return errors.New("Connection already closed")
+	}
+
+	return (*c.Conn).Close()
+}
+
+func (c *KiwiProxyConnection) Dial(proxyServerAddr string) error {
+	if c.State != KiwiProxyStateClosed {
+		return errors.New("Connection in closed state")
+	}
+
+	c.State = KiwiProxyStateConnecting
+
+	conn, err := net.Dial("tcp", proxyServerAddr)
+	if err != nil {
+		return err
+	}
+
+	c.Conn = &conn
+	c.State = KiwiProxyStateHandshaking
+
+	meta, _ := json.Marshal(map[string]interface{}{
+		"username":  c.Username,
+		"interface": c.ProxyInterface,
+		"host":      c.DestHost,
+		"port":      c.DestPort,
+		"ssl":       c.DestTLS,
+	})
+
+	(*c.Conn).Write(append(meta, byte('\n')))
+
+	buf := make([]byte, 1024)
+	bufLen, readErr := (*c.Conn).Read(buf)
+	if readErr != nil {
+		(*c.Conn).Close()
+		c.State = KiwiProxyStateClosed
+		return readErr
+	}
+
+	response := string(buf)
+	if bufLen > 0 && response[0] == '1' {
+		c.State = KiwiProxyStateConnected
+	} else {
+		(*c.Conn).Close()
+		c.State = KiwiProxyStateClosed
+
+		if bufLen == 0 {
+			return errors.New("The proxy could not connect to the destination")
+		}
+
+		switch response[0] {
+		case '0':
+			return errors.New("The proxy could not connect to the destination")
+		case '2':
+			return &ConnError{Msg: "Connection reset", Type: "conn_reset"}
+		case '3':
+			return &ConnError{Msg: "Connection refused", Type: "conn_refused"}
+		case '4':
+			return &ConnError{Msg: "Host not found", Type: "not_found"}
+		case '5':
+			return &ConnError{Msg: "Connection timed out", Type: "conn_timeout"}
+		}
+	}
+
+	return nil
+}
+
+func (c *KiwiProxyConnection) Read(b []byte) (n int, err error) {
+	if c.State == KiwiProxyStateConnecting || c.State == KiwiProxyStateHandshaking {
+		return 0, nil
+	} else if c.State == KiwiProxyStateClosed {
+		return 0, io.EOF
+	} else {
+		return (*c.Conn).Read(b)
+	}
+}
+
+func (c *KiwiProxyConnection) Write(b []byte) (n int, err error) {
+	if c.State == KiwiProxyStateConnecting || c.State == KiwiProxyStateHandshaking {
+		return 0, nil
+	} else if c.State == KiwiProxyStateClosed {
+		return 0, io.EOF
+	} else {
+		return (*c.Conn).Write(b)
+	}
+}

package/webircgateway/pkg/proxy/server.go

@@ -0,0 +1,237 @@
+package proxy
+
+import (
+	"bufio"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"strconv"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/kiwiirc/webircgateway/pkg/identd"
+)
+
+const (
+	ResponseError       = "0"
+	ResponseOK          = "1"
+	ResponseReset       = "2"
+	ResponseRefused     = "3"
+	ResponseUnknownHost = "4"
+	ResponseTimeout     = "5"
+)
+
+var identdRpc *identd.RpcClient
+var Server net.Listener
+
+type HandshakeMeta struct {
+	Host      string `json:"host"`
+	Port      int    `json:"port"`
+	TLS       bool   `json:"ssl"`
+	Username  string `json:"username"`
+	Interface string `json:"interface"`
+}
+
+func MakeClient(conn net.Conn) *Client {
+	return &Client{
+		Client: conn,
+	}
+}
+
+type Client struct {
+	Client       net.Conn
+	Upstream     net.Conn
+	UpstreamAddr *net.TCPAddr
+	Username     string
+	BindAddr     *net.TCPAddr
+	TLS          bool
+}
+
+func (c *Client) Run() {
+	var err error
+
+	err = c.Handshake()
+	if err != nil {
+		log.Println(err.Error())
+		return
+	}
+
+	err = c.ConnectUpstream()
+	if err != nil {
+		log.Println(err.Error())
+		return
+	}
+
+	c.Pipe()
+}
+
+func (c *Client) Handshake() error {
+	// Read the first line - it should be JSON
+	reader := bufio.NewReader(c.Client)
+	line, readErr := reader.ReadBytes('\n')
+	if readErr != nil {
+		return readErr
+	}
+
+	var meta = HandshakeMeta{
+		Username:  "user",
+		Port:      6667,
+		Interface: "0.0.0.0",
+	}
+	unmarshalErr := json.Unmarshal(line, &meta)
+	if unmarshalErr != nil {
+		c.Client.Write([]byte(ResponseError))
+		return unmarshalErr
+	}
+
+	if meta.Host == "" || meta.Port == 0 || meta.Username == "" || meta.Interface == "" {
+		c.Client.Write([]byte(ResponseError))
+		return fmt.Errorf("missing args")
+	}
+
+	c.Username = meta.Username
+	c.TLS = meta.TLS
+
+	bindAddr, bindAddrErr := net.ResolveTCPAddr("tcp", meta.Interface+":")
+	if bindAddrErr != nil {
+		c.Client.Write([]byte(ResponseError))
+		return fmt.Errorf("interface: " + bindAddrErr.Error())
+	}
+	c.BindAddr = bindAddr
+
+	hostStr := net.JoinHostPort(meta.Host, strconv.Itoa(meta.Port))
+	addr, addrErr := net.ResolveTCPAddr("tcp", hostStr)
+	if addrErr != nil {
+		c.Client.Write([]byte(ResponseUnknownHost))
+		return fmt.Errorf("remote host: " + addrErr.Error())
+	}
+	c.UpstreamAddr = addr
+
+	return nil
+}
+
+func (c *Client) ConnectUpstream() error {
+	dialer := &net.Dialer{}
+	dialer.LocalAddr = c.BindAddr
+	dialer.Timeout = time.Second * 10
+
+	conn, err := dialer.Dial("tcp", c.UpstreamAddr.String())
+	if err != nil {
+		response := ""
+		errType := typeOfErr(err)
+		switch errType {
+		case "timeout":
+			response = ResponseTimeout
+		case "unknown_host":
+			response = ResponseUnknownHost
+		case "refused":
+			response = ResponseRefused
+		}
+
+		c.Client.Write([]byte(response))
+		return err
+	}
+
+	if identdRpc != nil {
+		lAddr, lPortStr, _ := net.SplitHostPort(conn.LocalAddr().String())
+		lPort, _ := strconv.Atoi(lPortStr)
+		identdRpc.AddIdent(lPort, c.UpstreamAddr.Port, c.Username, lAddr)
+	}
+
+	if c.TLS {
+		tlsConfig := &tls.Config{InsecureSkipVerify: true}
+		tlsConn := tls.Client(conn, tlsConfig)
+		err := tlsConn.Handshake()
+		if err != nil {
+			conn.Close()
+			c.Client.Write([]byte(ResponseReset))
+			return err
+		}
+
+		conn = net.Conn(tlsConn)
+	}
+
+	c.Upstream = conn
+	c.Client.Write([]byte(ResponseOK))
+	return nil
+}
+
+func (c *Client) Pipe() {
+	wg := sync.WaitGroup{}
+	wg.Add(2)
+
+	go func() {
+		io.Copy(c.Client, c.Upstream)
+		c.Client.Close()
+		wg.Done()
+	}()
+
+	go func() {
+		io.Copy(c.Upstream, c.Client)
+		c.Upstream.Close()
+		wg.Done()
+	}()
+
+	wg.Wait()
+
+	if identdRpc != nil {
+		lAddr, lPortStr, _ := net.SplitHostPort(c.Upstream.LocalAddr().String())
+		lPort, _ := strconv.Atoi(lPortStr)
+		identdRpc.RemoveIdent(lPort, c.UpstreamAddr.Port, c.Username, lAddr)
+	}
+}
+
+func Start(laddr string) {
+	srv, err := net.Listen("tcp", laddr)
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+
+	// Expose the server
+	Server = srv
+	log.Printf("Kiwi proxy listening on %s", srv.Addr().String())
+
+	identdRpc = identd.MakeRpcClient("kiwiproxy" + laddr)
+	go identdRpc.ConnectAndReconnect("127.0.0.1:1133")
+
+	for {
+		conn, err := srv.Accept()
+		if err != nil {
+			log.Print(err.Error())
+			break
+		}
+
+		c := MakeClient(conn)
+		go c.Run()
+	}
+}
+
+func typeOfErr(err error) string {
+	if err == nil {
+		return ""
+	}
+
+	if netError, ok := err.(net.Error); ok && netError.Timeout() {
+		return "timeout"
+	}
+
+	switch t := err.(type) {
+	case *net.OpError:
+		if t.Op == "dial" {
+			return "unknown_host"
+		} else if t.Op == "read" {
+			return "refused"
+		}
+
+	case syscall.Errno:
+		if t == syscall.ECONNREFUSED {
+			return "refused"
+		}
+	}
+
+	return ""
+}

package/webircgateway/pkg/recaptcha/recaptcha.go

@@ -0,0 +1,59 @@
+// Google re-captcha package tweaked from http://github.com/haisum/recaptcha
+
+package recaptcha
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// R type represents an object of Recaptcha and has public property Secret,
+// which is secret obtained from google recaptcha tool admin interface
+type R struct {
+	URL       string
+	Secret    string
+	lastError []string
+}
+
+// Struct for parsing json in google's response
+type googleResponse struct {
+	Success    bool
+	ErrorCodes []string `json:"error-codes"`
+}
+
+// VerifyResponse is a method similar to `Verify`; but doesn't parse the form for you.  Useful if
+// you're receiving the data as a JSON object from a javascript app or similar.
+func (r *R) VerifyResponse(response string) bool {
+	r.lastError = make([]string, 1)
+	client := &http.Client{Timeout: 20 * time.Second}
+	resp, err := client.PostForm(r.URL,
+		url.Values{"secret": {r.Secret}, "response": {response}})
+	if err != nil {
+		r.lastError = append(r.lastError, err.Error())
+		return false
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		r.lastError = append(r.lastError, err.Error())
+		return false
+	}
+	gr := new(googleResponse)
+	err = json.Unmarshal(body, gr)
+	if err != nil {
+		r.lastError = append(r.lastError, err.Error())
+		return false
+	}
+	if !gr.Success {
+		r.lastError = append(r.lastError, gr.ErrorCodes...)
+	}
+	return gr.Success
+}
+
+// LastError returns errors occurred in last re-captcha validation attempt
+func (r R) LastError() []string {
+	return r.lastError
+}