E ai! blz... estou encaminhando um fonte de um programa que fiz no C... Estou utilizando Threads e um pouco de Courses... Deve ter um jeito melhor de fazer... mas funciona bem... Só tomem cuidado com as definições...
OBS: lista_busca.txt é um documento com nome para executar a busca, ele deve ser linear (linha a linha) para cada nome...
Estou mandando o fonte + os Anexos no download... espero que ajude alguém... hehehe...

• Download spammer.tar
• Enviar nova versão

Esconder código-fonte

//*************************************************************************//
//*************************************************************************//
//***                                                                   ***//
//***   Definições:                                                     ***//
//***           Entrada de Dados - lista_busca.txt                      ***//
//***           Saida de Dados - lista_email.txt                        ***//
//***           Anexos - Shell_Thread.sh                                ***//
//***                    busca.pl                                       ***//
//***                    expressoes.txt                                 ***//
//***                                                                   ***//
//***   Diretorios:                                                     ***//
//***           /var/spammer                                            ***//
//***           /tmp/spammer                                            ***//
//***   *Todos os aqruivos devem ficar em /var/spammer                  ***//
//***   *O diretorio /tmp/spammer deve ser criado manualmente           ***//
//***                                                                   ***//
//***   Compilando:                                                     ***//
//***   gcc essearquivo.c -lpthread -o essearquivo.bin -lncurses        ***//
//***                                                                   ***//
//*************************************************************************//
//*************************************************************************//

// Includes //
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <time.h>
#include <curses.h>
#define NUM_THREAD 10 //Num maximo = 30 devido o layout da tela

// Definições da Thread //
pthread_mutexattr_t mutex_attr;
pthread_mutex_t trava_flag;
sem_t criado; //Function que trata a existencia da Thread

// Variaveis Globais //
int num_linhas=0; //numero de linhas do arquivo
int linha_atual=0; // Contador de linha executadas
int cont_thread[NUM_THREAD]; //Contador da Thread

// Sub-Rotinas //
void proc_snifer(int *flag); //Thread Sniffer
void tela_principal(void);

// Principal //
int main(void){

    FILE *fb;

// Variaveis Locais //
    int i=0;
    char ch[15];
    
    pthread_t snifer; //Define a Thread
    pthread_t *ptr_sur_thread; // Define a Thread
    sem_init(&criado,0,0); //Inicia a função

// Definições da Tela //
    initscr();  //Esta função inicializa a ncurses. Para todos os programas devemos sempre inicializar a ncurses e depois finalizar.
    start_color();  //Tornando o uso das cores possíveis
    
// Definição dos pares de cores //
    init_pair(1,COLOR_WHITE,COLOR_BLUE); 
    init_pair(2,COLOR_BLUE,COLOR_WHITE);
    init_pair(3,COLOR_RED,COLOR_WHITE); 
    init_pair(4,COLOR_GREEN,COLOR_BLACK);
    init_pair(5,COLOR_BLACK,COLOR_GREEN);
    init_pair(6,COLOR_RED,COLOR_GREEN);
    init_pair(7,COLOR_RED,COLOR_BLACK);
    init_pair(8,COLOR_BLUE,COLOR_BLACK);
   
//Leitura das linhas no aquivo //
    system("wc -l lista_busca.txt | cut -f 1 -d ' ' >>num_lista.txt");
    if ((fb=fopen("num_lista.txt","r")) == NULL){
   attron(COLOR_PAIR(7));
        move(2,5);printw("Nao abriu");
    }
    fscanf(fb,"%d",&num_linhas);
    fclose(fb);
// Fim da Leitura do arquivo

    system("rm /var/spammer/num_lista.txt");
    
// Inicio Sistema Thread
    for(i=0;i<=NUM_THREAD;i++) //Zera o contolador das Thread
   cont_thread[i]=1;
    curs_set(0);
    tela_principal();
    
    while(linha_atual<=num_linhas){ //Enquanto não verificar todas as linhas do arquivo
   for(i=0;i<=NUM_THREAD;i++){ //For Thread Create
       if(cont_thread[i]==1){ // For Thread não existente
      sleep(4);
      ptr_sur_thread=(void*)malloc(sizeof(pthread_t)); //Alocação de espaço da memora para 1 ponteiro
      sleep(1);
           if(ptr_sur_thread!=NULL){ //Verifica a alocação
          pthread_create((void*)&ptr_sur_thread, NULL, (void*)&proc_snifer, &i); //Cria a Thread, passa como parametro a Flag
          pthread_mutex_lock(&trava_flag); //Trava alteração nas variaveis abaixo
          cont_thread[i]=0; // Indica a existencia da Thread
          sem_wait(&criado); // Aguarda a Thread Indicar que existe
          linha_atual+=1; 
          pthread_mutex_unlock(&trava_flag); // Libera as variaves acima
          }
       }
   }
   attron(COLOR_PAIR(7));
   move(NUM_THREAD+5,2);printw("Concluido Start Todas as Threas - Sleep(%d)",NUM_THREAD); //Concluido um Loop Formove(NUM_THREAD+5,2);printw("Concluido Start Todas as Threas - Sleep(%d)",NUM_THREAD*2); //Concluido um Loop For
   refresh();
   tela_principal();
   sleep(NUM_THREAD);
   attron(COLOR_PAIR(7));
   move(NUM_THREAD+5,2);printw("                                           ");
   move(NUM_THREAD+5,2);printw("Ativando Threas Livres"); //Concluido um Loop For
    }
endwin(); /* Sempre que finalizarmos um programa com a biblioteca curses, devemos executar este comando. */
}


