[Source - Download] Gerenciador de conexões - C

[Dark_Side]

Hi,

Para fixar alguns conhecimentos, escrevi um programinha bastante simples capaz de listar todas  as conexões ativas no computador.

Detalhes:

* Lista todas as conexões por endereço local, porta local, endereço remoto e porta remota;

* É possível fechar uma conexão específica;

* Ocasionalmente, pode-se fechar todas as conexões ativas;

* É possível, ainda, fechar conexões que tenham um endereço específico;

* Pode-se fechar conexões que tenham portas locais ou remotas específicas.

Source:

main.c

Code Select Expand

// Compile com as libs: wsock32, comctl32 e iphlpapi

#include  "funcoes.h"
 
 // Inicialização
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
    // Carrega ícone
    ICONE = LoadIcon(hInstance,icon1);
    DialogBox(hInstance,MAKEINTRESOURCE(IDD_DLG),0,(DLGPROC)WindowProc); // Cria form principal
    return 0;
} 

//////////////////////////////////////////////////////////////////////////////////////
         

// Procedure do form principal       
LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{   
        switch(msg)
        {
                   case WM_INITDIALOG: // Na inicialização
                        InitCommonControls(); // Carrega controles comuns
                        hwnd_main = hwnd; // Atribui à variável global "hwnd_main" o handle do form
                   
                       // Define ícones
                       SendMessage(hwnd,WM_SETICON,ICON_BIG,(LPARAM)ICONE);
                       SendMessage(hwnd,WM_SETICON,ICON_SMALL,(LPARAM)ICONE); 
                         
                   
                         // Atribui à variável global "hwnd_main" o handle da lista
                        lista_hwnd = GetDlgItem(hwnd,LISTA);
                        criar_colunas(); // Criar colunas na lista
                     
                      // Tenta obter conexões
                      if(!obter_conexoes())
                        {
                        MessageBox(hwnd,"Oc orreu um erro ao obter a lista de portas abertas","Erro",0x10);
                        ExitProcess(1);
                        }
                        break;
                                 
                  case WM_CTLCOLORDLG: // Cor do form
                       SetBkMode((HDC)wParam,0);
                       return (long)CreateSolidBrush(0x0); // Fundo preto
                       break;     
 
                 case WM_CTLCOLORSTATIC: // Cor dos labels
                      SetBkMode((HDC)wParam,0);
                      return (long)CreateSolidBrush(0x0); // Fundo preto
                      break;
                     
                  case WM_NOTIFY: // Eventos
                       if(LOWORD(wParam) == LISTA) // Evento ocorrido com a lista ?
                       {
                       POINT pos;
                         LPNMHDR evento = (LPNMHDR)lParam;
                         if(evento->code == NM_RCLICK) { // Verifica se o evento = clique com botão direito
                         HMENU Menu = CreatePopupMenu(); // Cria um menu PopUp
                         AppendMenu(Menu, MF_STRING, POPUP_FECHAR, "Fechar conexão"); // Adicione submenu
                         GetCursorPos(&pos); // Obtém posição do mouse
                         TrackPopupMenu(Menu, 0, pos.x, pos.y, 0, hwnd, NULL);} // Mostra o menu nesta posição
                         
                       }
                     break;
                     
                     
                  case WM_COMMAND: // Clique
                       switch(wParam)
                       {
                       case POPUP_FECHAR: // Menu popup
                            verifica_fechar(); // Confirma se a conexão deve ser fechada
                            break;
                           
                       case IDM_ATUALIZAR: // Menu Atualizar
                            obter_conexoes(); // Obtém-se novamente a lisra de conexões
                            break; 
                               
                       case IDM_SAIR: // Menu sair
                            PostQuitMessage(0); // Encerra
                            break;

                       case IDM_FECHA_SEL: // Menu Fechar selecionada
                            verifica_fechar();
                            break;
     
                       case IDM_FECHA_TODAS: // Fechar todas
                            fechar_todas();
                            break;
     
                       case IDM_FECHA_PORTA: // Fechar por porta
                            DialogBox(GetModuleHandle(NULL),MAKEINTRESOURCE(IDD_PROCURA_PORTA),0,(DLGPROC)ProcuraPortaProc);
                            break;
     
                       case IDM_FECHA_ADDR: // Fechar por endereço
                            DialogBox(GetModuleHandle(NULL),MAKEINTRESOURCE(IDD_PROCURA_ADDR),0,(DLGPROC)ProcuraAddrProc);
                            break;}
                      break;           
                 
                  case WM_CLOSE: // Botão fechar
                       PostQuitMessage(0);
                       break;
                 
                   }
        return 0;
        }

