Come posso inviare un file come allegato e-mail utilizzando la riga di comando di Linux?

StackOverflow https://stackoverflow.com/questions/17359

  •  08-06-2019
  •  | 
  •  

Domanda

Ho creato uno script che viene eseguito ogni notte sul mio server Linux che utilizza mysqldump per eseguire il backup di ciascuno dei miei database MySQL in file .sql e impacchettarli insieme come file .tar compresso.Il prossimo passo che voglio compiere è inviare il file tar tramite e-mail a un server di posta remoto per tenerlo al sicuro.Sono stato in grado di inviare un'e-mail allo script non elaborato nel corpo reindirizzando il file di testo di backup a mailx così:

$ cat mysqldbbackup.sql | mailx backup@email.com

cat fa eco al testo del file di backup che viene convogliato nel file mailx programma con l'indirizzo email del destinatario passato come argomento.

Anche se questo soddisfa ciò di cui ho bisogno, penso che potrebbe essere un passo migliore, Esiste un modo, utilizzando script di shell o altro, per inviare il file .tar compresso a un messaggio di posta elettronica in uscita come attaccamento? Ciò eviterebbe di dover gestire messaggi di posta elettronica molto lunghi che contengono dati di intestazione e spesso presentano problemi di a capo automatico, ecc.

È stato utile?

Soluzione

Nessuno di quelli bastardi ha funzionato per me.Si pensava che l'indirizzo email fosse parte dell'allegato.Doveva fare:

echo "This is the message body" | mutt -a "/path/to/file.to.attach" -s "subject of message" -- recipient@domain.com

Altri suggerimenti

Oppure, in mancanza di mutt:

gzip -c mysqldbbackup.sql | uuencode mysqldbbackup.sql.gz  | mail -s "MySQL DB" backup@email.com

Dal guardare man mailx, il programma mailx non dispone di un'opzione per allegare un file.Potresti usare un altro programma come mutt.

echo "This is the message body" | mutt -a file.to.attach -s "subject of message" recipient@domain.com

Le opzioni della riga di comando per mutt possono essere visualizzate con mutt -h.

A seconda della versione di Linux, potrebbe essere chiamato mail.Per citare @David sopra:

mail -s "Backup" -a mysqldbbackup.sql backup@email.com < message.txt

o anche:

cat message.txt | mail -s "Backup" -a mysqldbbackup.sql backup@email.com

Io uso mpack.

mpack -s subject file user@example.com

Sfortunatamente mpack non riconosce '-' come alias per stdin.Ma il seguente funziona e può essere facilmente racchiuso in un alias (shell) o in uno script:

mpack -s subject /dev/stdin loser@example.com < file

Utilizzo SendEmail, creato per questo scenario.È confezionato per Ubuntu quindi presumo che sia disponibile

sendemail -f sender@some.where -t receiver@some.place -m "Here are your files!" -a file1.jpg file2.zip

http://caspian.dotconf.net/menu/Software/SendEmail/

 echo 'These are contents of my mail' | mailx -s 'This is my email subject' -a /path/to/attachment_file.log email_id@example.com

Puoi usare bastardino per inviare l'e-mail con allegato

mutt -s "Backup" -a mysqldbbackup.sql backup@email.com < message.txt

Una volta ho scritto questa funzione per ksh su Solaris (usa Perl per la codifica base64): 

# usage: email_attachment to cc subject body attachment_filename
email_attachment() {
    to="$1"
    cc="$2"
    subject="$3"
    body="$4"
    filename="${5:-''}"
    boundary="_====_blah_====_$(date +%Y%m%d%H%M%S)_====_"
    {
        print -- "To: $to"
        print -- "Cc: $cc"
        print -- "Subject: $subject"
        print -- "Content-Type: multipart/mixed; boundary=\"$boundary\""
        print -- "Mime-Version: 1.0"
        print -- ""
        print -- "This is a multi-part message in MIME format."
        print -- ""
        print -- "--$boundary"
        print -- "Content-Type: text/plain; charset=ISO-8859-1"
        print -- ""
        print -- "$body"
        print -- ""
        if [[ -n "$filename" && -f "$filename" && -r "$filename" ]]; then
            print -- "--$boundary"
            print -- "Content-Transfer-Encoding: base64"
            print -- "Content-Type: application/octet-stream; name=$filename"
            print -- "Content-Disposition: attachment; filename=$filename"
            print -- ""
            print -- "$(perl -MMIME::Base64 -e 'open F, shift; @lines=<F>; close F; print MIME::Base64::encode(join(q{}, @lines))' $filename)"
            print -- ""
        fi
        print -- "--${boundary}--"
    } | /usr/lib/sendmail -oi -t
}

