socket verwaltung

xerxes_

hi,
ich suche zur zeit ein ping modul.
hab mir fremden code bis jetzt nur fehler verursacht. deshalb schrieb ich meine eigene ping klasse.
eine range wird angepingt mit ca. 10 threads.

folgendes ergebnis.

socket: 828 213.147.1.38   213.147.1.41   -
socket: 844 213.147.1.38   213.147.1.40   -
socket: 860 213.147.1.38   213.147.1.39   -
socket: 876 213.147.1.38   213.147.1.38   1
socket: 828 213.147.1.41   213.147.1.45   -
socket: 844 213.147.1.41   213.147.1.44   -
socket: 860 213.147.1.41   213.147.1.43   -
socket: 876 213.147.1.41   213.147.1.42   -
socket: 828 213.147.1.45   213.147.1.48   -
socket: 844 213.147.1.45   213.147.1.47   -
socket: 860 213.147.1.45   213.147.1.46   -
socket: 860 213.147.1.40   213.147.1.49   -

socket: 876 213.147.1.38 213.147.1.38 1
<socketid> <antwort von> <request gesendet an> <lebt?>

nun sieht ihr an der tabelle oben das da was faul ist.
wieso haben 4 verschiedene sockets die ip eines serves?
ein thread pingt die ip 213.147.1.44 an und bekommt die antwort von 213.147.1.41. das versteh ich nicht.

gruß xerxes

post mal deinen code mit der ping klasse usw..

cu

du hast ja 10 threads, die arbeiten parallel
wenn du also alle ips da gleichzeitig anpingst....dann bekommst du je nach dem welcher server schneller antwortet das ergebniss...oder????

cu

xerxes_

#include <windows.h>
#include <stdlib.h>
#include <string>
#include <sstream>
#include <iostream>
#include <stdio.h>
#include <iostream.h>

#include "icmp.h"

using namespace std;

#define ICMP_ECHOREPLY                 0
#define ICMP_UNREACHABLE               3
#define ICMP_ECHO                      8

// 0 = Netz nicht erreichbar
#define ICMP_CODE_NETWORK_UNREACHABLE  0
// 1 = Rechner nicht erreichbar
#define ICMP_CODE_HOST_UNREACHABLE     1

// Minimalgrösse 8 Byte
#define ICMP_MIN            8

#define STATUS_FAILED       0xFFFF
#define DEF_PACKET_SIZE     32
#define MAX_PACKET          65000 

int ICMP_::echo_ex(string ip)
{  
  SOCKADDR_IN addrDest;
  SOCKADDR_IN addrFrom;
  int addrFromLen = sizeof(addrFrom);
  HOSTENT* ptrHostent;
  unsigned long datasize;
  int RecvTimeout = 1000;
  char *dest_ip;
  char *icmp_data;
  char *recvbuf;
  unsigned int addr=0;
  unsigned short seq_no = 0;
  int BytesReceived;
  int BytesSent;
  long rc;
  unsigned ping_anzahl=0;

  sockRaw = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
  if (sockRaw == INVALID_SOCKET)
  {

  }
  rc = setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char*)&RecvTimeout, sizeof(RecvTimeout));
  if(rc == SOCKET_ERROR)
  {

  }

	memset(&addrDest,0,sizeof(SOCKADDR_IN)); 
	addrDest.sin_addr.s_addr = inet_addr(ip.c_str());
    addrDest.sin_family = AF_INET;

    //dest_ip = inet_ntoa(addrDest.sin_addr);

  // Gröss des Datenpaketes
  datasize = 32;

  if (datasize == 0)
  {
     datasize = DEF_PACKET_SIZE;
  }

  if (datasize > MAX_PACKET)
  {
     datasize = DEF_PACKET_SIZE;
  }
  datasize += sizeof(ICMP_HEADER); 
  icmp_data = (char*)malloc(MAX_PACKET);
  recvbuf = (char*)malloc(MAX_PACKET+sizeof(IP_HEADER)+sizeof(ICMP_HEADER));

  if (!icmp_data || !recvbuf)
  {

  }

  FillIcmpData(icmp_data, datasize);

    ((ICMP_HEADER*)icmp_data)->i_cksum = 0;
    ((ICMP_HEADER*)icmp_data)->timestamp = GetTickCount();

    ((ICMP_HEADER*)icmp_data)->i_seq = seq_no++;
    ((ICMP_HEADER*)icmp_data)->i_cksum = checksum((unsigned short*)icmp_data, datasize);

    BytesSent = sendto(sockRaw,icmp_data,datasize,0,(SOCKADDR*)&addrDest, sizeof(addrDest));

    if (BytesSent == SOCKET_ERROR)
    {
      if (WSAGetLastError() == WSAETIMEDOUT)
      {
      }

    }
    if (BytesSent < datasize )
    {
   }
    BytesReceived = recvfrom(sockRaw,recvbuf,MAX_PACKET+sizeof(IP_HEADER)+sizeof(ICMP_HEADER),0,(SOCKADDR*)&addrFrom, &addrFromLen);   	
	cur_ip = inet_ntoa(addrFrom.sin_addr);
	if(!ip.find(inet_ntoa(addrFrom.sin_addr))){
		if (BytesReceived == SOCKET_ERROR){
			if (WSAGetLastError() == WSAETIMEDOUT){
				//return 1;
			}
			closesocket(sockRaw);	
			return 1;
		} else{
			closesocket(sockRaw);	
			return 0;
		}
	}
	closesocket(sockRaw);	
  return 1;
}