//////////////////////////////////////////////////////////////////////////////////////


// Procedure do form ProcuraPorta
LRESULT CALLBACK ProcuraPortaProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        switch(msg)
        {
       
         case WM_INITDIALOG:
              // Obtém handles dos objetos - variáveis globais
              porta_hwnd = GetDlgItem(hwnd,porta_txt);
              op1 = GetDlgItem(hwnd,op_local);
              op2 = GetDlgItem(hwnd,op_remota);
             
              // Checa a primeira opção -> porta local
              SendMessage(op1,BM_SETCHECK,1,0);
              break;
                       
                 
         case WM_COMMAND:
              if(wParam == ok_btn) // Verifica clique no botão OK
              {
                         
                         
               int tam = GetWindowTextLength(porta_hwnd);
               if(!tam) { // Verifica se algo foi digitado
                        MessageBox(hwnd,"Digite um valor válido!","Erro",0x30);
                        SetFocus(porta_hwnd);
                        break;
                        }
              char buffer[0xA];
              GetWindowText(porta_hwnd,buffer,0xA); // Obtém o que foi digitado
              int checado = SendMessage(op1,BM_GETCHECK,0,0);
             
              switch(checado) // Verifica qual opção foi marcada
              {
                  case BST_CHECKED: // Porta local
                       fechar_porta_local(atol(buffer));
                       EndDialog(hwnd,0);
                       break;
                       
                  case BST_UNCHECKED: // Porta remota
                       fechar_porta_remota(atol(buffer));
                       EndDialog(hwnd,0);
                       break;
                           
              }
             
              }
              break;
             
         case WM_CLOSE: // Botão fechar
              EndDialog(hwnd,0);
              break;
              }
             
return 0;
}
//////////////////////////////////////////////////////////////////////////////////////



LRESULT CALLBACK ProcuraAddrProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
        switch(msg)
        {
       
         case WM_INITDIALOG:
                    // Obtém handles dos objetos - variáveis glovais
              ip_hwnd = GetDlgItem(hwnd,addr_txt);
              op3 = GetDlgItem(hwnd,addr_local);
              op4 = GetDlgItem(hwnd,addr_remoto);
             
              SetWindowText(ip_hwnd,"0.0.0.0"); // Inicializa campo
              SendMessage(op3,BM_SETCHECK,1,0); // Marca primeira opção - endereço local
              break;
                               
             
        case WM_COMMAND:
              if(wParam == ok_btn2) // Clique no botão OK ?
              {
                         
                         
              char buffer[0x10];
              GetWindowText(ip_hwnd,buffer,0x10); // Obtém IP digitado
              int checado = SendMessage(op3,BM_GETCHECK,0,0);
             
              switch(checado) // Verifica opção
              { 
                  case BST_CHECKED: // Local
                       fechar_addr_local(buffer);
                       EndDialog(hwnd,0);
                       break;
                       
                  case BST_UNCHECKED: // Remoto
                       fechar_addr_remoto(buffer);
                       EndDialog(hwnd,0);
                       break;
                               
              }
               
         case WM_CLOSE:
              EndDialog(hwnd,0);
              break;
              }
}             
return 0;
}
//////////////////////////*/c//////////////////////////////////////////////////




 
funcoes.h

Code Select Expand

#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <commctrl.h>
#include <winsock.h>
#include <iphlpapi.h>

#include "recurso.h"

HICON ICONE;
int obter_conexoes();
int num_itens();

void criar_colunas();
void add_item(int item_index, int subitem, char * texto);
void obter_item(int item_index, int subitem, char * buffer, int num);

void verifica_fechar();

void fechar_con(char * addr1, DWORD porta1, char* addr2, DWORD porta2);

void fechar_sel(int i);
void fechar_todas();

void fechar_porta_local(DWORD porta);
void fechar_porta_remota(DWORD porta);

void fechar_addr_local(char *  addr);
void fechar_addr_remoto(char * addr);

LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK ProcuraPortaProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK ProcuraAddrProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

HWND hwnd_main,lista_hwnd, porta_hwnd, ip_hwnd, op1, op2, op3, op4;

LVCOLUMN col;
LVITEM item;

PMIB_TCPTABLE TcpTable;
DWORD tamanho_buffer;
MIB_TCPROW TcpCon;

int i,item_num,num;

