Source: textproto.go in package net/textproto

Package textproto implements generic support for text-based request/response protocols in the style of HTTP, NNTP, and SMTP. The package provides: Error, which represents a numeric error response from a server. Pipeline, to manage pipelined requests and responses in a client. Reader, to read numeric response code lines, key: value headers, lines wrapped with leading spaces on continuation lines, and whole text blocks ending with a dot on a line by itself. Writer, to write dot-encoded text blocks. Conn, a convenient packaging of Reader, Writer, and Pipeline for use with a single network connection.

package textproto

import (
	"bufio"
	"fmt"
	"io"
	"net"
)

An Error represents a numeric error response from a server.

type Error struct {
	Code int
	Msg  string
}

func (e *Error) Error() string {
	return fmt.Sprintf("%03d %s", e.Code, e.Msg)
}

A ProtocolError describes a protocol violation such as an invalid response or a hung-up connection.

type ProtocolError string

func (p ProtocolError) Error() string {
	return string(p)
}

A Conn represents a textual network protocol connection. It consists of a Reader and Writer to manage I/O and a Pipeline to sequence concurrent requests on the connection. These embedded types carry methods with them; see the documentation of those types for details.

type Conn struct {
	Reader
	Writer
	Pipeline
	conn io.ReadWriteCloser
}

NewConn returns a new Conn using conn for I/O.

func NewConn(conn io.ReadWriteCloser) *Conn {
	return &Conn{
		Reader: Reader{R: bufio.NewReader(conn)},
		Writer: Writer{W: bufio.NewWriter(conn)},
		conn:   conn,
	}
}

Close closes the connection.

func (c *Conn) Close() error {
	return c.conn.Close()
}

Dial connects to the given address on the given network using net.Dial and then returns a new Conn for the connection.

func Dial(network, addr string) (*Conn, error) {
	c, err := net.Dial(network, addr)
	if err != nil {
		return nil, err
	}
	return NewConn(c), nil
}

Cmd is a convenience method that sends a command after waiting its turn in the pipeline. The command text is the result of formatting format with args and appending \r\n. Cmd returns the id of the command, for use with StartResponse and EndResponse. For example, a client might run a HELP command that returns a dot-body by using: id, err := c.Cmd("HELP") if err != nil { return nil, err } c.StartResponse(id) defer c.EndResponse(id) if _, _, err = c.ReadCodeLine(110); err != nil { return nil, err } text, err := c.ReadDotBytes() if err != nil { return nil, err } return c.ReadCodeLine(250)

func (c *Conn) Cmd(format string, args ...interface{}) (id uint, err error) {
	id = c.Next()
	c.StartRequest(id)
	err = c.PrintfLine(format, args...)
	c.EndRequest(id)
	if err != nil {
		return 0, err
	}
	return id, nil
}

TrimString returns s without leading and trailing ASCII space.

func TrimString(s string) string {
	for len(s) > 0 && isASCIISpace(s[0]) {
		s = s[1:]
	}
	for len(s) > 0 && isASCIISpace(s[len(s)-1]) {
		s = s[:len(s)-1]
	}
	return s
}

TrimBytes returns b without leading and trailing ASCII space.

func TrimBytes(b []byte) []byte {
	for len(b) > 0 && isASCIISpace(b[0]) {
		b = b[1:]
	}
	for len(b) > 0 && isASCIISpace(b[len(b)-1]) {
		b = b[:len(b)-1]
	}
	return b
}

func isASCIISpace(b byte) bool {
	return b == ' ' || b == '\t' || b == '\n' || b == '\r'
}

func isASCIILetter(b byte) bool {
	b |= 0x20 // make lower case
	return 'a' <= b && b <= 'z'