Example #1
0
func (s *Server) acceptUDP() {
	// Looping for new messages
	for {
		buf := make([]byte, MAX_MSG_SIZE)
		n, adr, err := s.udpsock.ReadFrom(buf)

		if s.comm.running {
			if err != nil {
				log.Error("Error while reading UDP (read %d) from %s: %s\n", n, adr, err)

			} else {
				abcon := net.Conn(s.udpsock)
				connection := NewConnection(s.comm.pool, P_UDP, D_Inbound, abcon)
				read := io.Reader(bytes.NewBuffer(buf))
				msg := s.comm.NewMessage()
				msg.connection = connection
				err := msg.readMessage(read)

				if err != nil {
					log.Error("Couldn't handle message received from UDP because of errors: %s %s\n", msg, err)
				} else {
					go s.comm.handleMessage(msg)
				}
			}
		} else {
			log.Info("Dropping connection because communications have been paused")
		}
	}
}
Example #2
0
// NewDirectRPCClient creates a rpc client
func NewDirectRPCClient(c *Client, clientCodecFunc ClientCodecFunc, network, address string, timeout time.Duration) (*rpc.Client, error) {
	//if network == "http" || network == "https" {
	if network == "http" {
		return NewDirectHTTPRPCClient(c, clientCodecFunc, network, address, "", timeout)
	}

	var conn net.Conn
	var tlsConn *tls.Conn
	var err error

	if c != nil && c.TLSConfig != nil {
		dialer := &net.Dialer{
			Timeout: timeout,
		}
		tlsConn, err = tls.DialWithDialer(dialer, network, address, c.TLSConfig)
		//or conn:= tls.Client(netConn, &config)

		conn = net.Conn(tlsConn)
	} else {
		conn, err = net.DialTimeout(network, address, timeout)
	}

	if err != nil {
		return nil, err
	}

	if c == nil || c.PluginContainer == nil {
		return rpc.NewClientWithCodec(clientCodecFunc(conn)), nil
	}
	return rpc.NewClientWithCodec(newClientCodecWrapper(c.PluginContainer, clientCodecFunc(conn))), nil
}
Example #3
0
// HandleStartTLS is the companion to StartTLS, and will do the connection upgrade.  It assumes
// that the TLS command byte has already been read.  Like StartTLS it returns the peer name, or
// an error
func (p *Protocol) HandleStartTLS(identity *security.Identity, caCertificate *security.Certificate) (string, error) {
	var (
		err     error
		tlsConn *tls.Conn
	)

	// Build the config
	config := new(tls.Config)
	config.ClientAuth = tls.RequireAndVerifyClientCert

	// Setup the tls connection
	if err := p.tlsSetup(config, identity, caCertificate); err != nil {
		return "", err
	}

	// Upgrade the connection to TLS
	// TODO: Add a deadline here?
	tlsConn = tls.Server(p.conn, config)
	if err = tlsConn.Handshake(); err != nil {
		return "", err
	}

	// Capture the connection state
	cs := tlsConn.ConnectionState()

	// And replace the original connection
	p.conn = net.Conn(tlsConn)
	p.setupBuffers()

	// Send an Ack
	p.Ack()

	return cs.PeerCertificates[0].Subject.CommonName, nil
}
Example #4
0
// StartTLS takes an identity and an authority certificate and upgrades the net.Conn on the protocol to TLS
// It returns the CommonName from the peer certitifcate, or an error
func (p *Protocol) StartTLS(identity *security.Identity, caCertificate *security.Certificate) (string, error) {
	var (
		err     error
		tlsConn *tls.Conn
	)

	if err = p.WriteBytesWithDeadline([]byte{TLS}); err != nil {
		return "", err
	}

	// Build the config
	config := new(tls.Config)
	config.ServerName = p.serverName

	// Setup the tls connection
	if err = p.tlsSetup(config, identity, caCertificate); err != nil {
		return "", err
	}

	// Upgrade the connection to TLS
	// TODO: Add a deadline here?
	tlsConn = tls.Client(p.conn, config)
	if err = tlsConn.Handshake(); err != nil {
		return "", err
	}

	// Capture the connection state
	cs := tlsConn.ConnectionState()

	// And replace the original connection
	p.conn = net.Conn(tlsConn)
	p.setupBuffers()

	return cs.PeerCertificates[0].Subject.CommonName, nil
}
Example #5
0
// SNIHost will try preempt the TLS handshake and try to sniff the
// Server Name Indication.  It returns `Host()` for non CONNECT
// requests, so it is always safe to call.  If it sniffed
// successfully, but didn't find anything, it is possible to return an
// empty string.
func (ctx *ProxyCtx) SNIHost() string {
	if ctx.Method != "CONNECT" {
		return ctx.Host()
	}

	if ctx.sniffedTLS {
		return ctx.sniHost
	}

	ctx.Conn.Write([]byte("HTTP/1.0 200 OK\r\n\r\n"))

	tlsConn, err := vhost.TLS(ctx.Conn)
	ctx.Conn = net.Conn(tlsConn)
	ctx.sniffedTLS = true
	if err != nil {
		ctx.Logf("Failed to sniff SNI (falling back to request Host): %s", err)
		return ctx.Host()
	}

	// TODO: make sure we put a ":port" on the `host` if there was one previously...
	sniHost := tlsConn.Host()

	if sniHost != "" {
		ctx.SetDestinationHost(inheritPort(sniHost, ctx.Host()))
		ctx.sniHost = ctx.Host()
	}
	return ctx.sniHost
}
Example #6
0
func TestIssue292(t *testing.T) {
	// The util/conn.Manager won't attempt to reconnect to the provided endpoint
	// if the endpoint is initially unavailable (e.g. dial tcp :8080:
	// getsockopt: connection refused). If the endpoint is up when
	// conn.NewManager is called and then goes down/up, it reconnects just fine.

	var (
		tickc    = make(chan time.Time)
		after    = func(time.Duration) <-chan time.Time { return tickc }
		dialconn = net.Conn(nil)
		dialerr  = errors.New("fail")
		dialer   = func(string, string) (net.Conn, error) { return dialconn, dialerr }
		mgr      = NewManager(dialer, "netw", "addr", after, log.NewNopLogger())
	)

	if conn := mgr.Take(); conn != nil {
		t.Fatal("first Take should have yielded nil conn, but didn't")
	}

	dialconn, dialerr = &mockConn{}, nil
	select {
	case tickc <- time.Now():
	case <-time.After(time.Second):
		t.Fatal("manager isn't listening for a tick, despite a failed dial")
	}

	if !within(time.Second, func() bool {
		return mgr.Take() != nil
	}) {
		t.Fatal("second Take should have yielded good conn, but didn't")
	}
}
Example #7
0
func (t *TCP) startTLS() (el element.Element, err error) {
	var tlsConn *tls.Conn
	if t.mode == stream.Initiating {
		err = t.WriteElement(element.StartTLS)
		if err != nil {
			return
		}
		el, err = t.Next()
		if err != nil || el.Tag != element.TLSProceed.Tag {
			return
		}
		tlsConn = tls.Client(t.Conn, t.conf)
	} else {
		err = t.WriteElement(element.TLSProceed)
		if err != nil {
			return
		}
		tlsConn = tls.Server(t.Conn, t.conf)
	}

	err = tlsConn.Handshake()
	if err != nil {
		return
	}
	conn := net.Conn(tlsConn)
	t.Conn = conn
	t.Decoder = xml.NewDecoder(conn)
	el = element.Element{}
	err = stream.ErrRequireRestart
	t.secure = true
	log.Println("Done upgrading connection")
	return
}
Example #8
0
func (server *TcpServer) Start() (err error) {
	for {
		var conn *net.TCPConn
		if conn, err = server.TCPListener.AcceptTCP(); err != nil {
			return err
		}
		if server.keepAlive != nil {
			if err := conn.SetKeepAlive(server.keepAlive.(bool)); err != nil {
				return err
			}
		}
		if server.keepAlivePeriod != nil {
			if kap, ok := (net.Conn(conn)).(iKeepAlivePeriod); ok {
				if err := kap.SetKeepAlivePeriod(server.keepAlivePeriod.(time.Duration)); err != nil {
					return err
				}
			}
		}
		if server.linger != nil {
			if err := conn.SetLinger(server.linger.(int)); err != nil {
				return err
			}
		}
		if server.noDelay != nil {
			if err := conn.SetNoDelay(server.noDelay.(bool)); err != nil {
				return err
			}
		}
		if server.readBuffer != nil {
			if err := conn.SetReadBuffer(server.readBuffer.(int)); err != nil {
				return err
			}
		}
		if server.writerBuffer != nil {
			if err := conn.SetWriteBuffer(server.writerBuffer.(int)); err != nil {
				return err
			}
		}
		if server.deadline != nil {
			if err := conn.SetDeadline(server.deadline.(time.Time)); err != nil {
				return err
			}
		}
		if server.readDeadline != nil {
			if err := conn.SetReadDeadline(server.readDeadline.(time.Time)); err != nil {
				return err
			}
		}
		if server.writerDeadline != nil {
			if err := conn.SetWriteDeadline(server.writerDeadline.(time.Time)); err != nil {
				return err
			}
		}
		if server.config != nil {
			server.ServeTCP(tls.Client(conn, server.config))
		} else {
			server.ServeTCP(conn)
		}
	}
}
Example #9
0
func (l *Listener) Accept() (c net.Conn, err error) {
	l.m.Lock()
	defer l.m.Unlock()

	if l.err == nil {
		l.err = errAccepted
		return net.Conn(l.client), nil
	}
	return nil, l.err
}
Example #10
0
func (p *Pool) GetMsgConnection(node *cluster.Node) *Connection {
	// TODO: IMPLEMENT THE POOLING

	adr := net.UDPAddr{node.Address, int(node.UdpPort)}
	con, err := net.DialUDP("udp", nil, &adr) // TODO: should use local address instead of nil (implicitly local)
	if err != nil {
		log.Error("NETPOOL: Couldn't create a connection\n", err)
		return nil
	}

	abcon := net.Conn(con)
	connection := NewConnection(p, P_UDP, D_Outbound, abcon)
	return connection
}
Example #11
0
// Upgrades a client connection to TLS
func (server *server) upgradeToTLS(client *client) bool {
	tlsConn := tls.Server(client.conn, server.tlsConfig)
	err := tlsConn.Handshake()
	if err != nil {
		log.WithError(err).Warn("[%s] Failed TLS handshake", client.RemoteAddress)
		return false
	}
	client.conn = net.Conn(tlsConn)
	client.bufin = newSMTPBufferedReader(client.conn)
	client.bufout = bufio.NewWriter(client.conn)
	client.TLS = true

	return true
}
Example #12
0
func TestRePConn2(t *testing.T) {
	c, err := net.Dial("tcp", "www.baidu.com:80")
	if err != nil {
		t.Errorf("连接错误:%v", err)
	}
	if _, err := c.Write([]byte("GET / HTTP/1.0\r\nHOST:www.baidu.com\r\n\r\n")); err != nil {
		t.Errorf("写错误:", err)
	}
	tConn := TConn{c}

	preconn := NewPreConn(tConn)
	preconn.NewPre()

	// 第一次读取
	b1 := make([]byte, 16384)
	if n, err := preconn.Read(b1); err != nil {
		t.Errorf("读错误:%v", err)
	} else {
		b1 = b1[:n]
	}

	preconn.ResetPreOffset()

	// 预读的实现是只要缓冲区有数据,即使不够也会直接返回而不是阻塞在Read里面
	// 所以这里应该是相同的长度。
	b2 := make([]byte, 16384)
	if n, err := preconn.Read(b2); err != nil {
		t.Errorf("读错误:", err)
	} else {
		b2 = b2[:n]
	}

	if bytes.Equal(b1, b2) != true {
		t.Errorf("预读会退结果不相等")
	}

	preconn.ResetPreOffset()
	conn := net.Conn(preconn)
	b2 = b2[:16384]
	if n, err := conn.Read(b2); err != nil {
		t.Errorf("读错误:%v", err)
	} else {
		b2 = b2[:n]
	}

	if bytes.Equal(b1, b2) != true {
		t.Errorf("预读会退结果不相等")
	}

}
Example #13
0
func notify(path, msg string) error {
	addr := net.UnixAddr{
		Net:  netType,
		Name: path,
	}
	conn, err := net.DialUnix(netType, nil, &addr)
	if err != nil {
		return err
	}
	defer net.Conn(conn).Close()

	_, err = conn.Write([]byte(msg))
	return err
}
Example #14
0
// Reconnect forces a new connection to the gateway
// If a connection exists it is closed before the creation of a new one
func (c *PersistentClient) Reconnect() error {

	var cert tls.Certificate
	var err error

	if c.isConnected == true {
		c.Close()
	}

	if len(c.client.certificateBase64) == 0 && len(c.client.keyBase64) == 0 {
		// The user did not specify raw block contents, so check the filesystem.
		cert, err = tls.LoadX509KeyPair(c.client.certificateFile, c.client.keyFile)
	} else {
		// The user provided the raw block contents, so use that.
		cert, err = tls.X509KeyPair([]byte(c.client.certificateBase64), []byte(c.client.keyBase64))
	}
	if err != nil {
		return err
	}
	gatewayParts := strings.Split(c.client.gateway, ":")
	conf := &tls.Config{
		Certificates: []tls.Certificate{cert},
		ServerName:   gatewayParts[0],
	}
	if c.ip == "" { // If the ip is not provided pick one
		ip, err := pickGatewayIP(gatewayParts[0])
		if err != nil {
			return err
		}
		c.ip = ip
	}
	conn, err := net.Dial("tcp", c.ip+":"+gatewayParts[1])
	if err != nil {
		return err
	}
	tlsConn := tls.Client(conn, conf)
	err = tlsConn.Handshake()
	if err != nil {
		conn.Close()
		return err
	}
	c.mu.Lock()
	c.conn = net.Conn(tlsConn)
	c.isConnected = true
	c.mu.Unlock()
	log.Printf("Address of %s is %s", c.client.gateway, c.conn.RemoteAddr().String())
	return nil
}
Example #15
0
func (c *Conn) upgradeSnappy() error {
	conn := net.Conn(c.conn)
	if c.tlsConn != nil {
		conn = c.tlsConn
	}
	c.r = snappystream.NewReader(conn, snappystream.SkipVerifyChecksum)
	c.w = snappystream.NewWriter(conn)
	frameType, data, err := ReadUnpackedResponse(c)
	if err != nil {
		return err
	}
	if frameType != FrameTypeResponse || !bytes.Equal(data, []byte("OK")) {
		return errors.New("invalid response from Snappy upgrade")
	}
	return nil
}
Example #16
0
// NewDirectHTTPRPCClient creates a rpc http client
func NewDirectHTTPRPCClient(c *Client, clientCodecFunc ClientCodecFunc, network, address string, path string, timeout time.Duration) (*rpc.Client, error) {
	if path == "" {
		path = rpc.DefaultRPCPath
	}

	var conn net.Conn
	var tlsConn *tls.Conn
	var err error

	if c != nil && c.TLSConfig != nil {
		dialer := &net.Dialer{
			Timeout: timeout,
		}
		tlsConn, err = tls.DialWithDialer(dialer, "tcp", address, c.TLSConfig)
		//or conn:= tls.Client(netConn, &config)

		conn = net.Conn(tlsConn)
	} else {
		conn, err = net.DialTimeout("tcp", address, timeout)
	}
	if err != nil {
		return nil, err
	}

	io.WriteString(conn, "CONNECT "+path+" HTTP/1.0\n\n")

	// Require successful HTTP response
	// before switching to RPC protocol.
	resp, err := http.ReadResponse(bufio.NewReader(conn), &http.Request{Method: "CONNECT"})
	if err == nil && resp.Status == connected {
		if c == nil || c.PluginContainer == nil {
			return rpc.NewClientWithCodec(clientCodecFunc(conn)), nil
		}
		return rpc.NewClientWithCodec(newClientCodecWrapper(c.PluginContainer, clientCodecFunc(conn))), nil
	}
	if err == nil {
		err = errors.New("unexpected HTTP response: " + resp.Status)
	}
	conn.Close()
	return nil, &net.OpError{
		Op:   "dial-http",
		Net:  network + " " + address,
		Addr: nil,
		Err:  err,
	}
}
Example #17
0
func (c *Conn) upgradeDeflate(level int) error {
	conn := net.Conn(c.conn)
	if c.tlsConn != nil {
		conn = c.tlsConn
	}
	fw, _ := flate.NewWriter(conn, level)
	c.r = flate.NewReader(conn)
	c.w = fw
	frameType, data, err := ReadUnpackedResponse(c)
	if err != nil {
		return err
	}
	if frameType != FrameTypeResponse || !bytes.Equal(data, []byte("OK")) {
		return errors.New("invalid response from Deflate upgrade")
	}
	return nil
}
Example #18
0
func obfs_accept(listener net.Listener) (net.Conn, error) {
	c, err := listener.Accept()
	if err != nil {
		return nil, err
	}
	conn := net.Conn(nil)
	donechan := make(chan error)
	eee := error(nil)
	go func() {
		conn, err = Kiriobfs_handshake_server(c)
		eee = err
		donechan <- err
	}()
	select {
	case <-donechan:
		return conn, eee
	case <-time.After(time.Second * time.Duration(10)):
		return nil, errors.New("timed out")
	}
}
Example #19
0
// ServeTCP ...
func (service *TcpService) ServeTCP(conn *net.TCPConn) (err error) {
	if service.keepAlive != nil {
		if err = conn.SetKeepAlive(service.keepAlive.(bool)); err != nil {
			return err
		}
	}
	if service.keepAlivePeriod != nil {
		if kap, ok := (net.Conn(conn)).(iKeepAlivePeriod); ok {
			if err = kap.SetKeepAlivePeriod(service.keepAlivePeriod.(time.Duration)); err != nil {
				return err
			}
		}
	}
	if service.linger != nil {
		if err = conn.SetLinger(service.linger.(int)); err != nil {
			return err
		}
	}
	if service.noDelay != nil {
		if err = conn.SetNoDelay(service.noDelay.(bool)); err != nil {
			return err
		}
	}
	if service.readBuffer != nil {
		if err = conn.SetReadBuffer(service.readBuffer.(int)); err != nil {
			return err
		}
	}
	if service.writeBuffer != nil {
		if err = conn.SetWriteBuffer(service.writeBuffer.(int)); err != nil {
			return err
		}
	}
	if service.config != nil {
		tlsConn := tls.Server(conn, service.config)
		tlsConn.Handshake()
		return service.Serve(tlsConn)
	}
	return service.Serve(conn)
}
Example #20
0
func (s *SMTPClientSession) Handler() {
	defer s.Close()
	start := time.Now().UnixNano()
	for {
		switch s.state {
		case INIT:
			s.addResponse("220 protonuke: Less for outcasts, more for weirdos.")
			s.state = COMMANDS
		case COMMANDS:
			input, err := s.readSmtp()
			input = strings.Trim(input, "\r\n")
			cmd := strings.ToUpper(input)
			if err != nil {
				log.Debugln(err)
				return
			}
			switch {
			case strings.HasPrefix(cmd, "HELO"):
				s.addResponse("250 You're all so great and we're gonna keep you listening all day")
			case strings.HasPrefix(cmd, "EHLO"):
				r := "250-" + myFQDN + " Serving mail almost makes you wish for a nuclear winter\r\n"
				r += "250-8BITMIME\r\n250-STARTTLS\r\n250 HELP"
				s.addResponse(r)
			case strings.HasPrefix(cmd, "MAIL FROM:"):
				if len(input) > 10 {
					s.mail_from = input[10:]
				}
				s.addResponse("250 Ok")
			case strings.HasPrefix(cmd, "RCPT TO:"):
				if len(input) > 8 {
					s.rcpt_to = append(s.rcpt_to, input[8:])
				}
				s.addResponse("250 Ok")
			case strings.HasPrefix(cmd, "DATA"):
				s.addResponse("354 End data with <CR><LF>.<CR><LF>")
				s.state = DATA
			case strings.HasPrefix(cmd, "STARTTLS") && !s.tls_on:
				s.addResponse("220 They asked what do you know about theoretical physics? I said I had a theoretical degree in physics.")
				s.state = STARTTLS
			case strings.HasPrefix(cmd, "QUIT"):
				s.addResponse("221 Beware the Battle Cattle!")
				s.state = QUIT
			case strings.HasPrefix(cmd, "NOOP"):
				s.addResponse("250 Is it time?")
			case strings.HasPrefix(cmd, "RSET"):
				s.mail_from = ""
				s.rcpt_to = []string{}
				s.addResponse("250 I forgot to remember to forget")
			default:
				s.addResponse("500 unrecognized command")
			}
		case DATA:
			input, err := s.readSmtp()
			if err != nil {
				log.Debugln(err)
			}
			s.data = input
			log.Debugln("Got email message:")
			log.Debugln(s)
			s.addResponse("250 Ok: Now that is a delivery service you can count on")
			s.state = COMMANDS
		case STARTTLS:
			// I'm just going to pull this from GoGuerrilla, thanks guys
			var tlsConn *tls.Conn
			tlsConn = tls.Server(s.conn, TLSconfig)
			err := tlsConn.Handshake() // not necessary to call here, but might as well
			if err == nil {
				s.conn = net.Conn(tlsConn)
				s.bufin = bufio.NewReader(s.conn)
				s.bufout = bufio.NewWriter(s.conn)
				s.tls_on = true
			} else {
				log.Debugln("Could not TLS handshake:", err)
			}
			s.state = COMMANDS
		case QUIT:
			stop := time.Now().UnixNano()
			log.Info("smtp %v %vns", s.conn.RemoteAddr(), uint64(stop-start))
			return
		}
		size, _ := s.bufout.WriteString(s.response)
		s.bufout.Flush()
		s.response = s.response[size:]
	}
}
Example #21
0
// Kirisurf_handshake_client returns a socket obfuscating the socket sock after
// initiating the client-side handshake.
func Kiriobfs_handshake_client(sock net.Conn) (net.Conn, error) {
	// generate our keypair
	our_keypair := kicrypt.UniformDH_genpair()
	scatch := make(chan bool, 16)

	//send our key
	c, err := sock.Write(our_keypair.PublicBytes())
	LOG(LOG_DEBUG, "Sent our %d-byte key", c)
	if err != nil {
		return nil, errors.New("error encountered when sending uniformdh pubkey")
	}

	//send 16384 bytes of garbage
	go func() {
		for i := 0; i < 64; i++ {
			buf := make([]byte, 256)
			rand.Reader.Read(buf)
			c, err := sock.Write(buf)
			if err != nil && c == c {
				return
			}
		}
		scatch <- true
	}()

	// read their key
	buf := make([]byte, 192)
	_, ecd := io.ReadFull(sock, buf)
	if ecd != nil {
		return nil, ecd
	}
	LOG(LOG_DEBUG, "Read their %d-byte key", 192)
	theirpub := big.NewInt(0).SetBytes(buf)

	//read 16384 bytes of garbage from remote
	go func() {
		buf := make([]byte, 16384)
		_, err := io.ReadFull(sock, buf)
		if err != nil {
			return
		}
		scatch <- true
	}()

	//synchronize
	<-scatch
	<-scatch
	LOG(LOG_DEBUG, "All garbage-related things done.")

	//shared secret
	shared_secret := kicrypt.UniformDH_gensecret(our_keypair.Private, theirpub)
	up_key := kicrypt.KeyedHash(shared_secret, "kiriobfs/up")
	down_key := kicrypt.KeyedHash(shared_secret, "kiriobfs/down")
	LOG(LOG_DEBUG, "Shared secret derived.")

	//RC4 initialization
	var toret Kiriobfs_state
	toret.RC4_state_r, err = rc4.NewCipher(down_key)
	toret.RC4_state_w, err = rc4.NewCipher(up_key)
	toret.underlying = sock
	throwaway := make([]byte, 8192)
	toret.RC4_state_r.XORKeyStream(throwaway, throwaway)
	toret.RC4_state_w.XORKeyStream(throwaway, throwaway)

	//Actual garbage
	blarg := make([]byte, 2)
	rand.Reader.Read(blarg)
	bllen := big.NewInt(0).SetBytes(blarg).Int64()
	toret.Write(blarg)
	toret.Write(make([]byte, bllen))
	LOG(LOG_DEBUG, "Encrypted junk sent.")

	//Read the actual garbage
	glarg := make([]byte, 2)
	io.ReadFull(net.Conn(toret), glarg)
	glwerg := make([]byte, big.NewInt(0).SetBytes(glarg).Int64())
	io.ReadFull(net.Conn(toret), glwerg)
	return net.Conn(toret), nil
}
Example #22
0
func handleClient(client *Client) {
	defer closeClient(client)
	//	defer closeClient(client)
	greeting := "220 " + gConfig["GSMTP_HOST_NAME"] +
		" SMTP Guerrilla-SMTPd #" + strconv.FormatInt(client.clientId, 10) + " (" + strconv.Itoa(len(sem)) + ") " + time.Now().Format(time.RFC1123Z)
	advertiseTls := "250-STARTTLS\r\n"
	for i := 0; i < 100; i++ {
		switch client.state {
		case 0:
			responseAdd(client, greeting)
			client.state = 1
		case 1:
			input, err := readSmtp(client)
			if err != nil {
				logln(1, fmt.Sprintf("Read error: %v", err))
				if err == io.EOF {
					// client closed the connection already
					return
				}
				if neterr, ok := err.(net.Error); ok && neterr.Timeout() {
					// too slow, timeout
					return
				}
				break
			}
			input = strings.Trim(input, " \n\r")
			cmd := strings.ToUpper(input)
			switch {
			case strings.Index(cmd, "HELO") == 0:
				if len(input) > 5 {
					client.helo = input[5:]
				}
				responseAdd(client, "250 "+gConfig["GSMTP_HOST_NAME"]+" Hello ")
			case strings.Index(cmd, "EHLO") == 0:
				if len(input) > 5 {
					client.helo = input[5:]
				}
				responseAdd(client, "250-"+gConfig["GSMTP_HOST_NAME"]+" Hello "+client.helo+"["+client.address+"]"+"\r\n"+"250-SIZE "+gConfig["GSMTP_MAX_SIZE"]+"\r\n"+advertiseTls+"250 HELP")
			case strings.Index(cmd, "MAIL FROM:") == 0:
				if len(input) > 10 {
					client.mail_from = input[10:]
				}
				responseAdd(client, "250 Ok")
			case strings.Index(cmd, "XCLIENT") == 0:
				// Nginx sends this
				// XCLIENT ADDR=212.96.64.216 NAME=[UNAVAILABLE]
				client.address = input[13:]
				client.address = client.address[0:strings.Index(client.address, " ")]
				fmt.Println("client address:[" + client.address + "]")
				responseAdd(client, "250 OK")
			case strings.Index(cmd, "RCPT TO:") == 0:
				if len(input) > 8 {
					client.rcpt_to = input[8:]
				}
				responseAdd(client, "250 Accepted")
			case strings.Index(cmd, "NOOP") == 0:
				responseAdd(client, "250 OK")
			case strings.Index(cmd, "RSET") == 0:
				client.mail_from = ""
				client.rcpt_to = ""
				responseAdd(client, "250 OK")
			case strings.Index(cmd, "DATA") == 0:
				responseAdd(client, "354 Enter message, ending with \".\" on a line by itself")
				client.state = 2
			case (strings.Index(cmd, "STARTTLS") == 0) && !client.tls_on:
				responseAdd(client, "220 Ready to start TLS")
				// go to start TLS state
				client.state = 3
			case strings.Index(cmd, "QUIT") == 0:
				responseAdd(client, "221 Bye")
				killClient(client)
			default:
				responseAdd(client, fmt.Sprintf("500 unrecognized command"))
				client.errors++
				if client.errors > 3 {
					responseAdd(client, fmt.Sprintf("500 Too many unrecognized commands"))
					killClient(client)
				}
			}
		case 2:
			var err error
			client.data, err = readSmtp(client)
			if err == nil {
				// to do: timeout when adding to SaveMailChan
				// place on the channel so that one of the save mail workers can pick it up
				SaveMailChan <- client
				// wait for the save to complete
				status := <-client.savedNotify

				if status == 1 {
					responseAdd(client, "250 OK : queued as "+client.hash)
				} else {
					responseAdd(client, "554 Error: transaction failed, blame it on the weather")
				}
			} else {
				logln(1, fmt.Sprintf("DATA read error: %v", err))
			}
			client.state = 1
		case 3:
			// upgrade to TLS
			var tlsConn *tls.Conn
			tlsConn = tls.Server(client.conn, TLSconfig)
			err := tlsConn.Handshake() // not necessary to call here, but might as well
			if err == nil {
				client.conn = net.Conn(tlsConn)
				client.bufin = bufio.NewReader(client.conn)
				client.bufout = bufio.NewWriter(client.conn)
				client.tls_on = true
			} else {
				logln(1, fmt.Sprintf("Could not TLS handshake:%v", err))
			}
			advertiseTls = ""
			client.state = 1
		}
		// Send a response back to the client
		err := responseWrite(client)
		if err != nil {
			if err == io.EOF {
				// client closed the connection already
				return
			}
			if neterr, ok := err.(net.Error); ok && neterr.Timeout() {
				// too slow, timeout
				return
			}
		}
		if client.kill_time > 1 {
			return
		}
	}

}
Example #23
0
func main() {
	flag.Parse()
	checkDns = make(chan *dnsQueryReq)
	checkDnsRes = make(chan *dnsQueryBack)
	go dnsLoop()
	if *bShowVersion {
		fmt.Printf("%.2f\n", common.Version)
		return
	}
	if !*bVerbose {
		log.SetOutput(ioutil.Discard)
	}
	if *serveName == "" && *linkName == "" {
		println("you must assign reg or link")
		return
	}
	if *serveName != "" && *linkName != "" {
		println("you must assign reg or link, not both of them")
		return
	}
	if *localAddr == "" {
		println("you must assign the local addr")
		return
	}
	if *serveName != "" {
		clientType = 0
	} else {
		clientType = 1
	}
	if *bEncrypt {
		if clientType != 1 {
			println("only link size need encrypt")
			return
		}
	}
	go func() {
		c := make(chan os.Signal, 1)
		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
		n := 0
		for {
			<-c
			log.Println("received signal,shutdown")
			bForceQuit = true
			if remoteConn != nil {
				remoteConn.Close()
			}
			n++
			if n > 5 {
				log.Println("force shutdown")
				os.Exit(-1)
			}
		}
	}()

	loop := func() bool {
		if bForceQuit {
			return true
		}
		g_ClientMap = make(map[string]*Client)
		g_ClientMapKey = make(map[string]*cipher.Block)
		g_Id2UDPSession = make(map[string]*UDPMakeSession)
		//var err error
		if *bUseSSL {
			_remoteConn, err := tls.Dial("tcp", *serverAddr, &tls.Config{InsecureSkipVerify: true})
			if err != nil {
				println("connect remote err:" + err.Error())
				return false
			}
			remoteConn = net.Conn(_remoteConn)
		} else {
			_remoteConn, err := net.DialTimeout("tcp", *serverAddr, 10*time.Second)
			if err != nil {
				println("connect remote err:" + err.Error())
				return false
			}
			remoteConn = _remoteConn
		}
		println("connect to server succeed")
		go connect()
		q := make(chan bool)
		go func() {
			c := time.NewTicker(time.Second * 10)
		out:
			for {
				select {
				case <-c.C:
					if remoteConn != nil {
						common.Write(remoteConn, "-1", "ping", "")
					}
				case <-q:
					break out
				}
			}
			c.Stop()
		}()

		common.Read(remoteConn, handleResponse)
		q <- true
		for clientId, client := range g_ClientMap {
			log.Println("client shutdown", clientId)
			client.Quit()
		}

		if remoteConn != nil {
			remoteConn.Close()
		}
		if bForceQuit {
			return true
		}
		return false
	}
	if clientType == 0 {
		for {
			if loop() {
				break
			}
			time.Sleep(10 * time.Second)
		}
	} else {
		loop()
	}
	log.Println("service shutdown")
}
Example #24
0
func main() {
	flag.Usage = Usage
	flag.Parse()

	args := flag.Args()

	if len(args) < 2 {
		flag.Usage()
		os.Exit(1)
	}

	jr := NewJobRequest()
	jr.Op = "queue"
	jr.Score = args[0]
	if *AllOf {
		jr.Scope = "all"
	} else {
		jr.Scope = "one"
	}

	var k int
	for k = 1; k < len(args); k++ {
		if args[k] == "!" {
			break
		}
		insertionpoint := 0
		if nil == jr.Players {
			jr.Players = make([]string, 1)
		} else {
			insertionpoint = len(jr.Players)
			newplayers := make([]string, insertionpoint+1)
			copy(newplayers, jr.Players)
			jr.Players = newplayers
		}
		jr.Players[insertionpoint] = args[k]
	}
	if k < len(args) {
		// skip the !
		k++
		if (len(args)-(k))%2 != 0 {
			fmt.Fprintf(os.Stderr, "Error: Odd number of param arguments.\n")
			os.Exit(1)
		}
		for ; k < len(args); k += 2 {
			jr.Params[args[k]] = args[k+1]
		}
	}

	raddr, err := net.ResolveUnixAddr("unix", *AudienceSock)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to resolve sockaddr: %s\n", err)
		os.Exit(1)
	}
	conn, err := net.DialUnix("unix", nil, raddr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to connect to sockaddr: %s\n", err)
		os.Exit(1)
	}

	defer conn.Close()

	nc := net.Conn(conn)

	r, _ := nc.(io.Reader)
	w, _ := nc.(io.Writer)

	dec := json.NewDecoder(r)
	enc := json.NewEncoder(w)

	// send the message
	err = enc.Encode(jr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to marshal & send: %s\n", err)
		os.Exit(1)
	}

	response := new([2]interface{})
	err = dec.Decode(response)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error decoding response: %s\n", err)
		os.Exit(1)
	}
	// coerce field 0 back into a string.
	rerr, ok := response[0].(string)
	if ok {
		if rerr == "OK" {
			// all OK!  get the JobID
			jobid, _ := response[1].(float64)
			fmt.Printf("%d\n", uint64(jobid))
			os.Exit(0)
		} else {
			fmt.Fprintf(os.Stderr, "Server Error: %s\n", rerr)
			os.Exit(1)
		}
	} else {
		fmt.Fprintf(os.Stderr, "Couldn't unmarshal response correctly.\n")
		os.Exit(1)
	}
}
Example #25
0
func (server *TcpServer) handle() (err error) {
	defer func() {
		if e := recover(); e != nil && err == nil {
			err = fmt.Errorf("%v", e)
		}
	}()
	if server.listener == nil {
		return nil
	}
	var conn *net.TCPConn
	if conn, err = server.listener.AcceptTCP(); err != nil {
		return err
	}
	if server.keepAlive != nil {
		if err = conn.SetKeepAlive(server.keepAlive.(bool)); err != nil {
			return err
		}
	}
	if server.keepAlivePeriod != nil {
		if kap, ok := (net.Conn(conn)).(iKeepAlivePeriod); ok {
			if err = kap.SetKeepAlivePeriod(server.keepAlivePeriod.(time.Duration)); err != nil {
				return err
			}
		}
	}
	if server.linger != nil {
		if err = conn.SetLinger(server.linger.(int)); err != nil {
			return err
		}
	}
	if server.noDelay != nil {
		if err = conn.SetNoDelay(server.noDelay.(bool)); err != nil {
			return err
		}
	}
	if server.readBuffer != nil {
		if err = conn.SetReadBuffer(server.readBuffer.(int)); err != nil {
			return err
		}
	}
	if server.writerBuffer != nil {
		if err = conn.SetWriteBuffer(server.writerBuffer.(int)); err != nil {
			return err
		}
	}
	if server.deadline != nil {
		if err = conn.SetDeadline(server.deadline.(time.Time)); err != nil {
			return err
		}
	}
	if server.readDeadline != nil {
		if err = conn.SetReadDeadline(server.readDeadline.(time.Time)); err != nil {
			return err
		}
	}
	if server.writerDeadline != nil {
		if err = conn.SetWriteDeadline(server.writerDeadline.(time.Time)); err != nil {
			return err
		}
	}
	if server.config != nil {
		server.ServeTCP(tls.Client(conn, server.config))
	} else {
		server.ServeTCP(conn)
	}
	return nil
}
Example #26
0
func (l listener) close() error {
	net.Conn(l.conn).Close()
	return os.RemoveAll(l.tempDir)
}
Example #27
0
func (service *TcpService) ServeTCP(conn *net.TCPConn) (err error) {
	if service.keepAlive != nil {
		if err = conn.SetKeepAlive(service.keepAlive.(bool)); err != nil {
			return err
		}
	}
	if service.keepAlivePeriod != nil {
		if kap, ok := (net.Conn(conn)).(iKeepAlivePeriod); ok {
			if err = kap.SetKeepAlivePeriod(service.keepAlivePeriod.(time.Duration)); err != nil {
				return err
			}
		}
	}
	if service.linger != nil {
		if err = conn.SetLinger(service.linger.(int)); err != nil {
			return err
		}
	}
	if service.noDelay != nil {
		if err = conn.SetNoDelay(service.noDelay.(bool)); err != nil {
			return err
		}
	}
	if service.readBuffer != nil {
		if err = conn.SetReadBuffer(service.readBuffer.(int)); err != nil {
			return err
		}
	}
	if service.writeBuffer != nil {
		if err = conn.SetWriteBuffer(service.writeBuffer.(int)); err != nil {
			return err
		}
	}
	if service.timeout != nil {
		if err = conn.SetDeadline(time.Now().Add(service.timeout.(time.Duration))); err != nil {
			return err
		}
	}
	go func(conn net.Conn) {
		if service.config != nil {
			tlsConn := tls.Server(conn, service.config)
			tlsConn.Handshake()
			conn = tlsConn
		}
		var data []byte
		var err error
		for {
			if service.readTimeout != nil {
				err = conn.SetReadDeadline(time.Now().Add(service.readTimeout.(time.Duration)))
			}
			if err == nil {
				data, err = receiveDataOverTcp(conn)
			}
			if err == nil {
				data = service.Handle(data, conn)
				if service.writeTimeout != nil {
					err = conn.SetWriteDeadline(time.Now().Add(service.writeTimeout.(time.Duration)))
				}
				if err == nil {
					err = sendDataOverTcp(conn, data)
				}
			}
			if err != nil {
				conn.Close()
				break
			}
		}
	}(conn)
	return nil
}
Example #28
0
func main() {
	flag.Usage = Usage
	flag.Parse()

	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(1)
	}

	sr := NewStatusRequest()
	var err error
	sr.Id, err = strconv.ParseUint(flag.Arg(0), 10, 64)
	if nil != err {
		fmt.Fprintf(os.Stderr, "Failed to parse JobID: %s\n", err)
		os.Exit(1)
	}

	raddr, err := net.ResolveUnixAddr("unix", *AudienceSock)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to resolve sockaddr: %s\n", err)
		os.Exit(1)
	}
	conn, err := net.DialUnix("unix", nil, raddr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to connect to sockaddr: %s\n", err)
		os.Exit(1)
	}

	defer conn.Close()

	nc := net.Conn(conn)

	r, _ := nc.(io.Reader)
	w, _ := nc.(io.Writer)

	dec := json.NewDecoder(r)
	enc := json.NewEncoder(w)

	// send the message
	err = enc.Encode(sr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to marshal & send: %s\n", err)
		os.Exit(1)
	}

	response := new([2]interface{})
	sresp := new(StatusResponse)
	response[1] = sresp
	err = dec.Decode(response)
	if err != nil {
		// OK, the problem here is that an in the request will throw a null in the second field.
		// This will cause Decode to softfault.  We'll ignore these softfaults.
		utye, ok := err.(*json.UnmarshalTypeError)
		if ok {
			fmt.Fprintf(os.Stderr, "Unmarshalling error: %s of Type %s\n", utye.Value, utye.Type)
		} else {
			ufe, ok := err.(*json.UnmarshalFieldError)
			if ok {
				fmt.Fprintf(os.Stderr, "Error decoding response: UFE %s of Type %s\n", ufe.Key, ufe.Type)
				os.Exit(1)
			}
			ute, ok := err.(*json.UnsupportedTypeError)
			if ok {
				fmt.Fprintf(os.Stderr, "Error decoding response: UTE of Type %s\n", ute.Type)
				os.Exit(1)
			}

			fmt.Fprintf(os.Stderr, "Error decoding response: %s\n", err)
			os.Exit(1)
		}
	}

	// coerce field 0 back into a string.
	rerr, ok := response[0].(string)
	if ok {
		if rerr == "OK" {
			// all OK, process the sresp.
			fmt.Printf("Aggregate: %s\n", *sresp.Status)
			os.Exit(0)
		} else {
			fmt.Fprintf(os.Stderr, "Server Error: %s\n", rerr)
			os.Exit(1)
		}
	} else {
		fmt.Fprintf(os.Stderr, "Couldn't unmarshal response correctly.\n")
		os.Exit(1)
	}
}
Example #29
0
// Check executes a TCP healthcheck.
func (hc *TCPChecker) Check(timeout time.Duration) *Result {
	msg := fmt.Sprintf("TCP connect to %s", hc.addr())
	start := time.Now()
	if timeout == time.Duration(0) {
		timeout = defaultTCPTimeout
	}
	deadline := start.Add(timeout)

	tcpConn, err := dialTCP(hc.network(), hc.addr(), timeout, hc.Mark)
	if err != nil {
		msg = fmt.Sprintf("%s; failed to connect", msg)
		return complete(start, msg, false, err)
	}
	conn := net.Conn(tcpConn)
	defer conn.Close()

	// Negotiate TLS if this is required.
	if hc.Secure {
		// TODO(jsing): We probably should allow the server name to
		// be specified via configuration...
		host, _, err := net.SplitHostPort(hc.addr())
		if err != nil {
			msg = msg + "; failed to split host"
			return complete(start, msg, false, err)
		}
		tlsConfig := &tls.Config{
			InsecureSkipVerify: !hc.TLSVerify,
			ServerName:         host,
		}
		tlsConn := tls.Client(conn, tlsConfig)
		if err := tlsConn.Handshake(); err != nil {
			return complete(start, msg, false, err)
		}
		conn = tlsConn
	}

	if hc.Send == "" && hc.Receive == "" {
		return complete(start, msg, true, err)
	}

	err = conn.SetDeadline(deadline)
	if err != nil {
		msg = fmt.Sprintf("%s; failed to set deadline", msg)
		return complete(start, msg, false, err)
	}

	if hc.Send != "" {
		err = writeFull(conn, []byte(hc.Send))
		if err != nil {
			msg = fmt.Sprintf("%s; failed to send request", msg)
			return complete(start, msg, false, err)
		}
	}

	if hc.Receive != "" {
		buf := make([]byte, len(hc.Receive))
		n, err := io.ReadFull(conn, buf)
		if err != nil {
			msg = fmt.Sprintf("%s; failed to read response", msg)
			return complete(start, msg, false, err)
		}
		got := string(buf[0:n])
		if got != hc.Receive {
			msg = fmt.Sprintf("%s; unexpected response - %q", msg, got)
			return complete(start, msg, false, err)
		}
	}
	return complete(start, msg, true, err)
}
Example #30
0
func (a *netListenerAdaptor) Accept() (net.Conn, error) {
	str, err := a.Session.Accept()
	return net.Conn(str), err
}