char  ip_local[0x10],  ip_remoto[0x10];
char porta_local[8], porta_remota[8];

////////////////////////////////////////////////////////////////////////////////////
void criar_colunas()
{
 
ZeroMemory(&col,sizeof(col)); //Zera estrutura
col.mask=LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM; //Define estilo

col.cx=0x75; //Largura
col.pszText="Endereço Local";
SendMessage(lista_hwnd,LVM_INSERTCOLUMN,0,(LPARAM)&col); //Adiciona coluna

col.cx=0x50;         
col.pszText="Porta Local";
SendMessage(lista_hwnd,LVM_INSERTCOLUMN,1,(LPARAM)&col);

col.cx=0x75;         
col.pszText="Endereço Remoto";
SendMessage(lista_hwnd,LVM_INSERTCOLUMN,2,(LPARAM)&col);

col.cx=0x50;         
col.pszText="Porta Remota";
SendMessage(lista_hwnd,LVM_INSERTCOLUMN,3,(LPARAM)&col);

}
/////////////////////////////////////////////////////////////////////////////////////

void add_item(int item_index, int subitem, char * texto)
{
ZeroMemory(&item,sizeof(item)); //Zera estrutura
item.mask=LVIF_TEXT;

if(!subitem){ // Verifica se trata-se de um item
item.pszText=texto;
SendMessage(lista_hwnd,LVM_INSERTITEM,0,(LPARAM)&item);   // Insere um item ao invés de um subitem
}
else // Se não
{
item.iSubItem=subitem;
item.pszText=texto;
SendMessage(lista_hwnd,LVM_SETITEM,0,(LPARAM)&item);  // Adiciona um subitem

}
}

/////////////////////////////////////////////////////////////////////////////////////


void obter_item(int item_index, int subitem, char * buffer, int num)
{
ZeroMemory(&item,sizeof(item));
item.mask=LVIF_TEXT;

item.iSubItem=subitem;
item.pszText=buffer; // Buffer onde o texto será armazenado
item.cchTextMax=num;
SendMessage(lista_hwnd,LVM_GETITEMTEXT, item_index, (LPARAM)&item);     //Atribui o itém selecionado à variável

}
/////////////////////////////////////////////////////////////////////////////////////

 
int num_itens()
 {
     return SendMessage(lista_hwnd,LVM_GETITEMCOUNT,0,0); // Retorna o número de itens
 }
     
/////////////////////////////////////////////////////////////////////////////////////

int obter_conexoes(){

SendMessage(lista_hwnd,LVM_DELETEALLITEMS, 0,0);     // Limpa itens

TcpTable = (PMIB_TCPTABLE)malloc(sizeof(TcpTable)); // Aloca espaço

// Se necessário, realoca
if(GetTcpTable(TcpTable,&tamanho_buffer,TRUE) == ERROR_INSUFFICIENT_BUFFER)
{
free(TcpTable);
TcpTable = (PMIB_TCPTABLE)malloc(tamanho_buffer);
if(GetTcpTable(TcpTable,&tamanho_buffer,TRUE) != NO_ERROR) return 0;
}


item_num = 0; // Começar pelo item 0

for(i = 0; i < TcpTable->dwNumEntries; i++) // Número de conexões
 {
 
  if(TcpTable->table[i].dwState == MIB_TCP_STATE_ESTAB){ // Verifica se o estado = estabelecida

/* Escreve nos buffer:

ip_local     = Ip Local;
porta_local  = Porta Local;
ip_remoto    = Ip do Host;
porta_remota = Porta do Host.
                             
*/   

snprintf(ip_local,0x10,"%s",inet_ntoa(*(struct in_addr*)&TcpTable->table[i].dwLocalAddr));
snprintf(porta_local,8,"%ld",htons(TcpTable->table[i].dwLocalPort));
snprintf(ip_remoto,0x10,"%s",inet_ntoa(*(struct in_addr*)&TcpTable->table[i].dwRemoteAddr));
snprintf(porta_remota,8,"%ld",htons(TcpTable->table[i].dwRemotePort));

add_item(item_num,0,ip_local);  // Adiciona item

// Adicione subitens
add_item(item_num,1,porta_local);
add_item(item_num,2,ip_remoto);
add_item(item_num,3,porta_remota);

item_num++; // Incrementa número do item
}}

free(TcpTable);  // Libera buffer
return 1;
}
/////////////////////////////////////////////////////////////////////////////////////


