Como envio um arquivo como anexo de e-mail usando a linha de comando do Linux?

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

  •  08-06-2019
  •  | 
  •  

Pergunta

Eu criei um script que é executado todas as noites no meu servidor Linux que usa mysqldump fazer backup de cada um dos meus bancos de dados MySQL em arquivos .sql e empacotá-los como um arquivo .tar compactado.A próxima etapa que desejo realizar é enviar o arquivo tar por e-mail para um servidor de e-mail remoto para proteção.Consegui enviar um e-mail ao script bruto no corpo canalizando o arquivo de texto de backup para mailx igual a:

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

cat ecoa o texto do arquivo de backup que é canalizado para o mailx programa com o endereço de e-mail do destinatário passado como argumento.

Embora isso atenda ao que preciso, acho que poderia ser um passo melhor, Existe alguma maneira, usando scripts de shell ou de outra forma, de enviar o arquivo .tar compactado para uma mensagem de e-mail de saída como um anexo? Isso seria melhor do que ter que lidar com mensagens de e-mail muito longas que contêm dados de cabeçalho e muitas vezes apresentam problemas de quebra de linha, etc.

Foi útil?

Solução

Nenhum dos vira-latas funcionou para mim.Estava pensando que o endereço de e-mail fazia parte do anexo.Tive que fazer:

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

Outras dicas

Ou, falhando no vira-lata:

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

De olhar para man mailx, o programa mailx não tem a opção de anexar um arquivo.Você poderia usar outro programa como o mutt.

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

As opções de linha de comando para mutt podem ser mostradas com mutt -h.

Dependendo da sua versão do Linux, pode ser chamado de mail.Para citar @David acima:

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

ou também:

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

Eu uso o mpack.

mpack -s subject file user@example.com

Infelizmente, o mpack não reconhece '-' como um alias para stdin.Mas o seguinte funciona e pode ser facilmente agrupado em um alias (shell) ou em um script:

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

Eu uso o SendEmail, que foi criado para este cenário.Está empacotado para Ubuntu, então presumo que esteja disponível

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

Você pode usar vira-lata para enviar o e-mail com anexo

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

Certa vez, escrevi esta função para ksh no Solaris (usa Perl para codificação 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
}

Envie um e-mail de texto simples com um anexo de texto simples com mailx:

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

Abaixo está o mesmo comando acima, sem as novas linhas

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

Certifique-se de ter um arquivo /home/el/attachfile.txt definido com este conteúdo:

<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 você não tem uuencode, leia isto: https://unix.stackexchange.com/questions/16277/how-do-i-get-uuencode-to-work

No Linux, envie email com corpo em HTML com anexo em PDF com sendmail:

Certifique-se de ter o ksh instalado: yum info ksh

Certifique-se de ter o sendmail instalado e configurado.

Certifique-se de ter o uuencode instalado e disponível: https://unix.stackexchange.com/questions/16277/how-do-i-get-uuencode-to-work

Faça um novo arquivo chamado test.sh e coloque-o em seu diretório inicial: /home/el

Coloque o seguinte código em 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

Altere as variáveis ​​de exportação na parte superior de test.sh para refletir seu endereço e nomes de arquivos.

Baixe um documento PDF de teste e coloque-o /home/el chamado pdf-teste.pdf

Crie um arquivo chamado /home/el/email_body.htm e coloque esta linha nele:

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

Certifique-se de que o arquivo PDF tenha 755 permissões suficientes.

Execute o script ./test.sh

Verifique sua caixa de entrada de e-mail, o texto deve estar no formato HTML e o arquivo pdf será automaticamente interpretado como um arquivo binário.Tome cuidado para não usar esta função mais do que 15 vezes por dia, mesmo se você enviar os e-mails para si mesmo, os filtros de spam no Gmail podem colocar um domínio na lista negra vomitando e-mails sem lhe dar a opção de deixá-los passar.E você descobrirá que isso não funciona mais, ou apenas deixa passar o anexo, ou o e-mail não chega.Se você tiver que fazer muitos testes sobre isso, distribua-os por dias ou você será rotulado de spammer e essa função não funcionará mais.

Existem várias respostas aqui sugerindo mail ou mailx então este é mais um pano de fundo para ajudá-lo a interpretá-los no contexto.

Notas Históricas

As origens do Unix mail Voltemos às brumas da história inicial do Bell Labs Unix™ (1969?), e provavelmente não podemos esperar entrar em sua genealogia completa aqui.Basta dizer que existem muitos programas que herdam código ou reimplementam (ou herdam código de uma reimplementação de) mail e que não existe uma base de código única que possa ser inequivocamente identificada como "o" mail.