Invia un'e-mail con il corpo in testo normale con un allegato in testo normale con mailx:

(
  /usr/bin/uuencode attachfile.txt myattachedfilename.txt; 
  /usr/bin/echo "Body of text"
) | mailx -s 'Subject' youremail@gmail.com

Di seguito è riportato lo stesso comando di sopra, senza i ritorni a capo

( /usr/bin/uuencode /home/el/attachfile.txt myattachedfilename.txt; /usr/bin/echo "Body of text" ) | mailx -s 'Subject' youremail@gmail.com

Assicurati di avere un file /home/el/attachfile.txt definito con questo contenuto:

<html><body>
Government discriminates against programmers with cruel/unusual 35 year prison
sentences for making the world's information free, while bankers that pilfer 
trillions in citizens assets through systematic inflation get the nod and 
walk free among us.
</body></html>

Se non hai uuencode leggi questo: https://unix.stackexchange.com/questions/16277/how-do-i-get-uuencode-to-work

Su Linux, invia un'e-mail con corpo HTML con un allegato PDF con sendmail:

Assicurati di aver installato ksh: yum info ksh

Assicurati di avere sendmail installato e configurato.

Assicurati di avere uuencode installato e disponibile: https://unix.stackexchange.com/questions/16277/how-do-i-get-uuencode-to-work

Crea un nuovo file chiamato test.sh e inseriscilo nella tua home directory: /home/el

Inserisci il seguente codice test.sh:

#!/usr/bin/ksh
export MAILFROM="el@defiant.com"
export MAILTO="youremail@gmail.com"
export SUBJECT="Test PDF for Email"
export BODY="/home/el/email_body.htm"
export ATTACH="/home/el/pdf-test.pdf"
export MAILPART=`uuidgen` ## Generates Unique ID
export MAILPART_BODY=`uuidgen` ## Generates Unique ID

(
 echo "From: $MAILFROM"
 echo "To: $MAILTO"
 echo "Subject: $SUBJECT"
 echo "MIME-Version: 1.0"
 echo "Content-Type: multipart/mixed; boundary=\"$MAILPART\""
 echo ""
 echo "--$MAILPART"
 echo "Content-Type: multipart/alternative; boundary=\"$MAILPART_BODY\""
 echo ""
 echo "--$MAILPART_BODY"
 echo "Content-Type: text/plain; charset=ISO-8859-1"
 echo "You need to enable HTML option for email"
 echo "--$MAILPART_BODY"
 echo "Content-Type: text/html; charset=ISO-8859-1"
 echo "Content-Disposition: inline"
 cat $BODY
 echo "--$MAILPART_BODY--"

 echo "--$MAILPART"
 echo 'Content-Type: application/pdf; name="'$(basename $ATTACH)'"'
 echo "Content-Transfer-Encoding: uuencode"
 echo 'Content-Disposition: attachment; filename="'$(basename $ATTACH)'"'
 echo ""
 uuencode $ATTACH $(basename $ATTACH)
 echo "--$MAILPART--"
) | /usr/sbin/sendmail $MAILTO

Modifica le variabili di esportazione in alto test.sh per riflettere il tuo indirizzo e i nomi dei file.

Scarica un documento pdf di prova e inseriscilo /home/el chiamato pdf-test.pdf

Crea un file chiamato /home/el/email_body.htm e inserisci questa riga:

<html><body><b>this is some bold text</b></body></html>

Assicurati che il file pdf disponga di autorizzazioni 755 sufficienti.

Esegui lo script ./test.sh

Controlla la tua casella di posta elettronica, il testo dovrebbe essere in formato HTML e il file pdf interpretato automaticamente come file binario.Fai attenzione a non utilizzare questa funzione più di 15 volte al giorno, anche se invii le email a te stesso, i filtri antispam in Gmail possono inserire nella lista nera un dominio che invia email senza darti la possibilità di lasciarle passare.E scoprirai che questo non funziona più, o lascia passare solo l'allegato, o l'e-mail non arriva affatto.Se devi fare molti test su questo argomento, distribuiscili su più giorni o verrai etichettato come spammer e questa funzione non funzionerà più.

Ci sono diverse risposte qui che suggeriscono mail O mailx quindi questo è più che altro uno sfondo per aiutarti a interpretarli nel contesto.