void proc_snifer(int *flag){ //Thread Sniffer
    
// Variaveis locais //
    auto int x;
    auto int line;
    char nome[50];
    char nome2[10];

    x=*flag; line=linha_atual; 

    sem_post(&criado); // Notifica o sistema que a Thread existe
    attron(COLOR_PAIR(1));
    move(x+2,2);printw("                                        ", x,line); refresh();
    move(x+2,2);printw("Iniciando Thread - %d  <> Linha %d", x,line); refresh();

    strcpy(nome,"sh /var/spammer/Shell_Thread.sh lista_busca.txt "); // Concatena nomes e endereços
    sprintf(nome2,"%d",line);
    strcat(nome, nome2);
    strcat(nome," ");
    sprintf(nome2,"%d",x);
    strcat(nome,nome2);
    sleep(2);
    system(nome); //Chama a função do Shell ------ valor da variavel "sh/var/spammer/Shell_Thread.sh lista_busca.txt (valor de line) (valor de x)

    pthread_mutex_lock(&trava_flag); //Trava o uso da variavel
    cont_thread[x]=1;
    pthread_mutex_unlock(&trava_flag); // Libera a variavel

    attron(COLOR_PAIR(2));
    move(x+2,2);printw("                                        ", x,line); refresh();
    move(x+2,2);printw("Finalisando Thread - %d", x); refresh();
    }
    
void tela_principal(void){
    int z;
   //Tela de Resumo //
   attron(COLOR_PAIR(4));
   move(1,70); printw("//********************************************//");
   move(2,70); printw("//***       Resumo das Threads             ***//");
   move(3,70); printw("//***                                      ***//");
   for(z=0;z<=NUM_THREAD;z++){ //For de Controle interno
       move(z+4,70); printw("//***     Thread    status =               ***//");}
   attron(COLOR_PAIR(7));
   for(z=0;z<=NUM_THREAD;z++){ //For de Controle interno
       move(z+4,87); printw("%d",z);}    
   for(z=0;z<=NUM_THREAD;z++){ //For de Controle interno
       move(z+4,97); printw("%d",cont_thread[z]);}    
   attron(COLOR_PAIR(4));
   move(z+4,70); printw("//***                                      ***//");
   move(z+5,70); printw("//*** Legenda: 1 = Livre - 0 = Funcionando ***//");
   move(z+6,70); printw("//***                                      ***//");
   move(z+7,70); printw("//****************************************=***//");
   move(z+8,70); printw("//***                                      ***//");
   move(z+9,70); printw("//*** Total de Linhas:                     ***//");
   attron(COLOR_PAIR(7));
   move(z+9,95); printw("%d",num_linhas);
   attron(COLOR_PAIR(4));
   move(z+10,70); printw("//*** Total de Linhas Executadas:          ***//");
   attron(COLOR_PAIR(7));
   move(z+10,105); printw("%d",linha_atual);
   attron(COLOR_PAIR(4));
   move(z+11,70); printw("//***                                      ***//");   
   move(z+12,70); printw("//********************************************//"); 

   refresh();
}

Gerenciamento de Área de Alocação Dinâmica (Listas Encadeadas)

4 EP - Poli USP - LIG4 (LigK)

Driver ATI que funciona

Biblioteca estática para manipulação de pilhas

Cálculo de logaritmo de um número por Série de Taylor em C

Nenhum comentário foi encontrado.