crypto/tls (part 4/5)
R=rsc
CC=go-dev
http://go/go-review/1019002
diff --git a/src/pkg/crypto/tls/Makefile b/src/pkg/crypto/tls/Makefile
new file mode 100644
index 0000000..dd3df29
--- /dev/null
+++ b/src/pkg/crypto/tls/Makefile
@@ -0,0 +1,19 @@
+# Copyright 2009 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+include $(GOROOT)/src/Make.$(GOARCH)
+
+TARG=crypto/tls
+GOFILES=\
+ alert.go\
+ common.go\
+ handshake_messages.go\
+ handshake_server.go\
+ prf.go\
+ record_process.go\
+ record_read.go\
+ record_write.go\
+ tls.go\
+
+include $(GOROOT)/src/Make.pkg
diff --git a/src/pkg/crypto/tls/tls.go b/src/pkg/crypto/tls/tls.go
new file mode 100644
index 0000000..13d8fd7
--- /dev/null
+++ b/src/pkg/crypto/tls/tls.go
@@ -0,0 +1,172 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This package partially implements the TLS 1.1 protocol, as specified in RFC 4346.
+package tls
+
+import (
+ "bytes";
+ "io";
+ "os";
+ "net";
+ "time";
+)
+
+// A Conn represents a secure connection.
+type Conn struct {
+ net.Conn;
+ writeChan chan<- []byte;
+ readChan <-chan []byte;
+ requestChan chan<- interface{};
+ readBuf []byte;
+ eof bool;
+ readTimeout, writeTimeout int64;
+}
+
+func timeout(c chan<- bool, nsecs int64) {
+ time.Sleep(nsecs);
+ c <- true;
+}
+
+func (tls *Conn) Read(p []byte) (int, os.Error) {
+ if len(tls.readBuf) == 0 {
+ if tls.eof {
+ return 0, os.EOF;
+ }
+
+ var timeoutChan chan bool;
+ if tls.readTimeout > 0 {
+ timeoutChan = make(chan bool);
+ go timeout(timeoutChan, tls.readTimeout);
+ }
+
+ select {
+ case b := <-tls.readChan:
+ tls.readBuf = b;
+ case <-timeoutChan:
+ return 0, os.EAGAIN;
+ }
+
+ // TLS distinguishes between orderly closes and truncations. An
+ // orderly close is represented by a zero length slice.
+ if closed(tls.readChan) {
+ return 0, io.ErrUnexpectedEOF;
+ }
+ if len(tls.readBuf) == 0 {
+ tls.eof = true;
+ return 0, os.EOF;
+ }
+ }
+
+ n := bytes.Copy(p, tls.readBuf);
+ tls.readBuf = tls.readBuf[n:len(tls.readBuf)];
+ return n, nil;
+}
+
+func (tls *Conn) Write(p []byte) (int, os.Error) {
+ if tls.eof || closed(tls.readChan) {
+ return 0, os.EOF;
+ }
+
+ var timeoutChan chan bool;
+ if tls.writeTimeout > 0 {
+ timeoutChan = make(chan bool);
+ go timeout(timeoutChan, tls.writeTimeout);
+ }
+
+ select {
+ case tls.writeChan <- p:
+ case <-timeoutChan:
+ return 0, os.EAGAIN;
+ }
+
+ return len(p), nil;
+}
+
+func (tls *Conn) Close() os.Error {
+ close(tls.writeChan);
+ close(tls.requestChan);
+ tls.eof = true;
+ return nil;
+}
+
+func (tls *Conn) SetTimeout(nsec int64) os.Error {
+ tls.readTimeout = nsec;
+ tls.writeTimeout = nsec;
+ return nil;
+}
+
+func (tls *Conn) SetReadTimeout(nsec int64) os.Error {
+ tls.readTimeout = nsec;
+ return nil;
+}
+
+func (tls *Conn) SetWriteTimeout(nsec int64) os.Error {
+ tls.writeTimeout = nsec;
+ return nil;
+}
+
+func (tls *Conn) GetConnectionState() ConnectionState {
+ replyChan := make(chan ConnectionState);
+ tls.requestChan <- getConnectionState{replyChan};
+ return <-replyChan;
+}
+
+// Server establishes a secure connection over the given connection and acts
+// as a TLS server.
+func Server(conn net.Conn, config *Config) *Conn {
+ tls := new(Conn);
+ tls.Conn = conn;
+
+ writeChan := make(chan []byte);
+ readChan := make(chan []byte);
+ requestChan := make(chan interface{});
+
+ tls.writeChan = writeChan;
+ tls.readChan = readChan;
+ tls.requestChan = requestChan;
+
+ handshakeWriterChan := make(chan interface{});
+ processorHandshakeChan := make(chan interface{});
+ handshakeProcessorChan := make(chan interface{});
+ readerProcessorChan := make(chan *record);
+
+ go new(recordWriter).loop(conn, writeChan, handshakeWriterChan);
+ go recordReader(readerProcessorChan, conn);
+ go new(recordProcessor).loop(readChan, requestChan, handshakeProcessorChan, readerProcessorChan, processorHandshakeChan);
+ go new(serverHandshake).loop(handshakeWriterChan, handshakeProcessorChan, processorHandshakeChan, config);
+
+ return tls;
+}
+
+type Listener struct {
+ listener net.Listener;
+ config *Config;
+}
+
+func (l Listener) Accept() (c net.Conn, err os.Error) {
+ c, err = l.listener.Accept();
+ if err != nil {
+ return;
+ }
+
+ c = Server(c, l.config);
+ return;
+}
+
+func (l Listener) Close() os.Error {
+ return l.listener.Close();
+}
+
+func (l Listener) Addr() net.Addr {
+ return l.listener.Addr();
+}
+
+// NewListener creates a Listener which accepts connections from an inner
+// Listener and wraps each connection with Server.
+func NewListener(listener net.Listener, config *Config) (l Listener) {
+ l.listener = listener;
+ l.config = config;
+ return;
+}