void verifica_fechar()
{

// Verifica item selecionado
int item_selec =  SendMessage(lista_hwnd,LVM_GETNEXTITEM,-1,LVNI_SELECTED);

if(item_selec == -1) return; // Aborta caso nenhum esteja

// Confirma fechamento da conexão
int conf = MessageBox(hwnd_main,"Tem certeza que deseja fechar esta conexão?","Fechar conexão...",MB_YESNO + 0x30);
if(conf == IDYES) {
   fechar_sel(item_selec); // Fecha item selecionado
   obter_conexoes(); // Atualiza a lista
}
}
/////////////////////////////////////////////////////////////////////////////////////


void fechar_con(char * addr1, DWORD porta1, char* addr2, DWORD porta2)
{
TcpCon.dwLocalAddr = inet_addr(addr1); // Define o  Ip local
TcpCon.dwRemoteAddr = inet_addr(addr2); // Ip remoto
TcpCon.dwLocalPort = htons(porta1); // Porta local
TcpCon.dwRemotePort = htons(porta2); // Porta remota
TcpCon.dwState = MIB_TCP_STATE_DELETE_TCB; // estado = deletar conexão
SetTcpEntry(&TcpCon); // Fecha a conexão


}
/////////////////////////////////////////////////////////////////////////////////////


void fechar_sel(int i){

// Obtém cada valor (ip local, porta local, ip remoto e porta remota)
obter_item(i,0,ip_local,0x10);
obter_item(i,1,porta_local,8);
obter_item(i,2,ip_remoto,0x10);
obter_item(i,3,porta_remota,8);

fechar_con(ip_local,atol(porta_local),ip_remoto,atol(porta_remota)); // Fecha a conexão

   
}
/////////////////////////////////////////////////////////////////////////////////////

void fechar_todas()
{
     num = num_itens(); // Obtém número de itens
     for(i = 0;i<num;i++) // Percorre todos
          fechar_sel(i); // Fecha cada um

    obter_conexoes(); // Atualiza lista
 }
/////////////////////////////////////////////////////////////////////////////////////


void fechar_porta_local(DWORD porta)
{

  num = num_itens();
  for(i = 0;i<num;i++){

obter_item(i,1,porta_local,8); // Obtém porta local

if(atol(porta_local) == porta){ // Verifica se é a mesma especificada

// Obtém demais dados
obter_item(i,0,ip_local,0x10);
obter_item(i,2,ip_remoto,0x10);
obter_item(i,3,porta_remota,8);

// Fecha a conexão
fechar_con(ip_local,atol(porta_local),ip_remoto,atol(porta_remota));
             
}
}
obter_conexoes(); // Atualiza
}
/////////////////////////////////////////////////////////////////////////////////////



 void fechar_porta_remota(DWORD porta)
 {
     num = num_itens();
     for(i = 0 ;i<num;i++){

obter_item(i,3,porta_remota,8); // Obtém porta remota

if(atol(porta_remota) == porta){ // verifica

// Obtém demais dados
obter_item(i,0,ip_local,0x10);
obter_item(i,1,porta_local,8);
obter_item(i,2,ip_remoto,0x10);

// Fecha conexão
fechar_con(ip_local,atol(porta_local),ip_remoto,atol(porta_remota));

}
}
obter_conexoes();

}
/////////////////////////////////////////////////////////////////////////////////////


void fechar_addr_local(char *addr)
{
     num = num_itens();
     for(i = 0 ;i<num;i++){

obter_item(i,0,ip_local,0x10); // Obtém IP local

if(strcmp(ip_local,addr) == 0){ // Verifica

// Obtém demais dados
obter_item(i,1,porta_local,8);
obter_item(i,2,ip_remoto,0x10);
obter_item(i,3,porta_remota,8);

// Fecha a conexão
fechar_con(ip_local,atol(porta_local),ip_remoto,atol(porta_remota));
}
}
obter_conexoes();
}
/////////////////////////////////////////////////////////////////////////////////////


 void fechar_addr_remoto(char * addr)
 {
     num = num_itens();
     for(i = 0 ;i<num;i++){

obter_item(i,2,ip_remoto,0x10); // Obtém IP remoto

if(strcmp(ip_remoto,addr) == 0){ // Verifica

// Obtém demais dados
obter_item(i,0,ip_local,0x10);
obter_item(i,1,porta_local,8);
obter_item(i,3,porta_remota,8);
 
// Fecha conexão
fechar_con(ip_local,atol(porta_local),ip_remoto,atol(porta_remota));

}
}
obter_conexoes(); // Atualiza

}
/////////////////////////////////////////////////////////////////////////////////////




