Subversion Repositories openrisc

// Copyright 2010 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.

// 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.
//
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.ReadDotAll()
//      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
}