No entanto, um dos candidatos a essa posição é certamente "Berkeley Mail", que foi originalmente chamado Mail com M maiúsculo em 2BSD (1978);mas no 3BSD (1979), substituiu as letras minúsculas mail comando também, levando a alguma nova confusão.SVR3 (1986) incluiu um derivado que foi chamado mailx.O x foi provavelmente adicionado para torná-lo único e distinto;mas isto também foi agora copiado, reimplementado e mutilado, de modo que não existe uma única versão individual que seja definitiva.

Antigamente, o de fato padrão para envio de binários por correio eletrônico era uuencode.Ainda existe, mas apresenta inúmeros problemas de usabilidade;se possível, você deve enviar anexos MIME, a menos que se esforce especificamente para poder se comunicar com o final da década de 1980.

MIME foi introduzido no início da década de 1990 para resolver vários problemas com e-mail, incluindo suporte para vários tipos de conteúdo além de texto simples em um único conjunto de caracteres que só é realmente adequado para um subconjunto do inglês (e, dizem, do havaiano) .Isso introduziu suporte para mensagens multipartes, internacionalização, tipos de conteúdo rico, etc., e rapidamente ganhou força ao longo da década de 1990.

(O Herança mail/mailx notas de história foram muito úteis ao compor isso e certamente valem a pena ler se você gosta desse tipo de coisa.)

Ofertas atuais

A partir de 2018, o Debian tem três pacotes que incluem um mail ou mailx comando.(Você pode procurar 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

(Não estou destacando o Debian como recomendação;é o que eu uso, então estou familiarizado com isso;e fornece um meio de distinguir as várias alternativas de forma inequívoca, referindo-se aos seus respectivos nomes de pacotes.Obviamente, é também a distribuição da qual o Ubuntu obtém esses pacotes.)

  • bsd-mailx é relativamente simples mailx o que faz não parecem suportar o envio de anexos MIME.Veja seu página de manual e observe que este é o que você esperaria encontrar em um sistema *BSD, incluindo MacOS, por padrão.
  • heirloom-mailx agora está sendo chamado s-nail e faz suporte ao envio de anexos MIME com -a.Veja seu página de manual e mais geralmente o Projeto de herança
  • mailutils também conhecido como GNU Mailutils inclui um mail/mailx wrapper de compatibilidade qual faz suporte ao envio de anexos MIME com -A

Com essas preocupações, se você precisa que seu código seja portátil e pode depender de um pacote um tanto complexo, a maneira simples de enviar anexos MIME de forma portável é usar mutt.

Outra alternativa - Swaks (Canivete Suíço para 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 tem a ferramenta metasend

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

eu usei 

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

e isso funcionou bem para mim ....

mailx tem um -a opção agora para anexos.

Normalmente só uso o comando mail no RHEL.Eu tentei mailx e é bastante eficiente.

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

This is the content of my msg.

.

o caminho mais curto para mim é

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

então para o seu exemplo será

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

a parte boa é que consigo me lembrar disso com Ctrl+r para enviar outro arquivo...

Da máquina de origem

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

Na máquina de destino.Salve o corpo do e-mail recebido como db.sql.gz.b64;então..

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

usando o comando mailx

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

usando 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 `;

Só para adicionar meus 2 centavos, eu escreveria meu próprio script PHP:

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

Existem muitas maneiras de fazer o anexo nos exemplos dessa página.

Não é um método para enviar e-mail, mas você pode usar um servidor Git online (por exemplo,Bitbucket ou um serviço similar) para isso.

Dessa forma, você pode usar git push comandos, e todas as versões serão armazenadas de forma compactada e organizada.

É assim que estou fazendo com um grande arquivo de log no 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 o arquivo for texto, é mais fácil enviá-lo no corpo como:

sendmail recipient@example.com < message.txt

Mailutils torna isso muito fácil

echo "Body" | mail.mailutils -M -s "My Subject" -A attachment.pdf mail@example.org
  • -A file anexa um arquivo
  • -M habilita MIME, para que você possa ter um anexo e um corpo de texto simples.

Se ainda não estiver instalado, execute

sudo apt install mailutils

Mais uma coisa sobre mutt:por padrão, ele usa seu endereço e nome no campo "De:".Se não for o que você precisa, você pode criar um arquivo muttrc alternativo contendo uma string como esta:set from="Meu daemon de e-mail "

Use este arquivo com -F opção de linha de comando.

Se o mutt não estiver funcionando ou não estiver instalado, tente isto-

*#!/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*
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top