recurso.h

Code Select Expand

#define icon1 0


#define IDD_DLG 1000
#define IDC_GRP1 1001
#define LISTA 1002
#define POPUP_FECHAR 1003
//////////////////////////////////////////////////////////////////////////////////////

#define IDD_PROCURA_PORTA 2000
#define IDC_GRP2 2001
#define IDC_STC1 2002
#define porta_txt 2003
#define op_local 2004
#define op_remota 2005
#define ok_btn 2006

//////////////////////////////////////////////////////////////////////////////////////

#define IDD_PROCURA_ADDR 3000
#define IDC_GRP3 3001
#define IDC_STC2 3002
#define addr_txt 3003
#define addr_local 3004
#define addr_remoto 3005
#define ok_btn2 3006

//////////////////////////////////////////////////////////////////////////////////////

#define ID_MENU 10000
#define IDM_MENU_PRINC 10001
#define IDM_ATUALIZAR 10002
#define IDM_SAIR 10003
#define IDM_CON 10004
#define IDM_FECHA_SEL 10005
#define IDM_FECHA_TODAS 10006
#define IDM_FECHA_PORTA 10007
#define IDM_FECHA_ADDR 10008




recurso.rc

Code Select Expand

#include "recurso.h"

IDD_DLG DIALOGEX 6,5,288,256
CAPTION "Gerenciador de Conexões by Dark Side"
FONT 8,"MS Sans Serif",0,0
MENU ID_MENU
STYLE 0x90CA0800
BEGIN
  CONTROL "Conexões estabelecidas",IDC_GRP1,"Button",0x50000007,6,3,278,246
  CONTROL "",LISTA,"SysListView32",0x50010005,10,12,268,233,0x00000200
END
ID_MENU MENU
BEGIN
  POPUP "&Menu"
  BEGIN
    MENUITEM "&Atualizar lista",IDM_ATUALIZAR
    MENUITEM "Sai&r",IDM_SAIR
  END
  POPUP "&Conexões"
  BEGIN
    MENUITEM "&Fechar a selecionada",IDM_FECHA_SEL
    MENUITEM "F&echar todas\t",IDM_FECHA_TODAS
    MENUITEM "&Fechar por porta",IDM_FECHA_PORTA
    MENUITEM "Fech&ar por endereço",IDM_FECHA_ADDR
  END
END
IDD_PROCURA_PORTA DIALOGEX 6,6,207,91
CAPTION "Fechar conexão por porta..."
FONT 8,"MS Sans Serif",0,0
STYLE 0x10CC0800
EXSTYLE 0x00000080
BEGIN
  CONTROL "Informações sobre a porta...",IDC_GRP2,"Button",0x50000007,6,0,196,85
  CONTROL "Porta:",IDC_STC1,"Static",0x50000000,10,16,76,9
  CONTROL "",porta_txt,"Edit",0x50012000,30,16,32,11,0x00000200
  CONTROL "Procurar por porta local",op_local,"Button",0x50010009,10,31,106,17
  CONTROL "Procurar por porta remota",op_remota,"Button",0x50010009,10,51,106,19
  CONTROL "&OK!",ok_btn,"Button",0x50010001,166,70,30,13
END
IDD_PROCURA_ADDR DIALOGEX 6,6,207,91
CAPTION "Fechar conexão por endereço.."
FONT 8,"MS Sans Serif",0,0
STYLE 0x10CC0800
EXSTYLE 0x00000080
BEGIN
  CONTROL "Informações sobre o endereço...",IDC_GRP2,"Button",0x50000007,6,0,196,85
  CONTROL "IP:",IDC_STC1,"Static",0x50000000,10,16,76,9
  CONTROL "Procurar por IP local",addr_local,"Button",0x50010009,10,31,106,17
  CONTROL "Procurar por IP remoto",addr_remoto,"Button",0x50010009,10,51,106,19
  CONTROL "&OK!",ok_btn2,"Button",0x50010001,166,70,30,13
  CONTROL "",addr_txt,"SysIPAddress32",0x50010000,22,16,104,11
END

icon1 ICON DISCARDABLE "icone.ico"
1 24 "manifest.xml"

Segue agora o download do SOURCE (projeto DEV C++) + executável:

Arquivo em Anexo - Security Ðarkers - wWw.darkers.com.br

É isso...
Bye

[Anonymous]

Hummm, parece legal, vo testar...e valeu por compartilhar...