maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore(3p/lisp): import mime4cl source tarball

Browse source 
Used http://wcp.sdf-eu.org/software/mime4cl-20150207T211851.tbz (sha256
5a914669bba7561efe59a4fd0817204c07ad2add98b03ae206ef185ac04affb3).
Importing seems sensible since there's no upstream repo nor has their
been a release since 2015.

This is just an import commit, so the changes made to make it build are
more discoverable as their own commit.

Change-Id: I2ff28c3c7433abdf7857204bc89eaf9edc0b1cbc
Reviewed-on: https://cl.tvl.fyi/c/depot/+/3378
Tested-by: BuildkiteCI
Reviewed-by: grfn <grfn@gws.fyi>
This commit is contained in:
sterni 2021-08-21 15:29:43 +02:00
parent de0f0164d2
commit 901364869c
13 changed files with 3313 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

124
third_party/lisp/mime4cl/test/address.lisp vendored Normal file
View file

@ -0,0 +1,124 @@
;;; address.lisp --- tests for the e-mail address parser
;;; Copyright (C) 2007, 2009 by Walter C. Pelissero
;;; Author: Walter C. Pelissero <walter@pelissero.de>
;;; Project: mime4cl
#+cmu (ext:file-comment "$Module: address.lisp $")
;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Lesser General Public License
;;; as published by the Free Software Foundation; either version 2.1
;;; of the License, or (at your option) any later version.
;;; This library is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;;; Lesser General Public License for more details.
;;; You should have received a copy of the GNU Lesser General Public
;;; License along with this library; if not, write to the Free
;;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
;;; 02111-1307 USA
(in-package :mime4cl-tests)
(defun test-parsing (string)
(format nil "~{~A~^, ~}" (parse-addresses string)))
(deftest address-parse-simple.1
(test-parsing "foo@bar")
"foo@bar")
(deftest address-parse-simple.2
(test-parsing "foo@bar.com")
"foo@bar.com")
(deftest address-parse-simple.3
(test-parsing "foo@bar.baz.com")
"foo@bar.baz.com")
(deftest address-parse-simple.4
(test-parsing "foo.ooo@bar.baz.com")
"foo.ooo@bar.baz.com")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(deftest address-parse-simple-commented.1
(test-parsing "foo@bar (Some Comment)")
"\"Some Comment\" <foo@bar>")
(deftest address-parse-simple-commented.2
(test-parsing "foo@bar (Some, Comment)")
"\"Some, Comment\" <foo@bar>")
(deftest address-parse-simple-commented.3
(test-parsing "foo@bar (Some Comment (yes, indeed))")
"\"Some Comment (yes, indeed)\" <foo@bar>")
(deftest address-parse-simple-commented.4
(test-parsing "foo.bar@host.complicated.domain.net (Some Comment (yes, indeed))")
"\"Some Comment (yes, indeed)\" <foo.bar@host.complicated.domain.net>")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(deftest address-parse-angle.1
(test-parsing "<foo@bar.baz.net>")
"foo@bar.baz.net")
(deftest address-parse-angle.2
(test-parsing "My far far friend <foo@bar.baz.net>")
"\"My far far friend\" <foo@bar.baz.net>")
(deftest address-parse-angle.3
(test-parsing "\"someone, I don't like\" <foo@bar.baz.net>")
"\"someone, I don't like\" <foo@bar.baz.net>")
(deftest address-parse-angle.4
(test-parsing "\"this could (be a comment)\" <foo@bar.net>")
"\"this could (be a comment)\" <foo@bar.net>")
(deftest address-parse-angle.5
(test-parsing "don't be fooled <foo@bar.net>")
"\"don't be fooled\" <foo@bar.net>")
(deftest address-parse-angle.6
(test-parsing "<foo@bar>")
"foo@bar")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(deftest address-parse-domain-literal.1
(test-parsing "<foo@[bar]>")
"foo@[bar]")
(deftest address-parse-domain-literal.2
(test-parsing "<foo@[bar.net]>")
"foo@[bar.net]")
(deftest address-parse-domain-literal.3
(test-parsing "<foo@[10.0.0.2]>")
"foo@[10.0.0.2]")
(deftest address-parse-domain-literal.4
(test-parsing "<foo.bar@[10.0.0.2]>")
"foo.bar@[10.0.0.2]")
(deftest address-parse-domain-literal.5
(test-parsing "somewhere unkown <foo.bar@[10.0.0.2]>")
"\"somewhere unkown\" <foo.bar@[10.0.0.2]>")
(deftest address-parse-domain-literal.6
(test-parsing "\"Some--One\" <foo.bar@[10.0.0.23]>")
"\"Some--One\" <foo.bar@[10.0.0.23]>")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(deftest address-parse-group.1
(test-parsing "friends:john@bar.in.soho, jack@pub.round.the.corner, jim@[10.0.1.2];")
"friends: john@bar.in.soho, jack@pub.round.the.corner, jim@[10.0.1.2];")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(deftest address-parse-mixed.1
(test-parsing "Foo BAR <foo@bar.com>, \"John, Smith (that one!)\" <john.smith@host.domain.org>, friends:john@bar,jack@pub;, foo.bar.baz@wow.mail.mine, dont.bark@me (Fierce Dog)")
"\"Foo BAR\" <foo@bar.com>, \"John, Smith (that one!)\" <john.smith@host.domain.org>, friends: john@bar, jack@pub;, foo.bar.baz@wow.mail.mine, \"Fierce Dog\" <dont.bark@me>")

