mime-constructp - En ligne dans le Cloud

PROGRAMME:

Nom

mime-construct - construire et éventuellement envoyer des messages MIME

SYNOPSIS

mime-construire interrupteur

Désolé, il est difficile de fournir un résumé significatif. Voir les exemples.

DESCRIPTION

mime-construire construit et (par défaut) envoie des messages MIME. il est entièrement piloté
à partir de la ligne de commande, il est conçu pour être utilisé par d'autres programmes ou des personnes qui agissent comme
programmes.

OPTIONS

Global Paramètres
--déboguer
Activez le débogage.

--Aidez-moi
Afficher le message d'utilisation et mourir.

--output
N'envoyez pas le message généré, imprimez-le plutôt sur stdout. Cela perd --cci Info.

--sous-partie
Générer une sous-partie qui peut être utilisée dans un autre message MIME, plutôt qu'un niveau supérieur
message MIME lui-même. Cela s'allume --output et change certaines sémantiques internes a
bit. Voir les exemples.

--version
Imprimez la version et quittez avec succès, s'il s'agit du seul argument. Sinon, imprimez
la version et mourir.

Entrée En-tête
Ces arguments ajoutent du texte à l'en-tête de niveau supérieur du message ou contrôlent qui il reçoit
envoyé à.

--cci propos
Ajouter propos à la liste des destinataires. Cela n'ajoute rien à l'en-tête,
bien sûr. Si vous n'envoyez pas réellement le message (si vous utilisez --output or
--sous-partie) --cci n'aura aucun effet.

--cc propos
Ajouter une adresse au Cc: liste.

--intégré à
Envoyez le message aux destinataires déjà listés dans l'en-tête, en plus de ceux
donné avec --à, --ccet --cci. Cela a du sens si vous utilisez le --entête basculer vers
ajouter votre propre À: or Cc:. Dans ce cas, vous ne voulez probablement pas utiliser --à or --cc
car ils créeraient de nouveaux en-têtes plutôt que d'ajouter à ceux déjà présents dans le
par voie électronique.

Ce commutateur passe le -t passer à sendmail (mime-construire n'essaie pas d'analyser le
en-têtes que vous fournissez), donc cela ne fait vraiment rien si vous n'envoyez pas le
par voie électronique.

--entête str
Ajoutez du texte arbitraire à l'en-tête. Les str peut être tout ce que vous voulez, y compris
plusieurs lignes. Vous pouvez créer des messages invalides de cette façon. Si vous incluez un blanc
Ligne dans le str vous allez vraiment bousiller le message.

--multipart str
Cela spécifie le type de contenu en plusieurs parties et les options. La valeur par défaut est
"multipart/mixte". N'incluez pas de paramètre de « limite », qui est fourni par mime-
construire.

Ce n'est pas grave si vous spécifiez le --multipart tapez mais le message s'avère être un seul
partie, le type que vous fournissez sera simplement ignoré.

--prélude str
Cela ajoute str au texte du prélude en plusieurs parties. Si vous spécifiez --prélude plusieurs fois
le strs seront tous concaténés.

Il n'y a pas de valeur par défaut pour ce texte. Il me semble qu'aujourd'hui l'ajout d'un
expliquer MIME au début d'un message revient à expliquer comment utiliser un siège
boucle aux personnes qui voyagent dans un avion.

Ce n'est pas grave si vous spécifiez le --prélude mais le message s'avère être une seule partie,
le prélude que vous fournissez sera simplement ignoré.

--matière str
Spécifiez l'objet du message.

--à propos
Ajouter une adresse au À: liste.

Par pièce En-tête
Ces commutateurs contrôlent les en-têtes par partie. S'il s'avère que le message n'est pas en plusieurs parties
ils ajoutent en fait des données à l'en-tête de niveau supérieur.

Chacun de ces éléments s'applique uniquement à la sortie de pièce suivante. Une fois que chaque partie est sortie, elles sont
réinitialiser à leurs valeurs par défaut. Cela n'a pas de sens de les utiliser sans un suivi
partie, donc mime-construire va crachoter et mourir si vous essayez de le faire.

--attachement prénom
Cela ajoute un en-tête « Content-Disposition : attachement » avec le prénom comme valeur
de l'attribut "nom de fichier". C'est juste une commodité, car mime-construire est souvent
utilisé pour envoyer des fichiers en pièces jointes.

En utilisant --attachement prénom ne cause pas mime-construire pour lire les données du fichier
appelé prénom! Il utilise simplement ce nom dans l'en-tête. Les données réelles qui iront
dans cette partie du message vient de l'un des commutateurs de sortie de partie réguliers
(donnée ci-après).

Vous préférerez peut-être utiliser le --fichier-attacher commutateur, qui lit à partir du prénomd fichier.

--codage type
Ceci spécifie le type d'encodage que vous voulez que cette partie utilise. Vous ne devriez normalement pas
utilisez ce commutateur, cependant. Si ce commutateur n'est pas utilisé mime-construire choisira un
encodage approprié.

Les données que vous fournissez ne doivent pas déjà être encodées, mime-construire l'encodera
selon l' type vous précisez ici. Les encodages valides sont 7bit, 8bit, binaire,
cité-imprimableet base64. Il est facile de générer un message MIME illégal en
en spécifiant vous-même l'encodage.

--part-en-tête str
Ajoutez du texte arbitraire à l'en-tête par partie. Les str peut être tout ce que vous aimez,
y compris plusieurs lignes. Vous pouvez créer des messages invalides de cette façon. Si vous incluez un
ligne vierge dans le str vous allez vraiment bousiller le message.

