|
//
**************************************************
// Les include
// **************************************************
#include "stdafx.h"
#include "FrameIp.h"
#include "FrameIpDlg.h"
#include "class_ip_address.h"
#include "windows.h"
#include <C:\\RepPerso\\Personnel\\Developpement\\Projets\\LibrairieSocket\\LibrairieSocket.h>
#include ".\frameipdlg.h"
// **************************************************
// Les variables
// **************************************************
struct ipv4 entete_ipv4;
// Structure
de l'entête IP
struct icmp entete_icmp;
// Structure de l'entête ICMP
struct igmp entete_igmp;
// Structure de l'entête IGMP
struct tcp entete_tcp;
// Structure de l'entête TCP
struct udp entete_udp;
// Structure de l'entête UDP
BOOL initialisation=FALSE;
// Permet de savoir si la fenetre est présente ou pas
char
data[65535];
// chaine data qui sera émise
unsigned int sortie_de_la_boucle;
// Variable permettant de gérer la sortie de la boucle
unsigned int nombre_de_trame_emise;
// Compte le nombre de trame emise
SOCKET id_de_la_socket;
// Identification des socket
int nombre_de_caractere_emis;
// Variable récupérant le nombre de caractères émis
// **************************************************
// Les variables temporaires
// **************************************************
char tampon_char[65535];
char tampon_char2[65535];
int tampon_int;
CString tampon_cstring;
// **************************************************
// Les variables externes permetant le dialogue entre les différents cpp
// **************************************************
extern DWORD class_ip_address_retour_de_fenetre; // Nombre Inet_addr
retourné par l'utilisateur
extern BOOL class_ip_address_selection;
// Permet de choisir la selection par defaut à l'ouverture
de la fenetre
// **************************************************
// Les Fonctions
// **************************************************
void CFrameIpDlg::On_button_about()
{
// ********************************************************
// Concatenation de l'affichage
// ********************************************************
sprintf(tampon_char,"
FrameIp Version 1.5.3.8");
sprintf(tampon_char,"%s\n",tampon_char);
sprintf(tampon_char,"%s\n Create on April 26, 2003 - Last
compilation on August 25, 2004",tampon_char);
sprintf(tampon_char,"%s\n SebF@FrameIp.Com -
www.FrameIp.Com",tampon_char);
sprintf(tampon_char,"%s\n\n",tampon_char);
// ********************************************************
// Affichage de l'About en mode fenêtre
// ********************************************************
MessageBox(tampon_char,"About",0);
}
CFrameIpDlg::CFrameIpDlg(CWnd* pParent) : CDialog(CFrameIpDlg::IDD,pParent)
, m_edit_ip_source(_T(""))
{
m_edit_data = _T("");
m_edit_size = 0;
m_edit_icmp_checksum = 0;
m_edit_icmp_code = 0;
m_edit_icmp_id = 0;
m_edit_icmp_sequence = 0;
m_edit_icmp_type = 0;
m_edit_ip_checksum = 0;
m_edit_ip_destination = _T("");
m_edit_ip_flags = 0;
m_edit_ip_id = 0;
m_edit_ip_ihl = 0;
m_edit_ip_length = 0;
m_edit_ip_offset = 0;
m_edit_ip_tos = 0;
m_edit_ip_ttl = 0;
m_edit_ip_type = 0;
m_edit_ip_version = 0;
m_edit_layer_ip = _T("");
m_edit_layer_4 = _T("");
m_edit_igmp_checksum = 0;
m_edit_igmp_reserved = 0;
m_edit_igmp_type = 0;
m_edit_igmp_version = 0;
m_edit_igmp_destination = _T("");
m_edit_tcp_ack = 0;
m_edit_tcp_checksum = 0;
m_edit_tcp_destination_port = 0;
m_edit_tcp_offset = 0;
m_edit_tcp_pointer = 0;
m_edit_tcp_reserved = 0;
m_edit_tcp_sequence = 0;
m_edit_tcp_source_port = 0;
m_edit_tcp_window = 0;
m_edit_udp_checksum = 0;
m_edit_udp_destination_port = 0;
m_edit_udp_length = 0;
m_edit_udp_source_port = 0;
m_static_layer_4 = _T("");
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CFrameIpDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
DDX_Control(pDX, IDC_spin_udp_source_port,
m_spin_udp_source_port_control);
DDX_Control(pDX, IDC_spin_udp_destination_port,
m_spin_udp_destination_port_control);
DDX_Control(pDX, IDC_spin_tcp_window,
m_spin_tcp_window_control);
DDX_Control(pDX, IDC_spin_tcp_source_port,
m_spin_tcp_source_port_control);
DDX_Control(pDX, IDC_spin_tcp_reserved,
m_spin_tcp_reserved_control);
DDX_Control(pDX, IDC_spin_tcp_pointer,
m_spin_tcp_pointer_control);
DDX_Control(pDX, IDC_spin_tcp_destination_port,
m_spin_tcp_destination_port_control);
DDX_Control(pDX, IDC_spin_icmp_type,
m_spin_icmp_type_control);
DDX_Control(pDX, IDC_spin_icmp_sequence,
m_spin_icmp_sequence_control);
DDX_Control(pDX, IDC_spin_icmp_id,
m_spin_icmp_id_control);
DDX_Control(pDX, IDC_spin_icmp_code,
m_spin_icmp_code_control);
DDX_Control(pDX, IDC_spin_igmp_version,
m_spin_igmp_version_control);
DDX_Control(pDX, IDC_spin_igmp_type,
m_spin_igmp_type_control);
DDX_Control(pDX, IDC_spin_igmp_reserved,
m_spin_igmp_reserved_control);
DDX_Control(pDX, IDC_edit_udp_destination_port,
m_edit_udp_destination_port_control);
DDX_Control(pDX, IDC_edit_tcp_window,
m_edit_tcp_window_control);
DDX_Control(pDX, IDC_edit_tcp_source_port,
m_edit_tcp_source_port_control);
DDX_Control(pDX, IDC_edit_tcp_sequence,
m_edit_tcp_sequence_control);
DDX_Control(pDX, IDC_edit_tcp_reserved,
m_edit_tcp_reserved_control);
DDX_Control(pDX, IDC_edit_tcp_pointer,
m_edit_tcp_pointer_control);
DDX_Control(pDX, IDC_edit_tcp_offset,
m_edit_tcp_offset_control);
DDX_Control(pDX, IDC_edit_tcp_destination_port,
m_edit_tcp_destination_port_control);
DDX_Control(pDX, IDC_edit_tcp_checksum,
m_edit_tcp_checksum_control);
DDX_Control(pDX, IDC_edit_tcp_ack,
m_edit_tcp_ack_control);
DDX_Control(pDX, IDC_edit_udp_source_port,
m_edit_udp_source_port_control);
DDX_Control(pDX, IDC_edit_udp_length,
m_edit_udp_length_control);
DDX_Control(pDX, IDC_edit_udp_checksum,
m_edit_udp_checksum_control);
DDX_Control(pDX, IDC_edit_igmp_version,
m_edit_igmp_version_control);
DDX_Control(pDX, IDC_edit_igmp_type,
m_edit_igmp_type_control);
DDX_Control(pDX, IDC_edit_igmp_reserved,
m_edit_igmp_reserved_control);
DDX_Control(pDX, IDC_edit_igmp_destination,
m_edit_igmp_destination_control);
DDX_Control(pDX, IDC_edit_igmp_checksum,
m_edit_igmp_checksum_control);
DDX_Control(pDX, IDC_edit_icmp_type,
m_edit_icmp_type_control);
DDX_Control(pDX, IDC_edit_icmp_sequence,
m_edit_icmp_sequence_control);
DDX_Control(pDX, IDC_edit_icmp_id,
m_edit_icmp_id_control);
DDX_Control(pDX, IDC_edit_icmp_code,
m_edit_icmp_code_control);
DDX_Control(pDX, IDC_edit_icmp_checksum,
m_edit_icmp_checksum_control);
DDX_Control(pDX, IDC_check_icmp_header,
m_check_icmp_header_control);
DDX_Control(pDX, IDC_check_udp_header,
m_check_udp_header_control);
DDX_Control(pDX, IDC_check_tcp_header,
m_check_tcp_header_control);
DDX_Control(pDX, IDC_check_igmp_header,
m_check_igmp_header_control);
DDX_Control(pDX, IDC_edit_layer_4,
m_edit_layer_4_control);
DDX_Control(pDX, IDC_edit_layer_data,
m_edit_layer_data_control);
DDX_Control(pDX, IDC_edit_layer_ip,
m_edit_layer_ip_control);
DDX_Control(pDX, IDC_edit_number,
m_edit_number_control);
DDX_Control(pDX, IDC_spin_ip_ttl,
m_spin_ip_ttl_control);
DDX_Control(pDX, IDC_spin_timeout,
m_spin_timeout_control);
DDX_Control(pDX, IDC_spin_number,
m_spin_number_control);
DDX_Control(pDX, IDC_spin_ip_version,
m_spin_ip_version_control);
DDX_Control(pDX, IDC_spin_ip_tos,
m_spin_ip_tos_control);
DDX_Control(pDX, IDC_spin_ip_offset,
m_spin_ip_offset_control);
DDX_Control(pDX, IDC_spin_ip_ihl,
m_spin_ip_ihl_control);
DDX_Control(pDX, IDC_spin_ip_id,
m_spin_ip_id_control);
DDX_Control(pDX, IDC_check_permenent,
m_check_permenent_control);
DDX_Control(pDX, IDC_check_data,
m_check_data_control);
DDX_Control(pDX, IDC_edit_size,
m_edit_size_control);
DDX_Control(pDX, IDC_edit_data,
m_edit_data_control);
DDX_Text(pDX, IDC_edit_data, m_edit_data);
DDX_Text(pDX, IDC_edit_size, m_edit_size);
DDV_MinMaxUInt(pDX, m_edit_size, 0, 65535);
DDX_Text(pDX, IDC_edit_icmp_checksum,
m_edit_icmp_checksum);
DDV_MinMaxUInt(pDX, m_edit_icmp_checksum, 0,
65535);
DDX_Text(pDX, IDC_edit_icmp_code,
m_edit_icmp_code);
DDV_MinMaxUInt(pDX, m_edit_icmp_code, 0, 255);
DDX_Text(pDX, IDC_edit_icmp_id, m_edit_icmp_id);
DDV_MinMaxUInt(pDX, m_edit_icmp_id, 0, 65535);
DDX_Text(pDX, IDC_edit_icmp_sequence,
m_edit_icmp_sequence);
DDV_MinMaxUInt(pDX, m_edit_icmp_sequence, 0,
65535);
DDX_Text(pDX, IDC_edit_icmp_type,
m_edit_icmp_type);
DDV_MinMaxUInt(pDX, m_edit_icmp_type, 0, 255);
DDX_Text(pDX, IDC_edit_ip_checksum,
m_edit_ip_checksum);
DDV_MinMaxUInt(pDX, m_edit_ip_checksum, 0,
65535);
DDX_Text(pDX, IDC_edit_ip_destination,
m_edit_ip_destination);
DDV_MinMaxUInt(pDX, m_edit_ip_flags, 0, 65535);
DDX_Text(pDX, IDC_edit_ip_id, m_edit_ip_id);
DDV_MinMaxUInt(pDX, m_edit_ip_id, 0, 65535);
DDX_Text(pDX, IDC_edit_ip_ihl, m_edit_ip_ihl);
DDV_MinMaxUInt(pDX, m_edit_ip_ihl, 0, 15);
DDX_Text(pDX, IDC_edit_ip_length,
m_edit_ip_length);
DDV_MinMaxUInt(pDX, m_edit_ip_length, 0, 65535);
DDX_Text(pDX, IDC_edit_ip_offset,
m_edit_ip_offset);
DDV_MinMaxUInt(pDX, m_edit_ip_offset, 0, 8191);
DDX_Text(pDX, IDC_edit_ip_tos, m_edit_ip_tos);
DDV_MinMaxUInt(pDX, m_edit_ip_tos, 0, 255);
DDX_Text(pDX, IDC_edit_ip_ttl, m_edit_ip_ttl);
DDV_MinMaxUInt(pDX, m_edit_ip_ttl, 0, 255);
DDX_Text(pDX, IDC_edit_ip_type, m_edit_ip_type);
DDV_MinMaxUInt(pDX, m_edit_ip_type, 0, 255);
DDX_Text(pDX, IDC_edit_ip_version,
m_edit_ip_version);
DDV_MinMaxUInt(pDX, m_edit_ip_version, 0, 15);
DDX_Text(pDX, IDC_edit_layer_ip, m_edit_layer_ip);
DDX_Text(pDX, IDC_edit_layer_4, m_edit_layer_4);
DDX_Text(pDX, IDC_edit_igmp_checksum,
m_edit_igmp_checksum);
DDV_MinMaxUInt(pDX, m_edit_igmp_checksum, 0,
65535);
DDX_Text(pDX, IDC_edit_igmp_reserved,
m_edit_igmp_reserved);
DDV_MinMaxUInt(pDX, m_edit_igmp_reserved, 0,
255);
DDX_Text(pDX, IDC_edit_igmp_type,
m_edit_igmp_type);
DDV_MinMaxUInt(pDX, m_edit_igmp_type, 0, 15);
DDX_Text(pDX, IDC_edit_igmp_version,
m_edit_igmp_version);
DDV_MinMaxUInt(pDX, m_edit_igmp_version, 0, 15);
DDX_Text(pDX, IDC_edit_igmp_destination,
m_edit_igmp_destination);
DDX_Text(pDX, IDC_edit_tcp_ack, m_edit_tcp_ack);
DDV_MinMaxUInt(pDX, m_edit_tcp_ack, 0,
4294967295);
DDX_Text(pDX, IDC_edit_tcp_checksum,
m_edit_tcp_checksum);
DDV_MinMaxUInt(pDX, m_edit_tcp_checksum, 0,
65535);
DDX_Text(pDX, IDC_edit_tcp_destination_port,
m_edit_tcp_destination_port);
DDV_MinMaxUInt(pDX, m_edit_tcp_destination_port,
0, 65535);
DDX_Text(pDX, IDC_edit_tcp_offset,
m_edit_tcp_offset);
DDV_MinMaxUInt(pDX, m_edit_tcp_offset, 0, 15);
DDX_Text(pDX, IDC_edit_tcp_pointer,
m_edit_tcp_pointer);
DDV_MinMaxUInt(pDX, m_edit_tcp_pointer, 0,
65535);
DDX_Text(pDX, IDC_edit_tcp_reserved,
m_edit_tcp_reserved);
DDV_MinMaxUInt(pDX, m_edit_tcp_reserved, 0, 63);
DDX_Text(pDX, IDC_edit_tcp_sequence,
m_edit_tcp_sequence);
DDV_MinMaxUInt(pDX, m_edit_tcp_sequence, 0,
4294967295);
DDX_Text(pDX, IDC_edit_tcp_source_port,
m_edit_tcp_source_port);
DDV_MinMaxUInt(pDX, m_edit_tcp_source_port, 0,
4294967295);
DDX_Text(pDX, IDC_edit_tcp_window,
m_edit_tcp_window);
DDV_MinMaxUInt(pDX, m_edit_tcp_window, 0,
65535);
DDX_Text(pDX, IDC_edit_udp_checksum,
m_edit_udp_checksum);
DDV_MinMaxUInt(pDX, m_edit_udp_checksum, 0,
65535);
DDX_Text(pDX, IDC_edit_udp_destination_port,
m_edit_udp_destination_port);
DDV_MinMaxUInt(pDX, m_edit_udp_destination_port,
0, 65535);
DDX_Text(pDX, IDC_edit_udp_length,
m_edit_udp_length);
DDV_MinMaxUInt(pDX, m_edit_udp_length, 0,
65535);
DDX_Text(pDX, IDC_edit_udp_source_port,
m_edit_udp_source_port);
DDV_MinMaxUInt(pDX, m_edit_udp_source_port, 0,
65535);
DDX_Text(pDX, IDC_static_layer_4,
m_static_layer_4);
DDX_Control(pDX, IDC_edit_ip_version,
m_edit_ip_version_control);
DDX_Control(pDX, IDC_edit_ip_ihl,
m_edit_ip_ihl_control);
DDX_Control(pDX, IDC_edit_ip_tos,
m_edit_ip_tos_control);
DDX_Control(pDX, IDC_edit_ip_length,
m_edit_ip_length_control);
DDX_Control(pDX, IDC_edit_ip_id,
m_edit_ip_id_control);
DDX_Control(pDX, IDC_edit_ip_offset,
m_edit_ip_offset_control);
DDX_Control(pDX, IDC_edit_ip_ttl,
m_edit_ip_ttl_control);
DDX_Control(pDX, IDC_edit_ip_type,
m_edit_ip_type_control);
DDX_Control(pDX, IDC_edit_ip_checksum,
m_edit_ip_checksum_control);
DDX_Control(pDX, IDC_edit_ip_destination,
m_edit_ip_destination_control);
DDX_Control(pDX, IDC_edit_timeout,
m_edit_timeout_control);
DDX_Control(pDX, IDC_static_layer_4,
m_static_layer_4_control);
DDX_Control(pDX, IDC_edit_ip_source,
m_edit_ip_source_control);
DDX_Text(pDX, IDC_edit_ip_source,
m_edit_ip_source);
DDX_Control(pDX, IDC_button_get_igmp_destination,
m_button_get_igmp_destination_control);
DDX_Control(pDX, IDC_spin_size,
m_spin_size_control);
DDV_MaxChars(pDX, m_edit_data, 65535);
DDX_Control(pDX, IDC_check_icmp_checksum,
m_check_icmp_checksum_control);
DDX_Control(pDX, IDC_check_igmp_checksum,
m_check_igmp_checksum_control);
DDX_Control(pDX, IDC_check_tcp_checksum,
m_check_tcp_checksum_control);
DDX_Control(pDX, IDC_check_udp_checksum,
m_check_udp_checksum_control);
DDX_Control(pDX, IDC_check_ip_checksum,
m_check_ip_checksum_control);
DDX_Control(pDX, IDC_check_ip_type,
m_check_ip_type_control);
DDX_Control(pDX, IDC_static_layer_5,
m_static_data_control);
DDX_Control(pDX, IDC_check_ip_flag_none,
m_check_ip_flag_none_control);
DDX_Control(pDX, IDC_check_hexa,
m_check_hexa_control);
DDX_Control(pDX, IDC_check_ip_flag_df,
m_check_ip_flag_df_control);
DDX_Control(pDX, IDC_check_ip_flag_mf,
m_check_ip_flag_mf_control);
DDX_Control(pDX, IDC_check_ip_length,
m_check_ip_length_control);
DDX_Control(pDX, IDC_check_tcp_flag_urg,
m_check_tcp_flag_urg_control);
DDX_Control(pDX, IDC_check_tcp_flag_ack,
m_check_tcp_flag_ack_control);
DDX_Control(pDX, IDC_check_tcp_flag_psh,
m_check_tcp_flag_psh_control);
DDX_Control(pDX, IDC_check_tcp_flag_rst,
m_check_tcp_flag_rst_control);
DDX_Control(pDX, IDC_check_tcp_flag_syn,
m_check_tcp_flag_syn_control);
DDX_Control(pDX, IDC_check_tcp_flag_fin,
m_check_tcp_flag_fin_control);
DDX_Control(pDX, IDC_check_udp_length,
m_check_udp_length_control);
DDX_Control(pDX, IDC_check_tcp_offset,
m_check_tcp_offset_control);
DDX_Control(pDX, IDC_button_send,
m_button_send_control);
DDX_Control(pDX, IDC_edit_envoi,
m_edit_envoi_control);
}
BEGIN_MESSAGE_MAP(CFrameIpDlg, CDialog)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_button_send, On_button_send)
ON_BN_CLICKED(IDC_button_stop, On_button_stop)
ON_BN_CLICKED(IDC_button_about, On_button_about)
ON_BN_CLICKED(IDC_check_data, On_check_data)
ON_BN_CLICKED(IDC_check_permenent, On_check_permenent)
ON_WM_SYSCOMMAND()
ON_WM_CLOSE()
ON_EN_CHANGE(IDC_edit_ip_version,
OnEn_Change_edit_ip_version)
ON_EN_CHANGE(IDC_edit_ip_ihl, OnEn_Change_edit_ip_ihl)
ON_EN_CHANGE(IDC_edit_ip_tos, OnEn_Change_edit_ip_tos)
ON_EN_CHANGE(IDC_edit_ip_length, OnEn_Change_edit_ip_length)
ON_EN_CHANGE(IDC_edit_ip_id, OnEn_Change_edit_ip_id)
ON_EN_CHANGE(IDC_edit_ip_offset, OnEn_Change_edit_ip_offset)
ON_EN_CHANGE(IDC_edit_ip_ttl, OnEn_Change_edit_ip_ttl)
ON_EN_CHANGE(IDC_edit_ip_type, OnEn_Change_edit_ip_type)
ON_EN_CHANGE(IDC_edit_ip_checksum,
OnEn_Change_edit_ip_checksum)
ON_EN_CHANGE(IDC_edit_ip_source, OnEn_Change_edit_ip_source)
ON_EN_CHANGE(IDC_edit_ip_destination,
OnEn_Change_edit_ip_destination)
ON_BN_CLICKED(IDC_check_icmp_header,
On_Change_check_icmp_header)
ON_BN_CLICKED(IDC_check_igmp_header,
On_Change_check_igmp_header)
ON_BN_CLICKED(IDC_check_tcp_header,
On_Change_check_tcp_header)
ON_BN_CLICKED(IDC_check_udp_header,
On_Change_check_udp_header)
ON_EN_CHANGE(IDC_edit_icmp_type, OnEn_Change_edit_icmp_type)
ON_EN_CHANGE(IDC_edit_icmp_code, OnEn_Change_edit_icmp_code)
ON_EN_CHANGE(IDC_edit_icmp_checksum,
OnEn_Change_edit_icmp_checksum)
ON_EN_CHANGE(IDC_edit_icmp_id, OnEn_Change_edit_icmp_id)
ON_EN_CHANGE(IDC_edit_icmp_sequence,
OnEn_Change_edit_icmp_sequence)
ON_EN_CHANGE(IDC_edit_igmp_version,
OnEn_Change_edit_igmp_version)
ON_EN_CHANGE(IDC_edit_igmp_type, OnEn_Change_edit_igmp_type)
ON_EN_CHANGE(IDC_edit_igmp_reserved,
OnEn_Change_edit_igmp_reserved)
ON_EN_CHANGE(IDC_edit_igmp_checksum,
OnEn_Change_edit_igmp_checksum)
ON_EN_CHANGE(IDC_edit_igmp_destination,
OnEn_Change_edit_igmp_destination)
ON_EN_CHANGE(IDC_edit_tcp_source_port,
OnEn_Change_edit_tcp_source_port)
ON_EN_CHANGE(IDC_edit_tcp_destination_port,
OnEn_Change_edit_tcp_destination_port)
ON_EN_CHANGE(IDC_edit_tcp_sequence,
OnEn_Change_edit_tcp_sequence)
ON_EN_CHANGE(IDC_edit_tcp_ack, OnEn_Change_edit_tcp_ack)
ON_EN_CHANGE(IDC_edit_tcp_offset,
OnEn_Change_edit_tcp_offset)
ON_EN_CHANGE(IDC_edit_tcp_reserved,
OnEn_Change_edit_tcp_reserved)
ON_EN_CHANGE(IDC_edit_tcp_window,
OnEn_Change_edit_tcp_window)
ON_EN_CHANGE(IDC_edit_tcp_checksum,
OnEn_Change_edit_tcp_checksum)
ON_EN_CHANGE(IDC_edit_tcp_pointer,
OnEn_Change_edit_tcp_pointer)
ON_EN_CHANGE(IDC_edit_udp_source_port,
OnEn_Change_edit_udp_source_port)
ON_EN_CHANGE(IDC_edit_udp_destination_port,
OnEn_Change_edit_udp_destination_port)
ON_EN_CHANGE(IDC_edit_udp_length,
OnEn_Change_edit_udp_length)
ON_EN_CHANGE(IDC_edit_udp_checksum,
OnEn_Change_edit_udp_checksum)
ON_BN_CLICKED(IDC_button_get_ip_destination,
OnBn_Clicked_button_get_ip_destination)
ON_BN_CLICKED(IDC_button_get_ip_source,
OnBn_Clicked_button_get_ip_source)
ON_BN_CLICKED(IDC_button_get_igmp_destination,
OnBn_Clicked_button_get_igmp_destination)
ON_EN_CHANGE(IDC_edit_data, OnEn_Change_edit_data)
ON_EN_CHANGE(IDC_edit_size, OnEn_Change_edit_size)
ON_BN_CLICKED(IDC_check_icmp_checksum,
OnBn_Clicked_check_icmp_checksum)
ON_BN_CLICKED(IDC_check_igmp_checksum,
OnBn_Clicked_check_igmp_checksum)
ON_BN_CLICKED(IDC_check_tcp_checksum,
OnBn_Clicked_check_tcp_checksum)
ON_BN_CLICKED(IDC_check_udp_checksum,
OnBn_Clicked_check_udp_checksum)
ON_BN_CLICKED(IDC_check_ip_checksum,
OnBn_Clicked_check_ip_checksum)
ON_BN_CLICKED(IDC_check_ip_type, OnBn_Clicked_check_ip_type)
ON_BN_CLICKED(IDC_check_ip_length,
OnBn_Clicked_check_ip_length)
ON_BN_CLICKED(IDC_check_ip_flag_none,
OnBn_Clicked_check_ip_flag_none)
ON_BN_CLICKED(IDC_check_ip_flag_df,
OnBn_Clicked_check_ip_flag_df)
ON_BN_CLICKED(IDC_check_ip_flag_mf,
OnBn_Clicked_check_ip_flag_mf)
ON_BN_CLICKED(IDC_check_tcp_flag_urg,
OnBn_Clicked_check_tcp_flag_urg)
ON_BN_CLICKED(IDC_check_tcp_flag_ack,
OnBn_Clicked_check_tcp_flag_ack)
ON_BN_CLICKED(IDC_check_tcp_flag_psh,
OnBn_Clicked_check_tcp_flag_psh)
ON_BN_CLICKED(IDC_check_tcp_flag_rst,
OnBn_Clicked_check_tcp_flag_rst)
ON_BN_CLICKED(IDC_check_tcp_flag_syn,
OnBn_Clicked_check_tcp_flag_syn)
ON_BN_CLICKED(IDC_check_tcp_flag_fin,
OnBn_Clicked_check_tcp_flag_fin)
ON_BN_CLICKED(IDC_check_udp_length,
OnBn_Clicked_check_udp_length)
ON_BN_CLICKED(IDC_check_tcp_offset,
OnBn_Clicked_check_tcp_offset)
ON_BN_CLICKED(IDC_button_clear, OnBn_Clicked_button_clear)
ON_BN_CLICKED(IDC_check_hexa, OnBnClickedcheckhexa)
END_MESSAGE_MAP()
BOOL CFrameIpDlg::OnInitDialog()
{
struct structure_ip_local reception_des_ip_locales;
// **************************************************
// Orginie VC++
// **************************************************
CDialog::OnInitDialog();
SetIcon(m_hIcon, TRUE); // Set
big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// **************************************************
// Insert le "String Table" dans le menu
// **************************************************
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING,
IDM_ABOUTBOX, strAboutMenu);
}
}
// ********************************************************
// Initialisation de l'entête IP
// ********************************************************
entete_ipv4.version=4;
entete_ipv4.ihl=5;
entete_ipv4.tos=0;
entete_ipv4.length=htons(0);
entete_ipv4.id=htons(5000);
entete_ipv4.flag_zero=0;
entete_ipv4.flag_mf=0;
entete_ipv4.flag_df=0;
entete_ipv4.offset=0;
entete_ipv4.offset2=0; // Offset2 n'est là que pour la
séparation d'offset
entete_ipv4.ttl=100;
entete_ipv4.type=1;
entete_ipv4.checksum=htons(0);
reception_des_ip_locales=recuperation_ip_local(TRUE);
entete_ipv4.ip_source=resolution_de_nom(TRUE,reception_des_ip_locales.adresse_ip_local[0]);
entete_ipv4.ip_destination=resolution_de_nom(TRUE,"www.yahoo.fr");
// ********************************************************
// Initialisation de l'entête ICMP
// ********************************************************
entete_icmp.type=8;
entete_icmp.code=0;
entete_icmp.checksum=htons(0);
entete_icmp.id=htons(0);
entete_icmp.sequence=htons(0);
// ********************************************************
// Initialisation de l'entête IGMP
// ********************************************************
entete_igmp.version=1;
entete_igmp.type=1;
entete_igmp.reserve=0;
entete_igmp.checksum=htons(0);
sprintf(tampon_char,"224.0.0.1");
entete_igmp.ip_destination=resolution_de_nom(TRUE,tampon_char);
// ********************************************************
// Initialisation de l'entête TCP
// ********************************************************
entete_tcp.port_source=htons(5000);
entete_tcp.port_destination=htons(80);
entete_tcp.sequence=htonl(0);
entete_tcp.accuse=htonl(0);
entete_tcp.offset=5;
entete_tcp.reserved=0;
entete_tcp.reserved2=0;
entete_tcp.flag_urg=0;
entete_tcp.flag_ack=1;
entete_tcp.flag_psh=0;
entete_tcp.flag_rst=0;
entete_tcp.flag_syn=0;
entete_tcp.flag_fin=0;
entete_tcp.window=htons(0);
entete_tcp.checksum=htons(0);
entete_tcp.pointeur=htons(0);
// ********************************************************
// Initialisation de l'entête UDP
// ********************************************************
entete_udp.port_source=htons(0);
entete_udp.port_destination=htons(53);
entete_udp.length=htons(8);
entete_udp.checksum=htons(0);
// ********************************************************
// Initialisation de la couche DATA
// ********************************************************
m_edit_data="www.frameip.com ";
m_edit_size=strlen(m_edit_data);
strcpy(data,m_edit_data);
sprintf(tampon_char,"1");
m_edit_number_control.SetWindowText(tampon_char);
sprintf(tampon_char,"1000");
m_edit_timeout_control.SetWindowText(tampon_char);
// ********************************************************
// Affichage des champs de l'entête IP
// ********************************************************
sprintf(tampon_char,"%d",entete_ipv4.version);
m_edit_ip_version_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_ipv4.ihl);
m_edit_ip_ihl_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_ipv4.tos);
m_edit_ip_tos_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_ipv4.length));
m_edit_ip_length_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_ipv4.id));
m_edit_ip_id_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_ipv4.offset);
m_edit_ip_offset_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_ipv4.ttl);
m_edit_ip_ttl_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_ipv4.type);
m_edit_ip_type_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_ipv4.checksum));
m_edit_ip_checksum_control.SetWindowText(tampon_char);
m_edit_ip_source_control.SetWindowText(reception_des_ip_locales.adresse_ip_local[0]);
m_edit_ip_destination_control.SetWindowText("www.yahoo.fr");
// ********************************************************
// Affichage des champs de l'entête ICMP
// ********************************************************
sprintf(tampon_char,"%d",entete_icmp.type);
m_edit_icmp_type_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_icmp.code);
m_edit_icmp_code_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_icmp.checksum));
m_edit_icmp_checksum_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_icmp.id));
m_edit_icmp_id_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_icmp.sequence));
m_edit_icmp_sequence_control.SetWindowText(tampon_char);
// ********************************************************
// Affichage des champs de l'entête IGMP
// ********************************************************
sprintf(tampon_char,"%d",entete_igmp.version);
m_edit_igmp_version_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_igmp.type);
m_edit_igmp_type_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_igmp.reserve);
m_edit_igmp_reserved_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_igmp.checksum));
m_edit_igmp_checksum_control.SetWindowText(tampon_char);
m_edit_igmp_destination_control.SetWindowText("224.0.0.1");
// ********************************************************
// Affichage des champs de l'entête TCP
// ********************************************************
sprintf(tampon_char,"%d",htons(entete_tcp.port_source));
m_edit_tcp_source_port_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_tcp.port_destination));
m_edit_tcp_destination_port_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htonl(entete_tcp.sequence));
m_edit_tcp_sequence_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htonl(entete_tcp.accuse));
m_edit_tcp_ack_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_tcp.offset);
m_edit_tcp_offset_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",entete_tcp.reserved);
m_edit_tcp_reserved_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_tcp.window));
m_edit_tcp_window_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_tcp.checksum));
m_edit_tcp_checksum_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_tcp.pointeur));
m_edit_tcp_pointer_control.SetWindowText(tampon_char);
// ********************************************************
// Affichage des champs de l'entête UDP
// ********************************************************
sprintf(tampon_char,"%d",htons(entete_udp.port_source));
m_edit_udp_source_port_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_udp.port_destination));
m_edit_udp_destination_port_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_udp.length));
m_edit_udp_length_control.SetWindowText(tampon_char);
sprintf(tampon_char,"%d",htons(entete_udp.checksum));
m_edit_udp_checksum_control.SetWindowText(tampon_char);
// ********************************************************
// Affichage des champs DATA
// ********************************************************
m_edit_data_control.SetWindowText(m_edit_data);
sprintf(tampon_char,"%d",m_edit_size);
m_edit_size_control.SetWindowText(tampon_char);
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa(); // Met à jour
le champ Layer IP
m_edit_number_control.SetReadOnly(FALSE);
CFrameIpDlg::On_check_data(); // Initialize les ReadOnly des
champs Data
// ********************************************************
// Active par défaut l'entête ICMP
// ********************************************************
m_check_icmp_header_control.SetCheck(TRUE);
CFrameIpDlg::On_Change_check_icmp_header();
CFrameIpDlg::mise_a_jour_du_champ_data_hexa();
// ********************************************************
// Activation par defaut des case à cocher
// ********************************************************
m_check_hexa_control.SetCheck(false);
m_check_ip_length_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_ip_length();
m_check_ip_flag_none_control.SetCheck(false);
CFrameIpDlg::OnBn_Clicked_check_ip_flag_none();
m_check_ip_flag_df_control.SetCheck(false);
CFrameIpDlg::OnBn_Clicked_check_ip_flag_df();
m_check_ip_flag_mf_control.SetCheck(false);
CFrameIpDlg::OnBn_Clicked_check_ip_flag_mf();
m_check_ip_type_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_ip_type();
m_check_ip_checksum_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_ip_checksum();
m_check_icmp_checksum_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_icmp_checksum();
m_check_igmp_checksum_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_igmp_checksum();
m_check_tcp_offset_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_tcp_offset();
m_check_tcp_flag_urg_control.SetCheck(false);
CFrameIpDlg::OnBn_Clicked_check_tcp_flag_urg();
m_check_tcp_flag_ack_control.SetCheck(false);
CFrameIpDlg::OnBn_Clicked_check_tcp_flag_ack();
m_check_tcp_flag_psh_control.SetCheck(false);
CFrameIpDlg::OnBn_Clicked_check_tcp_flag_psh();
m_check_tcp_flag_rst_control.SetCheck(false);
CFrameIpDlg::OnBn_Clicked_check_tcp_flag_rst();
m_check_tcp_flag_syn_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_tcp_flag_syn();
m_check_tcp_flag_fin_control.SetCheck(false);
CFrameIpDlg::OnBn_Clicked_check_tcp_flag_fin();
m_check_tcp_checksum_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_tcp_checksum();
m_check_udp_length_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_udp_length();
m_check_udp_checksum_control.SetCheck(true);
CFrameIpDlg::OnBn_Clicked_check_udp_checksum();
// ********************************************************
// Initialisation des Spins Divers
// ********************************************************
m_spin_number_control.SetRange32(0,65535);
m_spin_timeout_control.SetRange32(0,65535);
m_spin_size_control.SetRange32(0,65535);
// ********************************************************
// Initialisation des Spins de l'entête IP
// ********************************************************
m_spin_ip_version_control.SetRange32(0,15);
m_spin_ip_ihl_control.SetRange32(0,15);
m_spin_ip_tos_control.SetRange32(0,255);
m_spin_ip_id_control.SetRange32(0,65535);
m_spin_ip_offset_control.SetRange32(0,8191);
m_spin_ip_ttl_control.SetRange32(0,255);
// ********************************************************
// Initialisation des Spins de l'entête ICMP
// ********************************************************
m_spin_icmp_type_control.SetRange32(0,255);
m_spin_icmp_code_control.SetRange32(0,255);
m_spin_icmp_id_control.SetRange32(0,65535);
m_spin_icmp_sequence_control.SetRange32(0,65535);
// ********************************************************
// Initialisation des Spins de l'entête IGMP
// ********************************************************
m_spin_igmp_version_control.SetRange32(0,15);
m_spin_igmp_type_control.SetRange32(0,15);
m_spin_igmp_reserved_control.SetRange32(0,255);
// ********************************************************
// Initialisation des Spins de l'entête TCP
// ********************************************************
m_spin_tcp_source_port_control.SetRange32(0,65535);
m_spin_tcp_destination_port_control.SetRange32(0,65535);
m_spin_tcp_reserved_control.SetRange32(0,63);
m_spin_tcp_window_control.SetRange32(0,65535);
m_spin_tcp_pointer_control.SetRange32(0,65535);
// ********************************************************
// Initialisation des Spins de l'entête UDP
// ********************************************************
m_spin_udp_source_port_control.SetRange32(0,65535);
m_spin_udp_destination_port_control.SetRange32(0,65535);
// **************************************************
// Initialisation de la fenetre d'envoi
// **************************************************
m_edit_envoi_control.SetReadOnly(1);
// ********************************************************
// Je concidère à ce niveau que la fenêtre est affichée
// ********************************************************
initialisation=TRUE;
return TRUE; // return TRUE unless you set the focus to a
control
}
void CFrameIpDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
// **************************************************
// Si l'utilisateur selectionne le menu About
// **************************************************
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
On_button_about();
else
CDialog::OnSysCommand(nID, lParam);
}
void CFrameIpDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for
painting
SendMessage(WM_ICONERASEBKGND, (WPARAM)
dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
HCURSOR CFrameIpDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
void CFrameIpDlg::On_check_permenent()
{
m_edit_number_control.SetReadOnly(m_check_permenent_control.GetCheck());
m_spin_number_control.EnableScrollBarCtrl(1,m_check_permenent_control.GetCheck());
}
void CFrameIpDlg::mise_a_jour_du_champ_ip_hexa()
{
unsigned char *entete_convertit_char;
// ********************************************************
// Convertit la structure en unsigned char
// ********************************************************
entete_convertit_char=(unsigned char *)&entete_ipv4;
// ********************************************************
// Convertit chaque caratère en Hexa
// ********************************************************
for(tampon_int=0;tampon_int<sizeof(struct
ipv4);tampon_int++)
sprintf(tampon_char+tampon_int*2, "%02X",
entete_convertit_char[tampon_int]);
// ********************************************************
// Met le resultat dans le champ Edit correspondant
// ********************************************************
m_edit_layer_ip_control.SetWindowText(tampon_char);;
}
void CFrameIpDlg::mise_a_jour_du_champ_icmp_hexa(void)
{
unsigned char *entete_convertit_char;
// ********************************************************
// Convertit la structure Icmp en unsigned char
// ********************************************************
entete_convertit_char=(unsigned char *)&entete_icmp;
// ********************************************************
// Convertit chaque caratère en Hexa
// ********************************************************
for(tampon_int=0;tampon_int<sizeof(struct
icmp);tampon_int++)
sprintf(tampon_char+tampon_int*2, "%02X",
entete_convertit_char[tampon_int]);
// ********************************************************
// Affichage du resultat Hexa
// ********************************************************
m_edit_layer_4_control.SetWindowText(tampon_char);
// ********************************************************
// mise_a_jour_du_champ_static_layer_4
// ********************************************************
mise_a_jour_du_champ_static_layer_4();
}
void CFrameIpDlg::mise_a_jour_du_champ_igmp_hexa(void)
{
unsigned char *entete_convertit_char;
// ********************************************************
// Convertit la structure Igmp en unsigned char
// ********************************************************
entete_convertit_char=(unsigned char *)&entete_igmp;
// ********************************************************
// Convertit chaque caratère en Hexa
// ********************************************************
for(tampon_int=0;tampon_int<sizeof(struct
igmp);tampon_int++)
sprintf(tampon_char+tampon_int*2, "%02X",
entete_convertit_char[tampon_int]);
// ********************************************************
// Affichage du resultat Hexa
// ********************************************************
m_edit_layer_4_control.SetWindowText(tampon_char);
// ********************************************************
// mise_a_jour_du_champ_static_layer_4
// ********************************************************
mise_a_jour_du_champ_static_layer_4();
}
void CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa(void)
{
unsigned char *entete_convertit_char;
// ********************************************************
// Convertit la structure Tcp en unsigned char
// ********************************************************
entete_convertit_char=(unsigned char *)&entete_tcp;
// ********************************************************
// Convertit chaque caratère en Hexa
// ********************************************************
for(tampon_int=0;tampon_int<sizeof(struct tcp);tampon_int++)
sprintf(tampon_char+tampon_int*2, "%02X",
entete_convertit_char[tampon_int]);
// ********************************************************
// Affichage du resultat Hexa
// ********************************************************
m_edit_layer_4_control.SetWindowText(tampon_char);
// ********************************************************
// mise_a_jour_du_champ_static_layer_4
// ********************************************************
mise_a_jour_du_champ_static_layer_4();
}
void CFrameIpDlg::mise_a_jour_du_champ_udp_hexa(void)
{
unsigned char *entete_convertit_char;
// ********************************************************
// Convertit la structure Udp en unsigned char
// ********************************************************
entete_convertit_char=(unsigned char *)&entete_udp;
// ********************************************************
// Convertit chaque caratère en Hexa
// ********************************************************
for(tampon_int=0;tampon_int<sizeof(struct udp);tampon_int++)
sprintf(tampon_char+tampon_int*2, "%02X",
entete_convertit_char[tampon_int]);
// ********************************************************
// Affichage du resultat Hexa
// ********************************************************
m_edit_layer_4_control.SetWindowText(tampon_char);
// ********************************************************
// mise_a_jour_du_champ_static_layer_4
// ********************************************************
mise_a_jour_du_champ_static_layer_4();
}
void CFrameIpDlg::mise_a_jour_du_champ_static_layer_4(void)
{
if (m_check_icmp_header_control.GetCheck()==1)
{
sprintf(tampon_char,"ICMP Header - %d
octets",sizeof(struct icmp));
m_edit_layer_4_control.SetReadOnly(0);
}
else if (m_check_igmp_header_control.GetCheck()==1)
{
sprintf(tampon_char,"IGMP Header - %d
octets",sizeof(struct igmp));
m_edit_layer_4_control.SetReadOnly(0);
}
else if (m_check_tcp_header_control.GetCheck()==1)
{
sprintf(tampon_char,"TCP Header - %d
octets",sizeof(struct tcp));
m_edit_layer_4_control.SetReadOnly(0);
}
else if (m_check_udp_header_control.GetCheck()==1)
{
sprintf(tampon_char,"UDP Header - %d
octets",sizeof(struct udp));
m_edit_layer_4_control.SetReadOnly(0);
}
else
{
//
********************************************************
// Remise à zéro du champ Hexa
//
********************************************************
sprintf(tampon_char,"");
m_edit_layer_4_control.SetWindowText(tampon_char);
//
********************************************************
// Desactivation du champs static
//
********************************************************
sprintf(tampon_char,"No Header");
m_edit_layer_4_control.SetReadOnly(1);
}
m_static_layer_4_control.SetWindowText(tampon_char);
}
void CFrameIpDlg::mise_a_jour_du_champ_data_hexa(void)
{
// ********************************************************
// Initialisation
// ********************************************************
strcpy(tampon_char2,""); // Initialise tampon_char2 au cas
où la taille des data serait à 0
// ********************************************************
// Convertion de CString en Char *
// ********************************************************
strcpy(tampon_char,m_edit_data);
if (strlen(tampon_char)!=0) // Ne transcrit pas en Hexa si
la chaine est vide
{
m_edit_layer_data_control.SetReadOnly(FALSE);
if (m_check_data_control.GetCheck()==FALSE)
if (m_edit_size==0)
{
m_edit_layer_data_control.SetReadOnly(TRUE);
strcpy(data,"");
}
else
{
//
********************************************************
// Dimentionnement des
Data
//
********************************************************
strcpy(data,dimensionnement_de_data_a_envoyer(TRUE,tampon_char,m_edit_size));
//
********************************************************
// Convertion en Hexa
//
********************************************************
for(tampon_int=0;(unsigned int)tampon_int<m_edit_size;tampon_int++)
sprintf(tampon_char2+tampon_int*2, "%02X", data[tampon_int]);
}
else
{
//
********************************************************
// Insertion du résultat dans data
//
********************************************************
strcpy(data,m_edit_data);
//
********************************************************
// Convertion en Hexa
//
********************************************************
for(tampon_int=0;(unsigned
int)tampon_int<strlen(m_edit_data);tampon_int++)
sprintf(tampon_char2+tampon_int*2, "%02X", tampon_char[tampon_int]);
}
}
else
{
m_edit_layer_data_control.SetReadOnly(TRUE);
strcpy(data,"");
}
// ********************************************************
// Affichage du resultat Hexa
// ********************************************************
m_edit_layer_data_control.SetWindowText(tampon_char2);
// ********************************************************
// Modification du champs static
// ********************************************************
sprintf(tampon_char,"Data - %d
octets",strlen(tampon_char2)/2);
m_static_data_control.SetWindowText(tampon_char);
}
void CFrameIpDlg::On_Change_check_icmp_header(void)
{
// ********************************************************
// Une seule entête couche 4 ne doit être active
// ********************************************************
if (m_check_icmp_header_control.GetCheck()==1)
{
// Désactive donc les autres entêtes
m_check_igmp_header_control.SetCheck(FALSE);
m_check_tcp_header_control.SetCheck(FALSE);
m_check_udp_header_control.SetCheck(FALSE);
}
// ********************************************************
// Met à jour des l'options ReadOnly des champs couche 4
// ********************************************************
CFrameIpDlg::read_only_des_entetes_couche_4();
// ********************************************************
// Calcul du checksum ICMP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_icmp_checksum();
// ********************************************************
// Mise à jour du champ ICMP Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_icmp_hexa();
// ********************************************************
// Mise à jour du champ Length
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_length();
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::On_Change_check_igmp_header(void)
{
// ********************************************************
// Une seule entête couche 4 ne doit être active
// ********************************************************
if (m_check_igmp_header_control.GetCheck()==1)
{
m_check_icmp_header_control.SetCheck(FALSE);
m_check_tcp_header_control.SetCheck(FALSE);
m_check_udp_header_control.SetCheck(FALSE);
}
// ********************************************************
// Met à jour des l'options ReadOnly des champs couche 4
// ********************************************************
CFrameIpDlg::read_only_des_entetes_couche_4();
// ********************************************************
// Calcul du checksum IGMP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_igmp_checksum();
// ********************************************************
// Mise à jour du champ IGMP Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_igmp_hexa();
// ********************************************************
// Mise à jour du champ Length
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_length();
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::On_Change_check_tcp_header(void)
{
// ********************************************************
// Une seule entête couche 4 ne doit être active
// ********************************************************
if (m_check_tcp_header_control.GetCheck()==1)
{
m_check_icmp_header_control.SetCheck(FALSE);
m_check_igmp_header_control.SetCheck(FALSE);
m_check_udp_header_control.SetCheck(FALSE);
}
// ********************************************************
// Met à jour des l'options ReadOnly des champs couche 4
// ********************************************************
CFrameIpDlg::read_only_des_entetes_couche_4();
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
// ********************************************************
// Mise à jour du champ TCP Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
// ********************************************************
// Mise à jour du champ Length
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_length();
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::On_Change_check_udp_header(void)
{
// ********************************************************
// Une seule entête couche 4 ne doit être active
// ********************************************************
if (m_check_udp_header_control.GetCheck()==1)
{
m_check_icmp_header_control.SetCheck(FALSE);
m_check_igmp_header_control.SetCheck(FALSE);
m_check_tcp_header_control.SetCheck(FALSE);
}
// ********************************************************
// Met à jour des l'options ReadOnly des champs couche 4
// ********************************************************
CFrameIpDlg::read_only_des_entetes_couche_4();
// ********************************************************
// Calcul du checksum UDP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_udp_checksum();
// ********************************************************
// Mise à jour du champ UDP Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
// ********************************************************
// Mise à jour du champ Length
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_length();
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::read_only_des_entetes_couche_4(void)
{
// ********************************************************
// Read Only des champs ICMP
// ********************************************************
m_edit_icmp_type_control.SetReadOnly(!m_check_icmp_header_control.GetCheck());
m_edit_icmp_code_control.SetReadOnly(!m_check_icmp_header_control.GetCheck());
m_check_icmp_checksum_control.EnableWindow(m_check_icmp_header_control.GetCheck());
if(m_check_icmp_checksum_control.GetCheck()==FALSE)
m_edit_icmp_checksum_control.SetReadOnly(!m_check_icmp_header_control.GetCheck());
m_edit_icmp_id_control.SetReadOnly(!m_check_icmp_header_control.GetCheck());
m_edit_icmp_sequence_control.SetReadOnly(!m_check_icmp_header_control.GetCheck());
// ********************************************************
// Read Only des Spin ICMP
// ********************************************************
m_spin_icmp_type_control.EnableScrollBarCtrl(1,!m_check_icmp_header_control.GetCheck());
m_spin_icmp_code_control.EnableScrollBarCtrl(1,!m_check_icmp_header_control.GetCheck());
m_spin_icmp_id_control.EnableScrollBarCtrl(1,!m_check_icmp_header_control.GetCheck());
m_spin_icmp_sequence_control.EnableScrollBarCtrl(1,!m_check_icmp_header_control.GetCheck());
// ********************************************************
// Read Only des champs IGMP
// ********************************************************
m_edit_igmp_version_control.SetReadOnly(!m_check_igmp_header_control.GetCheck());
m_edit_igmp_type_control.SetReadOnly(!m_check_igmp_header_control.GetCheck());
m_edit_igmp_reserved_control.SetReadOnly(!m_check_igmp_header_control.GetCheck());
m_check_igmp_checksum_control.EnableWindow(m_check_igmp_header_control.GetCheck());
if(m_check_igmp_checksum_control.GetCheck()==FALSE)
m_edit_igmp_checksum_control.SetReadOnly(!m_check_igmp_header_control.GetCheck());
m_button_get_igmp_destination_control.EnableWindow(m_check_igmp_header_control.GetCheck());
// ********************************************************
// Read Only des Spin IGMP
// ********************************************************
m_spin_igmp_version_control.EnableScrollBarCtrl(1,!m_check_igmp_header_control.GetCheck());
m_spin_igmp_type_control.EnableScrollBarCtrl(1,!m_check_igmp_header_control.GetCheck());
m_spin_igmp_reserved_control.EnableScrollBarCtrl(1,!m_check_igmp_header_control.GetCheck());
// ********************************************************
// Read Only des champs TCP
// ********************************************************
m_edit_tcp_source_port_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
m_edit_tcp_destination_port_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
m_edit_tcp_sequence_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
m_edit_tcp_ack_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
m_check_tcp_offset_control.EnableWindow(m_check_tcp_header_control.GetCheck());
if(m_check_tcp_offset_control.GetCheck()==FALSE)
m_edit_tcp_offset_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
m_edit_tcp_reserved_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
m_check_tcp_flag_urg_control.EnableWindow(m_check_tcp_header_control.GetCheck());
m_check_tcp_flag_ack_control.EnableWindow(m_check_tcp_header_control.GetCheck());
m_check_tcp_flag_psh_control.EnableWindow(m_check_tcp_header_control.GetCheck());
m_check_tcp_flag_rst_control.EnableWindow(m_check_tcp_header_control.GetCheck());
m_check_tcp_flag_syn_control.EnableWindow(m_check_tcp_header_control.GetCheck());
m_check_tcp_flag_fin_control.EnableWindow(m_check_tcp_header_control.GetCheck());
m_edit_tcp_window_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
m_check_tcp_checksum_control.EnableWindow(m_check_tcp_header_control.GetCheck());
if(m_check_tcp_checksum_control.GetCheck()==FALSE)
m_edit_tcp_checksum_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
m_edit_tcp_pointer_control.SetReadOnly(!m_check_tcp_header_control.GetCheck());
// ********************************************************
// Read Only des Spin TCP
// ********************************************************
m_spin_tcp_source_port_control.EnableScrollBarCtrl(1,!m_check_tcp_header_control.GetCheck());
m_spin_tcp_destination_port_control.EnableScrollBarCtrl(1,!m_check_tcp_header_control.GetCheck());
m_spin_tcp_reserved_control.EnableScrollBarCtrl(1,!m_check_tcp_header_control.GetCheck());
m_spin_tcp_window_control.EnableScrollBarCtrl(1,!m_check_tcp_header_control.GetCheck());
m_spin_tcp_pointer_control.EnableScrollBarCtrl(1,!m_check_tcp_header_control.GetCheck());
// ********************************************************
// Read Only des champs UDP
// ********************************************************
m_edit_udp_source_port_control.SetReadOnly(!m_check_udp_header_control.GetCheck());
m_edit_udp_destination_port_control.SetReadOnly(!m_check_udp_header_control.GetCheck());
m_check_udp_length_control.EnableWindow(m_check_udp_header_control.GetCheck());
m_check_udp_checksum_control.EnableWindow(m_check_udp_header_control.GetCheck());
if(m_check_udp_length_control.GetCheck()==FALSE)
m_edit_udp_length_control.SetReadOnly(!m_check_udp_header_control.GetCheck());
if(m_check_udp_checksum_control.GetCheck()==FALSE)
m_edit_udp_checksum_control.SetReadOnly(!m_check_udp_header_control.GetCheck());
// ********************************************************
// Read Only des Spin UDP
// ********************************************************
m_spin_udp_source_port_control.EnableScrollBarCtrl(1,!m_check_udp_header_control.GetCheck());
m_spin_udp_destination_port_control.EnableScrollBarCtrl(1,!m_check_udp_header_control.GetCheck());
// ********************************************************
// Mise à jour du champ IP_type
// ********************************************************
CFrameIpDlg::mise_a_jour_de_champ_ip_type();
}
void CFrameIpDlg::mise_a_jour_de_champ_ip_type(void)
{
if (m_check_ip_type_control.GetCheck()==1) // Si la case à
coché de Ip_type est active
{
//
********************************************************
// Met à jour le champ IP_type
//
********************************************************
if (m_check_icmp_header_control.GetCheck()==1)
entete_ipv4.type=1;
else if
(m_check_igmp_header_control.GetCheck()==1)
entete_ipv4.type=2;
else if
(m_check_tcp_header_control.GetCheck()==1)
entete_ipv4.type=6;
else if
(m_check_udp_header_control.GetCheck()==1)
entete_ipv4.type=17;
else
entete_ipv4.type=255;
sprintf(tampon_char,"%d",entete_ipv4.type);
m_edit_ip_type_control.SetWindowText(tampon_char);
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_version(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_ip_version_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_ipv4.version=(unsigned
char)atoi(tampon_char);
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_ihl(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_ip_ihl_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_ipv4.ihl=(unsigned
char)atoi(tampon_char);
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_tos(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_ip_tos_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_ipv4.tos=(unsigned
char)atoi(tampon_char);
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_length(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_ip_length_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_ipv4.length=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_id(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_ip_id_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_ipv4.id=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_offset(void)
{
unsigned short tempo3, tempo4;
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
//
********************************************************
// Récupération de la valeur
//
********************************************************
m_edit_ip_offset_control.GetWindowText(tampon_char,sizeof(tampon_char));
tempo3=(unsigned short)atoi(tampon_char);
//
********************************************************
// Récupération des cinq bits finaux du premier
octet
//
********************************************************
tempo4=tempo3<<3;
entete_ipv4.offset=tempo4>>11;
//
********************************************************
// Récupération des huit bits finaux du second
octet
//
********************************************************
entete_ipv4.offset2=(unsigned char)tempo3;
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_ttl(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_ip_ttl_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_ipv4.ttl=(unsigned
char)atoi(tampon_char);
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_type(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_ip_type_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_ipv4.type=(unsigned
char)atoi(tampon_char);
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_checksum(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_ip_checksum_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_ipv4.checksum=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Mise à jour de l'affichage hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_source(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
//
********************************************************
// Mise à jour des Checksum TCP et UDP (La
Pseudo entete dépend de l'ip source et destination)
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
CFrameIpDlg::calcul_et_affichage_udp_checksum();
//
********************************************************
// Mise à jour de l'affichage Hexa TCP et UDP
//
********************************************************
if (m_check_tcp_header_control.GetCheck()==1)
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
if (m_check_udp_header_control.GetCheck()==1)
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_ip_destination(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
//
********************************************************
// Mise à jour des Checksum TCP et UDP (La
Pseudo entete dépend de l'ip source et destination)
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
CFrameIpDlg::calcul_et_affichage_udp_checksum();
//
********************************************************
// Mise à jour de l'affichage Hexa TCP et UDP
//
********************************************************
if (m_check_tcp_header_control.GetCheck()==1)
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
if (m_check_udp_header_control.GetCheck()==1)
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
//
********************************************************
// Calcul du checksum IP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
//
********************************************************
// Mise à jour du champ Hexa IP
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_icmp_type(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_icmp_type_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_icmp.type=(unsigned
char)atoi(tampon_char);
//
********************************************************
// Calcul du checksum ICMP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_icmp_checksum();
//
********************************************************
// Mise à jour du champ ICMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_icmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_icmp_code(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_icmp_code_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_icmp.code=(unsigned
char)atoi(tampon_char);
//
********************************************************
// Calcul du checksum ICMP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_icmp_checksum();
//
********************************************************
// Mise à jour du champ ICMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_icmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_icmp_checksum(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_icmp_checksum_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_icmp.checksum=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Mise à jour du champ ICMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_icmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_icmp_id(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_icmp_id_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_icmp.id=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum ICMP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_icmp_checksum();
//
********************************************************
// Mise à jour du champ ICMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_icmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_icmp_sequence(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_icmp_sequence_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_icmp.sequence=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum ICMP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_icmp_checksum();
//
********************************************************
// Mise à jour du champ ICMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_icmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_igmp_version(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_igmp_version_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_igmp.version=atoi(tampon_char);
//
********************************************************
// Calcul du checksum IGMP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_igmp_checksum();
//
********************************************************
// Mise à jour du champ IGMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_igmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_igmp_type(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_igmp_type_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_igmp.type=atoi(tampon_char);
//
********************************************************
// Calcul du checksum IGMP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_igmp_checksum();
//
********************************************************
// Mise à jour du champ IGMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_igmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_igmp_reserved(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_igmp_reserved_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_igmp.reserve=(unsigned
char)atoi(tampon_char);
//
********************************************************
// Calcul du checksum IGMP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_igmp_checksum();
//
********************************************************
// Mise à jour du champ IGMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_igmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_igmp_checksum(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_igmp_checksum_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_igmp.checksum=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Mise à jour du champ IGMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_igmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_igmp_destination(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_igmp_destination_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_igmp.ip_destination=atoi(tampon_char);
//
********************************************************
// Calcul du checksum IGMP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_igmp_checksum();
//
********************************************************
// Mise à jour du champ IGMP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_igmp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_source_port(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_tcp_source_port_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_tcp.port_source=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum TCP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_destination_port(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_tcp_destination_port_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_tcp.port_destination=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum TCP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_sequence(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_tcp_sequence_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_tcp.sequence=htonl(atoi(tampon_char));
//
********************************************************
// Calcul du checksum TCP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_ack(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_tcp_ack_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_tcp.accuse=htonl(atoi(tampon_char));
//
********************************************************
// Calcul du checksum TCP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_offset(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_tcp_offset_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_tcp.offset=atoi(tampon_char);
//
********************************************************
// Calcul du checksum TCP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_reserved(void)
{
unsigned short tempo1,tempo2;
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
//
********************************************************
// Récupération de la valeur
//
********************************************************
m_edit_tcp_reserved_control.GetWindowText(tampon_char,sizeof(tampon_char));
tempo1=(unsigned short)atoi(tampon_char);
//
********************************************************
// Récupération des quatre bits centraux
//
********************************************************
tempo2=tempo1<<2; // Rajoute 2 0 à droite en
décalant
entete_tcp.reserved=tempo2>>4; // Rajoute 4 0 à
gauche en décalant
//
********************************************************
// Récupération des deux bits finaux
//
********************************************************
tempo2=tempo1<<6;
entete_tcp.reserved2=tempo2>>6; // Les deux bits
suivant
//
********************************************************
// Calcul du checksum TCP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_window(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_tcp_window_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_tcp.window=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum TCP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_checksum(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_tcp_checksum_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_tcp.checksum=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_tcp_pointer(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_tcp_pointer_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_tcp.pointeur=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum TCP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
//
********************************************************
// Mise à jour du champ TCP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_udp_source_port(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_udp_source_port_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_udp.port_source=(unsigned
short)atoi(tampon_char);
//
********************************************************
// Calcul du checksum UDP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_udp_checksum();
//
********************************************************
// Mise à jour du champ UDP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_udp_destination_port(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_udp_destination_port_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_udp.port_destination=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum UDP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_udp_checksum();
//
********************************************************
// Mise à jour du champ UDP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_udp_length(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_udp_length_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_udp.length=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Calcul du checksum UDP
//
********************************************************
CFrameIpDlg::calcul_et_affichage_udp_checksum();
//
********************************************************
// Mise à jour du champ UDP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_udp_checksum(void)
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
m_edit_udp_checksum_control.GetWindowText(tampon_char,sizeof(tampon_char));
entete_udp.checksum=htons((unsigned
short)atoi(tampon_char));
//
********************************************************
// Mise à jour du champ UDP Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
}
}
void CFrameIpDlg::OnBn_Clicked_button_get_ip_source()
{
class_ip_address fenetre_ip_adresse;
SOCKADDR_IN translation; //
Structure nécessaire à la transformation du nombre inet_addr en IP char*
class_ip_address_selection=1; // Annonce à la
prochaine boite de dialogue la provennance
// ********************************************************
// Lancement de la boite de dialogue pour la saisie de l'IP
// ********************************************************
if (fenetre_ip_adresse.DoModal()==1)
{
entete_ipv4.ip_source=class_ip_address_retour_de_fenetre;
translation.sin_addr.s_addr=class_ip_address_retour_de_fenetre; //
Convertion du Inet_addr en format char *
m_edit_ip_source_control.SetWindowText(inet_ntoa(translation.sin_addr));
}
}
void CFrameIpDlg::OnBn_Clicked_button_get_ip_destination()
{
class_ip_address fenetre_ip_adresse;
SOCKADDR_IN translation; //
Structure nécessaire à la transformation du nombre inet_addr en IP char*
class_ip_address_selection=3; // Annonce à la
prochaine boite de dialogue la provennance
// ********************************************************
// Lancement de la boite de dialogue pour la saisie de l'IP
// ********************************************************
if (fenetre_ip_adresse.DoModal()==1)
{
entete_ipv4.ip_destination=class_ip_address_retour_de_fenetre;
translation.sin_addr.s_addr=class_ip_address_retour_de_fenetre; //
Convertion du Inet_addr en format char *
m_edit_ip_destination_control.SetWindowText(inet_ntoa(translation.sin_addr));
}
}
void CFrameIpDlg::OnBn_Clicked_button_get_igmp_destination()
{
class_ip_address fenetre_ip_adresse;
SOCKADDR_IN translation; //
Structure nécessaire à la transformation du nombre inet_addr en IP char*
class_ip_address_selection=3; // Annonce à la
prochaine boite de dialogue la provennance
// ********************************************************
// Lancement de la boite de dialogue pour la saisie de l'IP
// ********************************************************
if (fenetre_ip_adresse.DoModal()==1)
{
entete_igmp.ip_destination=class_ip_address_retour_de_fenetre;
translation.sin_addr.s_addr=class_ip_address_retour_de_fenetre; //
Convertion du Inet_addr en format char *
m_edit_igmp_destination_control.SetWindowText(inet_ntoa(translation.sin_addr));
}
}
void CFrameIpDlg::On_check_data()
{
m_edit_size_control.SetReadOnly(m_check_data_control.GetCheck());
m_spin_size_control.EnableScrollBarCtrl(1,m_check_data_control.GetCheck());
m_edit_data_control.SetReadOnly(!m_check_data_control.GetCheck());
// ********************************************************
// Mise à jour du champ Data en Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_data_hexa();
// ********************************************************
// Mise à jour du champ UDP Length
// ********************************************************
CFrameIpDlg::calcul_et_affichage_udp_length();
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
// ********************************************************
// Mise à jour du champ IP Length
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_length();
}
void CFrameIpDlg::OnEn_Change_edit_data()
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
//
********************************************************
// Mise à jour de la variable Data
//
********************************************************
m_edit_data_control.GetWindowText(m_edit_data);
//
********************************************************
// Transformation de la variable si la case à
coché Hexa est active
//
********************************************************
if (m_check_hexa_control.GetCheck())
{
strcpy(tampon_char,m_edit_data);
m_edit_data=conversion_hexa_string(tampon_char,strlen(tampon_char));
}
//
********************************************************
// Mise à jour du champ Data en Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_data_hexa();
//
********************************************************
// Mise à jour du champ UDP Length
//
********************************************************
CFrameIpDlg::calcul_et_affichage_udp_length();
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
//
********************************************************
// Mise à jour du champ IP Length
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_length();
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnEn_Change_edit_size()
{
if (initialisation==1) // Vérifie si la fenêtre est présente
sinon UpdateData fait planter lprogramme
{
//
********************************************************
// Mise à jour de la variable taille de la Data
//
********************************************************
m_edit_size_control.GetWindowText(tampon_char,sizeof(tampon_char));
m_edit_size=(unsigned int)atoi(tampon_char);
//
********************************************************
// Mise à jour du champ Data en Hexa
//
********************************************************
CFrameIpDlg::mise_a_jour_du_champ_data_hexa();
//
********************************************************
// Mise à jour du champ UDP Length
//
********************************************************
CFrameIpDlg::calcul_et_affichage_udp_length();
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
//
********************************************************
// Mise à jour du champ IP Length
//
********************************************************
CFrameIpDlg::calcul_et_affichage_ip_length();
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
}
void CFrameIpDlg::OnBn_Clicked_check_ip_length()
{
// ********************************************************
// Desactivation ou actvation du champ edit IP_length
// ********************************************************
m_edit_ip_length_control.SetReadOnly(m_check_ip_length_control.GetCheck());
// ********************************************************
// Mise à jour du champ Length
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_length();
}
void CFrameIpDlg::OnBn_Clicked_check_ip_flag_none()
{
entete_ipv4.flag_zero=m_check_ip_flag_none_control.GetCheck();
// ********************************************************
// Calcul du checksum IP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
// ********************************************************
// Mise à jour du champ Hexa IP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_ip_flag_df()
{
entete_ipv4.flag_df=m_check_ip_flag_df_control.GetCheck();
// ********************************************************
// Calcul du checksum IP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
// ********************************************************
// Mise à jour du champ Hexa IP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_ip_flag_mf()
{
entete_ipv4.flag_mf=m_check_ip_flag_mf_control.GetCheck();
// ********************************************************
// Calcul du checksum IP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
// ********************************************************
// Mise à jour du champ Hexa IP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_ip_type()
{
// ********************************************************
// Mise à jour du champ IP_type en fonction de la selection
Couche 4
// ********************************************************
CFrameIpDlg::mise_a_jour_de_champ_ip_type();
m_edit_ip_type_control.SetReadOnly(m_check_ip_type_control.GetCheck());
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_ip_checksum()
{
m_edit_ip_checksum_control.SetReadOnly(m_check_ip_checksum_control.GetCheck());
// ********************************************************
// Calcul du checksum IP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_ip_checksum();
// ********************************************************
// Mise à jour du champ Hexa IP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_ip_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_icmp_checksum()
{
m_edit_icmp_checksum_control.SetReadOnly(m_check_icmp_checksum_control.GetCheck());
// ********************************************************
// Calcul du checksum ICMP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_icmp_checksum();
// ********************************************************
// Mise à jour du champ ICMP Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_icmp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_igmp_checksum()
{
m_edit_igmp_checksum_control.SetReadOnly(m_check_igmp_checksum_control.GetCheck());
// ********************************************************
// Calcul du checksum IGMP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_igmp_checksum();
// ********************************************************
// Mise à jour du champ IGMP Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_igmp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_tcp_offset()
{
// ********************************************************
// Desactivation ou actvation du champ edit tcp_offset
// ********************************************************
m_edit_tcp_offset_control.SetReadOnly(m_check_tcp_offset_control.GetCheck());
// ********************************************************
// Calcul de la valeur de Tcp_offset
// ********************************************************
entete_tcp.offset=sizeof(struct tcp)/4; // Offset représente
le nombre de mot de 32 bits donc /4
// ********************************************************
// Mise à jour du champ Tcp_offset
// ********************************************************
sprintf(tampon_char,"%d",entete_tcp.offset);
m_edit_tcp_offset_control.SetWindowText(tampon_char);
}
void CFrameIpDlg::OnBn_Clicked_check_tcp_flag_urg()
{
entete_tcp.flag_urg=m_check_tcp_flag_urg_control.GetCheck();
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
// ********************************************************
// Mise à jour du champ Hexa TCP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_tcp_flag_ack()
{
entete_tcp.flag_ack=m_check_tcp_flag_ack_control.GetCheck();
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
// ********************************************************
// Mise à jour du champ Hexa TCP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_tcp_flag_psh()
{
entete_tcp.flag_psh=m_check_tcp_flag_psh_control.GetCheck();
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
// ********************************************************
// Mise à jour du champ Hexa TCP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_tcp_flag_rst()
{
entete_tcp.flag_rst=m_check_tcp_flag_rst_control.GetCheck();
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
// ********************************************************
// Mise à jour du champ Hexa TCP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_tcp_flag_syn()
{
entete_tcp.flag_syn=m_check_tcp_flag_syn_control.GetCheck();
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
// ********************************************************
// Mise à jour du champ Hexa TCP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_tcp_flag_fin()
{
entete_tcp.flag_fin=m_check_tcp_flag_fin_control.GetCheck();
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
// ********************************************************
// Mise à jour du champ Hexa TCP
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_tcp_checksum()
{
m_edit_tcp_checksum_control.SetReadOnly(m_check_tcp_checksum_control.GetCheck());
// ********************************************************
// Calcul du checksum TCP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_tcp_checksum();
// ********************************************************
// Mise à jour du champ TCP Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_tcp_hexa();
}
void CFrameIpDlg::OnBn_Clicked_check_udp_length()
{
// ********************************************************
// Desactivation ou actvation du champ edit UDP_length
// ********************************************************
m_edit_udp_length_control.SetReadOnly(m_check_udp_length_control.GetCheck());
// ********************************************************
// Mise à jour du champ Length
// ********************************************************
CFrameIpDlg::calcul_et_affichage_udp_length();
}
void CFrameIpDlg::OnBn_Clicked_check_udp_checksum()
{
m_edit_udp_checksum_control.SetReadOnly(m_check_udp_checksum_control.GetCheck());
// ********************************************************
// Calcul du checksum UDP
// ********************************************************
CFrameIpDlg::calcul_et_affichage_udp_checksum();
// ********************************************************
// Mise à jour du champ UDP Hexa
// ********************************************************
CFrameIpDlg::mise_a_jour_du_champ_udp_hexa();
}
void CFrameIpDlg::calcul_et_affichage_ip_length(void)
{
unsigned short tempo_longueur;
if(m_check_ip_length_control.GetCheck()==1)
{
//
********************************************************
// Calcul du champ ip length
//
********************************************************
tempo_longueur=sizeof(struct ipv4);
if (m_check_icmp_header_control.GetCheck()==1)
tempo_longueur=tempo_longueur+sizeof(struct icmp);
if (m_check_igmp_header_control.GetCheck()==1)
tempo_longueur=tempo_longueur+sizeof(struct igmp);
if (m_check_tcp_header_control.GetCheck()==1)
tempo_longueur=tempo_longueur+sizeof(struct tcp);
if (m_check_udp_header_control.GetCheck()==1)
tempo_longueur=tempo_longueur+sizeof(struct udp);
tempo_longueur=tempo_longueur+(unsi |