Example #1
0
def backup(ip, porta, senha, arquivos, local):
    """ Função que solicita ao host alvo os arquivos a serem becapeados, recebe
    um arquivo compactado com os arquivos solicitados, e armazena o arquivo
    especificado num diretório passado como parâmetro. Possui como parâmetros
    de entrada o endereço "ip" do host alvo; o número da "porta" que a
    aplicação remota do host alvo utiliza para receber requisições; a "senha"
    para se contactar ao host alvo; uma tupla com a relação de "arquivos" que
    serão becapeados; e o "local" onde o arquivo compactado de backup será
    armazenado.
    """
    # Tenta fazer conexão com host remoto
    s_ssl = cria_socket(ip, porta)

    # 1a. conexão: ENVIANDO =======================================================
    # Envia senha para conexão ao host
    try:
        s_ssl.write(senha)
    except ssl.SSLError:
        gera_log("Erro ao enviar senha")
        s_ssl.close()
        exit()

    # 2a. conexão: RECEBENDO ======================================================
    # Recebe status da aceitação ou não da senha
    try:
        recebido = s_ssl.read()
    except ssl.SSLError:
        gera_log("Conexão encerrada por {}".format(ip))
        s_ssl.close()
        exit()

    if recebido == "Senha incorreta":
        gera_log("Senha incorreta do host {}".format(ip))
        gera_log("Encerrando conexão com {}".format(ip))
        s_ssl.close()
        exit()

    # 3a. conexão: ENVIANDO =======================================================
    # Enviando uma tupla com a relação de arquivos para backup
    try:
        s_ssl.write(pickle.dumps(arquivos))
    except:
        gera_log("Erro ao enviar relação de arquivos")
        s_ssl.close()
        exit()

    # 4a. conexão: RECEBENDO ======================================================
    # Recebendo o nome do arquivo compactado
    try:
        recebido = s_ssl.read()
    except ssl.SSLError:
        gera_log("Conexão encerrada por {}".format(ip))
        s_ssl.close()
        exit()

    name_file = recebido.split("/")[-1].strip("\n")
    name_file = "{0}-{1}-{2}".format(name_file.split("-", 1)[0], ip, name_file.split("-", 1)[1])

    # 5a. conexão: RECEBENDO ======================================================
    # Recebendo e gravando o arquivo compactado
    if not local.find("/", -1) == len(local) - 1:
        local = "{}/".format(local)

    while True:
        try:
            recebido = s_ssl.read()
        except ssl.SSLError:
            break

        if not recebido:
            break

        with open("{0}{1}".format(local, name_file), "ab") as f:
            f.write(recebido)

    gera_log("Arquivo {0} copiado de {1}".format(name_file, ip))

    # Encerrando a conexão
    s_ssl.close()
Example #2
0
def backup():
    ''' Função que recebe do servidor de backup uma relação de arquivos que
    serão becapeados e devolve a esse servidor um arquivo compactado contendo
    todos os arquivos solicitados, além de armazenar localmente uma cópia desse
    arquivo. Antes de atender a solicitação do servidor de backup, verifica se
    a senha informada está correta.
    '''
    # Cria socket
    s_ssl = cria_socket(PORTA, CHAVE_PRIVADA, CERTIFICADO)

    # Loop que permite o script ficar a espera de conexão do servidor de backup
    while True:
        # Recebe solicitação de conexão
        con, info_cliente = s_ssl.accept()
        gera_log('Conexão estabelecida por {}'.format(info_cliente))

# 1a. conexão: RECEBENDO ======================================================
        # Recebe a senha fornecida pelo servidor de backup
        try:
            dados = con.recv(128)
        except ssl.SSLError:
            gera_log('Conexão encerrada com {}'.format(info_cliente))
            con.close()
            continue

# 2a. conexão: ENVIANDO =======================================================
        # Verifica se a senha está correta
        if dados == SENHA:
            try:
                con.send('Sucesso na autenticação')
                gera_log('Sucesso na autenticação')
            except ssl.SSLError:
                gera_log('Conexão encerrada por {}'.format(info_cliente))
                con.close()
                continue
        else:
            sleep(10)
            try:
                con.send('Senha incorreta')
                gera_log('Senha incorreta')
            except ssl.SSLError:
                gera_log('Conexão encerrada por {}'.format(info_cliente))
                con.close()
                continue
            gera_log('Conexão encerrada com {}'.format(info_cliente))
            con.close()
            continue

# 3a. conexão: RECEBENDO ======================================================
        # Recebe uma tupla com a relação de arquivos a serem compactados
        try:
            dados = con.recv(1024)
        except ssl.SSLError:
            gera_log('Conexão encerrada com {}'.format(info_cliente))
            con.close()
            continue
        arquivos = pickle.loads(dados)

        # Realiza compactação dos arquivos e obtem o nome do arquivo de backup
        compactado = compacta(arquivos, LOCAL)

# 4a. conexão: ENVIANDO =======================================================
        # Informa ao servidor de backup o nome do arquivo de backup
        try:
            con.send(compactado)
        except:
            gera_log('Erro ao enviar nome de arquivo ao servidor')
            con.close()
            continue

# 5a. conexão: ENVIANDO =======================================================
        # Transfere o arquivo compactado
        try:
            with open(compactado, 'rb') as f:
                for i in f:
                    con.send(i)
        except:
            gera_log('Erro ao enviar arquivo compactado')
            con.close()
            continue

        gera_log('Arquivo {0} enviado ao servidor em {1}'
                 .format(compactado, info_cliente))

        # Encerra ciclo de conexões de uma solicitação de backup
        con.close()
        gera_log('Conexão com o servidor {} encerrada'.format(info_cliente))

    # Fecha o socket usado para transmissão
    s_ssl.close()