libgo/go/mime/quotedprintable/writer.go

   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 }