--taper type
Spécifiez le type de contenu pour cette partie. Si vous ne spécifiez pas de --taper il est par défaut
"texte simple". Les type que vous fournissez peut contenir non seulement le type proprement dit mais aussi
option. Le tout sera simplement déposé à la fin de "Content-Type:" et
coincé dans l'en-tête.

Vous préférerez peut-être utiliser le --file-auto or --fichier-attacher commutateurs, qui règlent le
--taper automatiquement en fonction du nom d'un fichier.

Partie Sortie
Ces commutateurs ajoutent des données au corps du message. Vous en utilisez un pour chacun pour
chaque partie d'un message en plusieurs parties (ou juste l'une d'entre elles si le message ne doit pas être
en plusieurs parties).

--déposer chemin
--file-auto chemin
--fichier-attacher chemin
--attacher chemin
--chaîne de caractères str
--corps str
Utiliser le contenu du fichier chemin ou la chaîne littérale str comme le corps de cette partie.

--file-auto entraîne la définition du type de contenu en fonction du nom du fichier, si possible.

--fichier-attacher fait cela et définit le --attachement nom aussi.

Assurez-vous d'inclure la nouvelle ligne de fin sur str à moins qu'il ne soit vraiment pas censé le faire
être une. Si vous laissez la nouvelle ligne de fin désactivée, la partie devra être encodée dans
"base64" (car "quoted-printable" a une limitation artificielle qui l'empêche
de pouvoir encoder un tel flux de données).

--attacher est un alias pour --fichier-attacheret --corps est un alias pour --chaîne de caractères.

--fichier-sous-partie chemin
--sous-partie-chaîne str
Utilisez soit le contenu de chemin or str lui-même comme le corps de cette partie, mais traitez-le
comme sous-partie. Cela signifie que les données contiennent à la fois des en-têtes et du texte. Ce
signifie également que vous ne pouvez pas utiliser --taper or --codage pour cette partie.

Normalement, le chemin or str aura été généré par une invocation différente de mime-
construire qui a reçu le --sous-partie interrupteur.

Les arguments des commutateurs qui prennent un nom de fichier (comme --déposer et --fichier-sous-partie) peut avoir
un peu de magie. S'il n'y a pas de fichier avec le chemin fourni un Perl régulier ouvrir() est fait le
ce. Voir "EXEMPLES".

EXEMPLES

Les exemples supposent que $nl contient une nouvelle ligne. Les autres variables utilisées sont j'espère
explicite.

Envoyez un message simple.

mime-construct --to "$recip" --subject 'bonjour' --string "$body"

Envoyer un message qui est lu à partir de stdin.

fortune | mime-construct --to "$recip" --subject fortune --file -

Envoyez une partie de texte brut et joignez un fichier, en définissant le type de contenu du fichier et --attachement
nom automatiquement.

mime-construct --to "$recip" --subject "$file" \
--string "Voici le fichier dont je vous ai parlé.$nl" \
--file-attach "$fichier"

La plupart des gens considèrent les pièces jointes comme des messages en plusieurs parties, mais ce n'est pas obligatoire. Cette
génère un zip de tous les fichiers du répertoire courant et les envoie en pièce jointe
mais comme un message en une seule partie.

zip -q - * |
mime-construct --to "$recip" --subject 'répertoire zippé' \
--attachment dir.zip --type application/zip --file -

Vous pouvez utiliser toute l'expressivité de Perl ouvrir() lors de la construction des noms de fichiers. Par exemple,
vous pouvez exécuter des processus XXX mauvais exemples, il n'y a pas de noms de fichiers

mime-construct --to "$recip" --subject "$subject" \
--string "Voici les deux fichiers que vous vouliez.$nl" \
--type application/x-gzip --attachment file1.gz --file 'gzip -c file1 |' \
--type application/x-gzip --attachment file1.gz --file 'gzip -c file2 |'

ou lire à partir d'autres descripteurs de fichiers ("<&=4" pour lire à partir du descripteur de fichier 4) ou
peu importe. Voir perlopentut pour un tutoriel.

Voici un exemple d'utilisation d'une invocation distincte de mime-construire pour créer une sous-partie.
Cela crée un message qui a deux parties au niveau supérieur. La première partie est un texte,
la deuxième partie est un condensé. Le condensé lui-même est un message en plusieurs parties qui contient un
nombre de parties message/rfc822.

msg_args=
pour msg dans $msg_list
do
msg_args="$msg_args --type message/rfc822 --file $msg"
fait

définir fnord
pour la recette dans $recip_list
do
set "$@" --bcc $recip
fait
décalage

mime-construct --subpart --multipart multipart/digest $msg_args |
construction mime \
--header "À : Digest destinataires : ;$nl" \
--subject 'Foo digest' \
"$@" \
--file "$introduction" \
--fichier-sous-partie -

Voici comment envoyer un message crypté (multipart/crypted, tel que défini dans la RFC 1847).
Vous visitez la fonctionnalité mime-construire "--subpart" pour générer le vrai message que vous voulez envoyer (qui
peut être une sorte de message MIME -- non textuel, en plusieurs parties, que voulez-vous), puis cryptez-le et
utiliser un autre mime-construire pour construire et envoyer le message en plusieurs parties/crypté qui
le contient.

enc_type=application/pgp-crypté
enc_params="Version : 1$nl"

mime-construct --subpart --file body --file-auto image.jpg |
gpg --encrypt --armor -r "$recip" |
mime-construct --output \
--to "$recip" \
--subject "$sujet" \
--multipart "multipart/encrypted; protocol=\"$enc_type\"" \
--type "$enc_type" \
--string "$enc_params" \
--type application/octet-stream \
--déposer -

Utilisez mime-constructp en ligne en utilisant les services onworks.net