← Back to branch summary

~ubuntu-branches/ubuntu/saucy/golang/saucy

« back to all changes in this revision

Viewing changes to src/pkg/encoding/pem/pem.go

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-07-08 05:52:37 UTC
  • mfrom: (29.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130708055237-at01839e0hp8z3ni
Tags: 2:1.1-1ubuntu1
016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/encoding/pem/pem.go
11
11
        "bytes"
12
12
        "encoding/base64"
13
13
        "io"
 
14
        "sort"
14
15
)
15
16
 
16
17
// A Block represents a PEM encoded structure.
209
210
        return
210
211
}
211
212
 
212
 
func Encode(out io.Writer, b *Block) (err error) {
213
 
        _, err = out.Write(pemStart[1:])
214
 
        if err != nil {
215
 
                return
 
213
func writeHeader(out io.Writer, k, v string) error {
 
214
        _, err := out.Write([]byte(k + ": " + v + "\n"))
 
215
        return err
 
216
}
 
217
 
 
218
func Encode(out io.Writer, b *Block) error {
 
219
        if _, err := out.Write(pemStart[1:]); err != nil {
 
220
                return err
216
221
        }
217
 
        _, err = out.Write([]byte(b.Type + "-----\n"))
218
 
        if err != nil {
219
 
                return
 
222
        if _, err := out.Write([]byte(b.Type + "-----\n")); err != nil {
 
223
                return err
220
224
        }
221
225
 
222
226
        if len(b.Headers) > 0 {
223
 
                for k, v := range b.Headers {
224
 
                        _, err = out.Write([]byte(k + ": " + v + "\n"))
225
 
                        if err != nil {
226
 
                                return
227
 
                        }
228
 
                }
229
 
                _, err = out.Write([]byte{'\n'})
230
 
                if err != nil {
231
 
                        return
 
227
                const procType = "Proc-Type"
 
228
                h := make([]string, 0, len(b.Headers))
 
229
                hasProcType := false
 
230
                for k := range b.Headers {
 
231
                        if k == procType {
 
232
                                hasProcType = true
 
233
                                continue
 
234
                        }
 
235
                        h = append(h, k)
 
236
                }
 
237
                // The Proc-Type header must be written first.
 
238
                // See RFC 1421, section 4.6.1.1
 
239
                if hasProcType {
 
240
                        if err := writeHeader(out, procType, b.Headers[procType]); err != nil {
 
241
                                return err
 
242
                        }
 
243
                }
 
244
                // For consistency of output, write other headers sorted by key.
 
245
                sort.Strings(h)
 
246
                for _, k := range h {
 
247
                        if err := writeHeader(out, k, b.Headers[k]); err != nil {
 
248
                                return err
 
249
                        }
 
250
                }
 
251
                if _, err := out.Write([]byte{'\n'}); err != nil {
 
252
                        return err
232
253
                }
233
254
        }
234
255
 
236
257
        breaker.out = out
237
258
 
238
259
        b64 := base64.NewEncoder(base64.StdEncoding, &breaker)
239
 
        _, err = b64.Write(b.Bytes)
240
 
        if err != nil {
241
 
                return
 
260
        if _, err := b64.Write(b.Bytes); err != nil {
 
261
                return err
242
262
        }
243
263
        b64.Close()
244
264
        breaker.Close()
245
265
 
246
 
        _, err = out.Write(pemEnd[1:])
247
 
        if err != nil {
248
 
                return
 
266
        if _, err := out.Write(pemEnd[1:]); err != nil {
 
267
                return err
249
268
        }
250
 
        _, err = out.Write([]byte(b.Type + "-----\n"))
251
 
        return
 
269
        _, err := out.Write([]byte(b.Type + "-----\n"))
 
270
        return err
252
271
}
253
272
 
254
273
func EncodeToMemory(b *Block) []byte {