writer.go

Documentation: mime/quotedprintable

		 1  // Copyright 2015 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package quotedprintable
		 6  
		 7  import "io"
		 8  
		 9  const lineMaxLen = 76
		10  
		11  // A Writer is a quoted-printable writer that implements io.WriteCloser.
		12  type Writer struct {
		13  	// Binary mode treats the writer's input as pure binary and processes end of
		14  	// line bytes as binary data.
		15  	Binary bool
		16  
		17  	w		io.Writer
		18  	i		int
		19  	line [78]byte
		20  	cr	 bool
		21  }
		22  
		23  // NewWriter returns a new Writer that writes to w.
		24  func NewWriter(w io.Writer) *Writer {
		25  	return &Writer{w: w}
		26  }
		27  
		28  // Write encodes p using quoted-printable encoding and writes it to the
		29  // underlying io.Writer. It limits line length to 76 characters. The encoded
		30  // bytes are not necessarily flushed until the Writer is closed.
		31  func (w *Writer) Write(p []byte) (n int, err error) {
		32  	for i, b := range p {
		33  		switch {
		34  		// Simple writes are done in batch.
		35  		case b >= '!' && b <= '~' && b != '=':
		36  			continue
		37  		case isWhitespace(b) || !w.Binary && (b == '\n' || b == '\r'):
		38  			continue
		39  		}
		40  
		41  		if i > n {
		42  			if err := w.write(p[n:i]); err != nil {
		43  				return n, err
		44  			}
		45  			n = i
		46  		}
		47  
		48  		if err := w.encode(b); err != nil {
		49  			return n, err
		50  		}
		51  		n++
		52  	}
		53  
		54  	if n == len(p) {
		55  		return n, nil
		56  	}
		57  
		58  	if err := w.write(p[n:]); err != nil {
		59  		return n, err
		60  	}
		61  
		62  	return len(p), nil
		63  }
		64  
		65  // Close closes the Writer, flushing any unwritten data to the underlying
		66  // io.Writer, but does not close the underlying io.Writer.
		67  func (w *Writer) Close() error {
		68  	if err := w.checkLastByte(); err != nil {
		69  		return err
		70  	}
		71  
		72  	return w.flush()
		73  }
		74  
		75  // write limits text encoded in quoted-printable to 76 characters per line.
		76  func (w *Writer) write(p []byte) error {
		77  	for _, b := range p {
		78  		if b == '\n' || b == '\r' {
		79  			// If the previous byte was \r, the CRLF has already been inserted.
		80  			if w.cr && b == '\n' {
		81  				w.cr = false
		82  				continue
		83  			}
		84  
		85  			if b == '\r' {
		86  				w.cr = true
		87  			}
		88  
		89  			if err := w.checkLastByte(); err != nil {
		90  				return err
		91  			}
		92  			if err := w.insertCRLF(); err != nil {
		93  				return err
		94  			}
		95  			continue
		96  		}
		97  
		98  		if w.i == lineMaxLen-1 {
		99  			if err := w.insertSoftLineBreak(); err != nil {
	 100  				return err
	 101  			}
	 102  		}
	 103  
	 104  		w.line[w.i] = b
	 105  		w.i++
	 106  		w.cr = false
	 107  	}
	 108  
	 109  	return nil
	 110  }
	 111  
	 112  func (w *Writer) encode(b byte) error {
	 113  	if lineMaxLen-1-w.i < 3 {
	 114  		if err := w.insertSoftLineBreak(); err != nil {
	 115  			return err
	 116  		}
	 117  	}
	 118  
	 119  	w.line[w.i] = '='
	 120  	w.line[w.i+1] = upperhex[b>>4]
	 121  	w.line[w.i+2] = upperhex[b&0x0f]
	 122  	w.i += 3
	 123  
	 124  	return nil
	 125  }
	 126  
	 127  const upperhex = "0123456789ABCDEF"
	 128  
	 129  // checkLastByte encodes the last buffered byte if it is a space or a tab.
	 130  func (w *Writer) checkLastByte() error {
	 131  	if w.i == 0 {
	 132  		return nil
	 133  	}
	 134  
	 135  	b := w.line[w.i-1]
	 136  	if isWhitespace(b) {
	 137  		w.i--
	 138  		if err := w.encode(b); err != nil {
	 139  			return err
	 140  		}
	 141  	}
	 142  
	 143  	return nil
	 144  }
	 145  
	 146  func (w *Writer) insertSoftLineBreak() error {
	 147  	w.line[w.i] = '='
	 148  	w.i++
	 149  
	 150  	return w.insertCRLF()
	 151  }
	 152  
	 153  func (w *Writer) insertCRLF() error {
	 154  	w.line[w.i] = '\r'
	 155  	w.line[w.i+1] = '\n'
	 156  	w.i += 2
	 157  
	 158  	return w.flush()
	 159  }
	 160  
	 161  func (w *Writer) flush() error {
	 162  	if _, err := w.w.Write(w.line[:w.i]); err != nil {
	 163  		return err
	 164  	}
	 165  
	 166  	w.i = 0
	 167  	return nil
	 168  }
	 169  
	 170  func isWhitespace(b byte) bool {
	 171  	return b == ' ' || b == '\t'
	 172  }
	 173
View as plain text