167
third_party/lisp/mime4cl/test/endec.lisp vendored Normal file
View file

@ -0,0 +1,167 @@
;;; endec.lisp --- test suite for the MIME encoder/decoder functions
;;; Copyright (C) 2006, 2007, 2009, 2010 by Walter C. Pelissero
;;; Author: Walter C. Pelissero <walter@pelissero.de>
;;; Project: mime4cl
#+cmu (ext:file-comment "$Module: endec.lisp $")
;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Lesser General Public License
;;; as published by the Free Software Foundation; either version 2.1
;;; of the License, or (at your option) any later version.
;;; This library is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;;; Lesser General Public License for more details.
;;; You should have received a copy of the GNU Lesser General Public
;;; License along with this library; if not, write to the Free
;;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
;;; 02111-1307 USA
(in-package :mime4cl-tests)
(deftest quoted-printable.1
(encode-quoted-printable-sequence (map '(vector (unsigned-byte 8)) #'char-code
"Français, Español, böse, skøl"))
"Fran=E7ais, Espa=F1ol, b=F6se, sk=F8l")
(deftest quoted-printable.2
(encode-quoted-printable-sequence (map '(vector (unsigned-byte 8)) #'char-code
"Français, Español, böse, skøl")
:start 10 :end 17)
"Espa=F1ol")
(deftest quoted-printable.3
(map 'string #'code-char
(decode-quoted-printable-string "Fran=E7ais, Espa=F1ol, b=F6se, sk=F8l"))
"Français, Español, böse, skøl")
(deftest quoted-printable.4
(map 'string #'code-char
(decode-quoted-printable-string "Fran=E7ais, Espa=F1ol, b=F6se, sk=F8l"
:start 12 :end 21))
"Español")
(deftest quoted-printable.5
(map 'string #'code-char
(decode-quoted-printable-string "this = wrong"))
"this = wrong")
(deftest quoted-printable.6
(map 'string #'code-char
(decode-quoted-printable-string "this is wrong="))
"this is wrong=")
(deftest quoted-printable.7
(map 'string #'code-char
(decode-quoted-printable-string "this is wrong=1"))
"this is wrong=1")
(deftest quoted-printable.8
(encode-quoted-printable-sequence (map '(vector (unsigned-byte 8)) #'char-code
"x = x + 1"))
"x =3D x + 1")
(deftest quoted-printable.9
(encode-quoted-printable-sequence (map '(vector (unsigned-byte 8)) #'char-code
"x = x + 1 "))
"x =3D x + 1 =20")
(deftest quoted-printable.10
(encode-quoted-printable-sequence (map '(vector (unsigned-byte 8)) #'char-code
"this string is very very very very very very very very very very very very very very very very very very very very long"))
"this string is very very very very very very very very very very very ve=
ry very very very very very very very very long")
(deftest quoted-printable.11
(encode-quoted-printable-sequence (map '(vector (unsigned-byte 8)) #'char-code
"this string is very very very very long"))
"this string is very very =
very very long")
(deftest quoted-printable.12
(encode-quoted-printable-sequence (map '(vector (unsigned-byte 8)) #'char-code
"please read the next
line"))
"please read the next =20
line")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(deftest base64.1
(let ((*base64-line-length* nil))
(encode-base64-sequence (map '(vector (unsigned-byte 8)) #'char-code
"Some random string.")))
"U29tZSByYW5kb20gc3RyaW5nLg==")
(deftest base64.2
(let ((*base64-line-length* nil))
(encode-base64-sequence (map '(vector (unsigned-byte 8)) #'char-code
"Some random string.") :start 5 :end 11))
"cmFuZG9t")
(deftest base64.3
(map 'string #'code-char
(decode-base64-string "U29tZSByYW5kb20gc3RyaW5nLg=="))
"Some random string.")
(deftest base64.4
(map 'string #'code-char
(decode-base64-string "some rubbish U29tZSByYW5kb20gc3RyaW5nLg== more rubbish"
:start 13 :end 41))
"Some random string.")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(deftest RFC2047.1
(parse-RFC2047-text "foo bar")
("foo bar"))
(defun perftest-encoder (encoder-class &optional (megs 100))
(declare (optimize (speed 3) (debug 0) (safety 0))
(type fixnum megs))
(with-open-file (in #P"/dev/random" :element-type '(unsigned-byte 8))
(let* ((meg (* 1024 1024))
(buffer (make-sequence '(vector (unsigned-byte 8)) meg))
(encoder (make-instance encoder-class
:output-function #'(lambda (c) (declare (ignore c))))))
(declare (type fixnum meg))
(time
(progn
(dotimes (x megs)
(read-sequence buffer in)
(dotimes (i meg)
(mime4cl:encoder-write-byte encoder (aref buffer i))))
(mime4cl:encoder-finish-output encoder))))))
(defun perftest-decoder (decoder-class &optional (megs 100))
(declare (optimize (speed 3) (debug 0) (safety 0))
(type fixnum megs))
(with-open-file (in #P"/dev/random" :element-type '(unsigned-byte 8))
(let ((sclf:*tmp-file-defaults* (make-pathname :defaults #.(or *load-pathname* *compile-file-pathname*)
:type "encoded-data")))
(sclf:with-temp-file (tmp nil :direction :io)
(let* ((meg (* 1024 1024))
(buffer (make-sequence '(vector (unsigned-byte 8)) meg))
(encoder-class (ecase decoder-class
(mime4cl:base64-decoder 'mime4cl:base64-encoder)
(mime4cl:quoted-printable-decoder 'mime4cl:quoted-printable-encoder)))
(encoder (make-instance encoder-class
:output-function #'(lambda (c)
(write-char c tmp))))
(decoder (make-instance decoder-class
:input-function #'(lambda ()
(read-char tmp nil)))))
(declare (type fixnum meg))
(dotimes (x megs)
(read-sequence buffer in)
(dotimes (i meg)
(mime4cl:encoder-write-byte encoder (aref buffer i))))
(mime4cl:encoder-finish-output encoder)
(file-position tmp 0)
(time
(loop
for b = (mime4cl:decoder-read-byte decoder)
while b)))))))

53
third_party/lisp/mime4cl/test/mime.lisp vendored Normal file
View file

@ -0,0 +1,53 @@
;;; mime.lisp --- MIME regression tests
;;; Copyright (C) 2012 by Walter C. Pelissero
;;; Author: Walter C. Pelissero <walter@pelissero.de>
;;; Project: mime4cl
#+cmu (ext:file-comment "$Module: mime.lisp")
;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Lesser General Public License
;;; as published by the Free Software Foundation; either version 2.1
;;; of the License, or (at your option) any later version.
;;; This library is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;;; Lesser General Public License for more details.
;;; You should have received a copy of the GNU Lesser General Public
;;; License along with this library; if not, write to the Free
;;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
;;; 02111-1307 USA
(in-package :mime4cl-tests)
(defvar *samples-directory*
(merge-pathnames (make-pathname :directory '(:relative "samples"))
#.(or *compile-file-pathname*
*load-pathname*
#P"")))
(deftest mime.1
(let* ((orig (mime-message (make-pathname :defaults #.(or *compile-file-pathname*
*load-pathname*)
:name "sample1"
:type "msg")))
(dup (mime-message (with-output-to-string (out) (encode-mime-part orig out)))))
(mime= orig dup))
t)
(deftest mime.2
(loop
for f in (directory (make-pathname :defaults *samples-directory*
:name :wild
:type "txt"))
do
(format t "~A:~%" f)
(finish-output)
(let* ((orig (mime-message f))
(dup (mime-message (with-output-to-string (out) (encode-mime-part orig out)))))
(unless (mime= orig dup)
(return nil)))
finally (return t))
t)

28
third_party/lisp/mime4cl/test/package.lisp vendored Normal file
View file

@ -0,0 +1,28 @@
;;; package.lisp --- package description for the regression tests
;;; Copyright (C) 2006, 2009 by Walter C. Pelissero
;;; Author: Walter C. Pelissero <walter@pelissero.de>
;;; Project: mime4cl
#+cmu (ext:file-comment "$Module: package.lisp $")
;;; This library is free software; you can redistribute it and/or
;;; modify it under the terms of the GNU Lesser General Public License
;;; as published by the Free Software Foundation; either version 2.1
;;; of the License, or (at your option) any later version.
;;; This library is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;;; Lesser General Public License for more details.
;;; You should have received a copy of the GNU Lesser General Public
;;; License along with this library; if not, write to the Free
;;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
;;; 02111-1307 USA
(cl:in-package :common-lisp)
(defpackage :mime4cl-tests
(:use :common-lisp
:rtest :mime4cl)
(:export))

254
third_party/lisp/mime4cl/test/rt.lisp vendored Normal file
View file

@ -0,0 +1,254 @@
#|----------------------------------------------------------------------------|
| Copyright 1990 by the Massachusetts Institute of Technology, Cambridge MA. |
| |
| Permission to use, copy, modify, and distribute this software and its |
| documentation for any purpose and without fee is hereby granted, provided |
| that this copyright and permission notice appear in all copies and |
| supporting documentation, and that the name of M.I.T. not be used in |
| advertising or publicity pertaining to distribution of the software |
| without specific, written prior permission. M.I.T. makes no |
| representations about the suitability of this software for any purpose. |
| It is provided "as is" without express or implied warranty. |
| |
| M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING |
| ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL |
| M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR |
| ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, |
| WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, |
| ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
| SOFTWARE. |
|----------------------------------------------------------------------------|#
(defpackage #:regression-test
(:nicknames #:rtest #-lispworks #:rt)
(:use #:cl)
(:export #:*do-tests-when-defined* #:*test* #:continue-testing
#:deftest #:do-test #:do-tests #:get-test #:pending-tests
#:rem-all-tests #:rem-test)
(:documentation "The MIT regression tester with pfdietz's modifications"))
(in-package :regression-test)
(defvar *test* nil "Current test name")
(defvar *do-tests-when-defined* nil)
(defvar *entries* '(nil) "Test database")
(defvar *in-test* nil "Used by TEST")
(defvar *debug* nil "For debugging")
(defvar *catch-errors* t
"When true, causes errors in a test to be caught.")
(defvar *print-circle-on-failure* nil
"Failure reports are printed with *PRINT-CIRCLE* bound to this value.")
(defvar *compile-tests* nil
"When true, compile the tests before running them.")
(defvar *optimization-settings* '((safety 3)))
(defvar *expected-failures* nil
"A list of test names that are expected to fail.")
(defstruct (entry (:conc-name nil)
(:type list))
pend name form)
(defmacro vals (entry) `(cdddr ,entry))
(defmacro defn (entry) `(cdr ,entry))
(defun pending-tests ()
(do ((l (cdr *entries*) (cdr l))
(r nil))
((null l) (nreverse r))
(when (pend (car l))
(push (name (car l)) r))))
(defun rem-all-tests ()
(setq *entries* (list nil))
nil)
(defun rem-test (&optional (name *test*))
(do ((l *entries* (cdr l)))
((null (cdr l)) nil)
(when (equal (name (cadr l)) name)
(setf (cdr l) (cddr l))
(return name))))
(defun get-test (&optional (name *test*))
(defn (get-entry name)))
(defun get-entry (name)
(let ((entry (find name (cdr *entries*)
:key #'name
:test #'equal)))
(when (null entry)
(report-error t
"~%No test with name ~:@(~S~)."
name))
entry))
(defmacro deftest (name form &rest values)
`(add-entry '(t ,name ,form .,values)))
(defun add-entry (entry)
(setq entry (copy-list entry))
(do ((l *entries* (cdr l))) (nil)
(when (null (cdr l))
(setf (cdr l) (list entry))
(return nil))
(when (equal (name (cadr l))
(name entry))
(setf (cadr l) entry)
(report-error nil
"Redefining test ~:@(~S~)"
(name entry))
(return nil)))
(when *do-tests-when-defined*
(do-entry entry))
(setq *test* (name entry)))
(defun report-error (error? &rest args)
(cond (*debug*
(apply #'format t args)
(if error? (throw '*debug* nil)))
(error? (apply #'error args))
(t (apply #'warn args))))
(defun do-test (&optional (name *test*))
(do-entry (get-entry name)))
(defun equalp-with-case (x y)
"Like EQUALP, but doesn't do case conversion of characters."
(cond
((eq x y) t)
((consp x)
(and (consp y)
(equalp-with-case (car x) (car y))
(equalp-with-case (cdr x) (cdr y))))
((and (typep x 'array)
(= (array-rank x) 0))
(equalp-with-case (aref x) (aref y)))
((typep x 'vector)
(and (typep y 'vector)
(let ((x-len (length x))
(y-len (length y)))
(and (eql x-len y-len)
(loop
for e1 across x
for e2 across y
always (equalp-with-case e1 e2))))))
((and (typep x 'array)
(typep y 'array)
(not (equal (array-dimensions x)
(array-dimensions y))))
nil)
((typep x 'array)
(and (typep y 'array)
(let ((size (array-total-size x)))
(loop for i from 0 below size
always (equalp-with-case (row-major-aref x i)
(row-major-aref y i))))))
(t (eql x y))))
(defun do-entry (entry &optional
(s *standard-output*))
(catch '*in-test*
(setq *test* (name entry))
(setf (pend entry) t)
(let* ((*in-test* t)
;; (*break-on-warnings* t)
(aborted nil)
r)
;; (declare (special *break-on-warnings*))
(block aborted
(setf r
(flet ((%do
()
(if *compile-tests*
(multiple-value-list
(funcall (compile
nil
`(lambda ()
(declare
(optimize ,@*optimization-settings*))
,(form entry)))))
(multiple-value-list
(eval (form entry))))))
(if *catch-errors*
(handler-bind
((style-warning #'muffle-warning)
(error #'(lambda (c)
(setf aborted t)
(setf r (list c))
(return-from aborted nil))))
(%do))
(%do)))))
(setf (pend entry)
(or aborted
(not (equalp-with-case r (vals entry)))))
(when (pend entry)
(let ((*print-circle* *print-circle-on-failure*))
(format s "~&Test ~:@(~S~) failed~
~%Form: ~S~
~%Expected value~P: ~
~{~S~^~%~17t~}~%"
*test* (form entry)
(length (vals entry))
(vals entry))
(format s "Actual value~P: ~
~{~S~^~%~15t~}.~%"
(length r) r)))))
(when (not (pend entry)) *test*))
(defun continue-testing ()
(if *in-test*
(throw '*in-test* nil)
(do-entries *standard-output*)))
(defun do-tests (&optional
(out *standard-output*))
(dolist (entry (cdr *entries*))
(setf (pend entry) t))
(if (streamp out)
(do-entries out)
(with-open-file
(stream out :direction :output)
(do-entries stream))))
(defun do-entries (s)
(format s "~&Doing ~A pending test~:P ~
of ~A tests total.~%"
(count t (cdr *entries*)
:key #'pend)
(length (cdr *entries*)))
(dolist (entry (cdr *entries*))
(when (pend entry)
(format s "~@[~<~%~:; ~:@(~S~)~>~]"
(do-entry entry s))))
(let ((pending (pending-tests))
(expected-table (make-hash-table :test #'equal)))
(dolist (ex *expected-failures*)
(setf (gethash ex expected-table) t))
(let ((new-failures
(loop for pend in pending
unless (gethash pend expected-table)
collect pend)))
(if (null pending)
(format s "~&No tests failed.")
(progn
(format s "~&~A out of ~A ~
total tests failed: ~
~:@(~{~<~% ~1:;~S~>~
~^, ~}~)."
(length pending)
(length (cdr *entries*))
pending)
(if (null new-failures)
(format s "~&No unexpected failures.")
(when *expected-failures*
(format s "~&~A unexpected failures: ~
~:@(~{~<~% ~1:;~S~>~
~^, ~}~)."
(length new-failures)
new-failures)))
))
(null pending))))

86
third_party/lisp/mime4cl/test/sample1.msg vendored Normal file
View file

@ -0,0 +1,86 @@
From wcp@scylla.home.lan Fri Feb 17 11:02:28 2012
Status: RO
X-VM-v5-Data: ([nil nil nil nil nil nil nil nil nil]
["1133" "Friday" "17" "February" "2012" "11:02:27" "+0100" "Walter C. Pelissero" "walter@pelissero.de" nil "56" "test" "^From:" nil nil "2" nil nil nil nil nil nil nil nil nil nil]
nil)
X-Clpmr-Processed: 2012-02-17T11:02:31
X-Clpmr-Version: 2011-10-23T12:55:20, SBCL 1.0.49
Received: from scylla.home.lan (localhost [127.0.0.1])
by scylla.home.lan (8.14.5/8.14.5) with ESMTP id q1HA2Sik004513
for <wcp@scylla.home.lan>; Fri, 17 Feb 2012 11:02:28 +0100 (CET)
(envelope-from wcp@scylla.home.lan)
Received: (from wcp@localhost)
by scylla.home.lan (8.14.5/8.14.5/Submit) id q1HA2SqU004512;
Fri, 17 Feb 2012 11:02:28 +0100 (CET)
(envelope-from wcp)
Message-ID: <20286.9651.890757.323027@scylla.home.lan>
X-Mailer: VM 8.1.1 under 23.3.1 (amd64-portbld-freebsd8.2)
Reply-To: walter@pelissero.de
X-Attribution: WP
X-For-Spammers: blacklistme@pelissero.de
X-MArch-Processing-Time: 0.552s
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="615CiWUaGO"
Content-Transfer-Encoding: 7BIT
From: walter@pelissero.de (Walter C. Pelissero)
To: wcp@scylla.home.lan
Subject: test
Date: Fri, 17 Feb 2012 11:02:27 +0100
--615CiWUaGO
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: 7BIT
Content-Description: message body text
Hereafter three attachments.
The first:
--615CiWUaGO
Content-Type: application/octet-stream; name="attach1"
Content-Transfer-Encoding: BASE64
Content-Disposition: attachment; filename="attach1"
YXR0YWNoMQo=
--615CiWUaGO
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: 7BIT
Content-Description: message body text
The second:
--615CiWUaGO
Content-Type: application/octet-stream; name="attach2"
Content-Transfer-Encoding: BASE64
Content-Disposition: attachment; filename="attach2"
YXR0YWNoMgo=
--615CiWUaGO
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: 7BIT
Content-Description: message body text
The third:
--615CiWUaGO
Content-Type: application/octet-stream; name="attach3"
Content-Transfer-Encoding: BASE64
Content-Disposition: attachment; filename="attach3"
YXR0YWNoMwo=
--615CiWUaGO
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: 7BIT
Content-Description: .signature
--
http://pelissero.de
--615CiWUaGO--