unsigned short ICMP_::checksum(unsigned short *buffer, int size)
{
  unsigned long cksum=0;
  while(size >1)
  {
    cksum+=*buffer++;
    size -=sizeof(unsigned short);
  }

  if(size)
  {
    cksum += *(unsigned char*)buffer;
  }

  cksum = (cksum >> 16) + (cksum & 0xffff);
  cksum += (cksum >>16);
  return (unsigned short)(~cksum);
}

void ICMP_::FillIcmpData(char *icmp_data, int datasize)
{
  ICMP_HEADER *icmp_hdr;
  char *datapart;

  icmp_hdr = (ICMP_HEADER*)icmp_data;

  icmp_hdr->i_type = ICMP_ECHO;
  icmp_hdr->i_code = 0;
  icmp_hdr->i_id = cur_proc_addr;
  icmp_hdr->i_cksum = 0;
  icmp_hdr->i_seq = 0;

  datapart = icmp_data + sizeof(ICMP_HEADER);
  // Den Buffer mit etwas füllen
  memset(datapart,'C', datasize - sizeof(ICMP_HEADER));
}

du hast ja 10 threads, die arbeiten parallel
wenn du also alle ips da gleichzeitig anpingst....dann bekommst du je nach dem welcher server schneller antwortet das ergebniss...oder????

jeder thread wird bedient. der fall das mehrer threads die gleiche ip auflösen, tritt nie ein. ich finde es komisch, das mehrere sockets das ergebnis einer anderen anfrage bekommen ...

hast du auch die ausgabe synchronisiert?

xerxes_

LONG crit_sec = false; 

DWORD WINAPI process(LPVOID lp_para)
{
	THREAD *t = (THREAD*)lp_para;	

	DWORD cur_proc_addr = GetCurrentThreadId();
	ICMP_ *icmp = new ICMP_((unsigned short)cur_proc_addr);

	while(!t->get_term()){
		if(t->get_work_state()){	
			int res;
			res = icmp->echo_ex(t->get_ip());
			string tmp;

			if(!res){
				enter();				
				 tmp = "   " + t->get_ip() + " ->     1\n"; 
				 fputs(tmp.c_str(), file);
				 cout << "> ";
				 cout << tmp;				 
				leave();
			} else{
				enter();				
				 tmp = "   " + t->get_ip() + " ->     -\n"; 
				 fputs(tmp.c_str(), file);
				 cout << "> ";
				 cout << tmp;
				leave();
			}

			t->set_work_state(false);
		}

		Sleep(1);
	}
	return ((DWORD) lp_para);
}

void enter(void)
{
   while(InterlockedExchange(&crit_sec, true) != false)
      Sleep(0); 
}

void leave(void)
{
   InterlockedExchange(&crit_sec, false); 
}