Note storiche

Le origini di Unix mail torniamo indietro nelle nebbie della storia iniziale di Bell Labs Unix™ (1969?), e probabilmente non possiamo sperare di approfondire qui la sua genealogia completa.Basti dire che ci sono molti programmi che ereditano il codice da o reimplementano (o ereditano il codice da una reimplementazione di) mail e che non esiste un'unica base di codice che possa essere identificata inequivocabilmente come "il" mail.

Tuttavia, uno dei contendenti a quella posizione è sicuramente "Berkeley Mail", come si chiamava originariamente Mail con una M maiuscola in 2BSD (1978);ma in 3BSD (1979), sostituì la minuscola mail comando, creando nuova confusione.SVR3 (1986) includeva un derivato chiamato mailx.IL x è stato presumibilmente aggiunto per renderlo unico e distinto;ma anche questo è stato ora copiato, reimplementato e mutilato, tanto che non esiste un'unica versione individuale che sia definitiva.

In passato, il di fatto era lo standard per l'invio di file binari tramite posta elettronica uuencode.Esiste ancora, ma presenta numerosi problemi di usabilità;se possibile, dovresti invece inviare allegati MIME, a meno che non ti sforzi specificamente di essere in grado di comunicare con la fine degli anni '80.

MIMO è stato introdotto all'inizio degli anni '90 per risolvere diversi problemi con la posta elettronica, incluso il supporto per vari tipi di contenuto diversi dal testo semplice in un singolo set di caratteri che è realmente adatto solo per un sottoinsieme dell'inglese (e, ci viene detto, hawaiano) .Ciò ha introdotto il supporto per i messaggi in più parti, l'internazionalizzazione, i tipi di contenuti avanzati, ecc., e ha rapidamente guadagnato terreno nel corso degli anni '90.

(IL Cimelio di famiglia mail/mailx appunti di storia sono stati molto utili durante la composizione di questo articolo e meritano sicuramente una lettura se ti piacciono questo genere di cose.)

Offerte attuali

A partire dal 2018, Debian ha tre pacchetti che includono a mail O mailx comando.(Puoi cercare Provides: mailx.)

debian$ aptitude search ~Pmailx
i   bsd-mailx                       - simple mail user agent
p   heirloom-mailx                  - feature-rich BSD mail(1)
p   mailutils                       - GNU mailutils utilities for handling mail

(Non sto scegliendo Debian come raccomandazione;è quello che uso, quindi lo conosco;e fornisce un mezzo per distinguere in modo inequivocabile le varie alternative facendo riferimento ai rispettivi nomi di pacchetto.Ovviamente è anche la distribuzione da cui Ubuntu ottiene questi pacchetti.)

  • bsd-mailx è relativamente semplice mailx che fa non sembrano supportare l'invio di allegati MIME.Guardalo pagina di manuale e nota che questo è quello che ti aspetteresti di trovare su un sistema *BSD, incluso MacOS, per impostazione predefinita.
  • heirloom-mailx ora viene chiamato s-nail E fa supporta l'invio di allegati MIME con -a.Guardalo pagina di manuale e più in generale il Progetto cimelio
  • mailutils ovvero Mailutil GNU include a mail/mailx involucro di compatibilità Quale fa supporta l'invio di allegati MIME con -A

Con queste preoccupazioni, se hai bisogno che il tuo codice sia portabile e possa dipendere da un pacchetto piuttosto complesso, il modo semplice per inviare portabilmente allegati MIME è quello di utilizzo mutt.

Un'altra alternativa - Swaks (Coltellino svizzero per SMTP).

swaks -tls \
    --to ${MAIL_TO} \
    --from ${MAIL_FROM} \
    --server ${MAIL_SERVER} \
    --auth LOGIN \
    --auth-user ${MAIL_USER} \
    --auth-password ${MAIL_PASSWORD} \
    --header "Subject: $MAIL_SUBJECT" \
    --header "Content-Type: text/html; charset=UTF-8" \
    --body "$MESSAGE" \
    --attach mysqldbbackup.sql

metamail ha lo strumento metasend

metasend -f mysqlbackup.sql.gz -t backup@email.com -s Backup -m application/x-gzip -b

ero solito 

echo "Start of Body" && uuencode log.cfg readme.txt | mail -s "subject" "a@b.c"

e questo ha funzionato bene per me....

mailx ha un -a opzione ora per gli allegati.

Di solito utilizzo solo il comando mail su RHEL.Ho provato mailx ed è abbastanza efficiente.

mailx -s "Sending Files" -a First_LocalConfig.conf -a
Second_LocalConfig.conf Recipient@myemail.com

This is the content of my msg.

.

la strada più breve per me è

file=filename_or_filepath;uuencode $file $file|mail -s "optional subject" email_address

quindi per il tuo esempio sarà

file=your_sql.log;gzip -c $file;uuencode ${file}.gz ${file}|mail -s "file with magnets" ph.gachoud@gmail.com

la parte buona è che posso ricordarlo con CTRL+R per inviare un altro file...

Dalla macchina di origine

mysqldump --defaults-extra-file=sql.cnf database | gzip | base64 | mail me@myemail.com

Sulla macchina di destinazione.Salva il corpo della posta ricevuta con nome db.sql.gz.b64;Poi..

base64 -D -i db.sql.gz.b64 | gzip -d | mysql --defaults-extra-file=sql.cnf

utilizzando il comando mailx

 echo "Message Body Here" | mailx -s "Subject Here" -a file_name user@example.com

utilizzando sendmail 

#!/bin/ksh

fileToAttach=data.txt

`(echo "To: user@company.com"
  echo "Cc: user@company.com"
  echo "From: Application"
  echo "Subject: your subject"
  echo  your body
  uuencode $fileToAttach $fileToAttach
  )| eval /usr/sbin/sendmail -t `;

Solo per aggiungere i miei 2 centesimi, scriverei il mio script PHP:

http://php.net/manual/en/function.mail.php

Esistono molti modi per eseguire l'allegato negli esempi in quella pagina.

Non è un metodo per inviare e-mail, ma puoi utilizzare un server Git online (ad es.Bitbucket o un servizio simile) per questo.

In questo modo puoi utilizzare git push comandi e tutte le versioni verranno archiviate in modo compresso e organizzato.

Ecco come sto facendo con un file di registro di grandi dimensioni in CentOS:

MAIL="`whereis mail | awk '{print $2}'`"
WHOAMI="`whoami`"
HOSTNAME="`hostname`"
EMAIL"your@email.address"
LOGDIR="/var/log/aide"
LOGNAME="`basename "$0"`_`date "+%Y%m%d_%H%M"`"
# Arhiveerime ning kui hästi, saadame edasi:
/bin/tar -zcvf ${LOGDIR}/${LOGNAME}.tgz "${LOGDIR}/${LOGNAME}.log" > /dev/null 2>&1
if [ $? -eq 0 ]; then
    cd ${LOGDIR}
    # This works too. The message content will be taken from text file below
    # echo 'Hello!' >/root/scripts/audit_check.sh.txt
    # echo "Arhiivifail manuses" | ${MAIL} -s "${HOSTNAME} Aide report" -q /root/scripts/audit_check.sh.txt -a ${LOGNAME}.tgz -S from=${WHOAMI}@${HOSTNAME} ${EMAIL}
    echo "Arhiivifail manuses" | ${MAIL} -s "${HOSTNAME} Aide report" -a ${LOGNAME}.tgz -S from=${WHOAMI}@${HOSTNAME} ${EMAIL}
    /bin/rm "${LOGDIR}/${LOGNAME}.log"
fi

Se il file è di testo, puoi inviarlo più facilmente nel corpo come:

sendmail recipient@example.com < message.txt

Mailutils rende tutto questo un gioco da ragazzi

echo "Body" | mail.mailutils -M -s "My Subject" -A attachment.pdf mail@example.org
  • -A file allega un file
  • -M abilita MIME, in modo da poter avere un allegato e un corpo di testo normale.

Se non è ancora installato, esegui

sudo apt install mailutils

Ancora una cosa mutt:per impostazione predefinita utilizza il tuo indirizzo e nome nel campo "Da:".Se non è quello che ti serve, puoi creare un file muttrc alternativo contenente una stringa come questa:set from="Il mio demone di posta"

Usa questo file con -F opzione della riga di comando.

Se mutt non funziona o non è installato, prova questo-

*#!/bin/sh

FilePath=$1
FileName=$2
Message=$3
MailList=$4

cd $FilePath

Rec_count=$(wc -l < $FileName)
if [ $Rec_count -gt 0 ]
then
(echo "The attachment contains $Message" ; uuencode $FileName $FileName.csv ) | mailx -s "$Message" $MailList
fi*
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top