jo tach auch,
wie müsste der code für ein prog (konsole) aussehen, mit dem ich eine beliebige ip mit einer bestimmten datenmenge anpingen kann ?

Ne discere cessa! - Marcus Porcius Cato

http://openbsd.secsup.org/src/sbin/ping/ping.c

wenns sonst nix is...

2far.net

<Teranite> ich hab nen arschmaessigen traffic

im resourcecode forum gibts von black nen thread "lan admin" oso, da ist sowas drin...

\o tanz den naziprau! o/

And more than ever, I hope to never fall,
Where enough is not the same it was before

Damit ich mal wieder Ärger bekomme, hier der entscheidene Code aus dem Proggy:

Quellcode:#include <winsock2.h>
#include <windows.h>

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

#define ICMP_CODE_NETWORK_UNREACHABLE 0
#define ICMP_CODE_HOST_UNREACHABLE 1

#define ICMP_MIN_SIZE 8

#define STATUS_FAILED 0xFFFF

#define PING_RECVTIMEO 1000 //Wait max x / 1000 seconds
#define PING_FAILED 0xFFFFF0
#define PING_TIMEOUT 0xFFFFF1
#define PING_NOHOST 0xFFFFF2

typedef struct
{
  unsigned int   h_len:4;          // Länge des Headers
  unsigned int   version:4;        // IP Version
  unsigned char  tos;              // Type of service
  unsigned short total_len;        // Gesamt länge des Pakets
  unsigned short ident;            // unique identifier
  unsigned short frag_and_flags;   // flags
  unsigned char  ttl;              // TTL
  unsigned char  proto;            // Protokoll (TCP, UDP etc)
  unsigned short checksum;         // IP Checksumme
  unsigned int   sourceIP;         // Source IP
  unsigned int   destIP;           // Ziel IP
} ip_header_t;

typedef struct
{
  char           i_type;    // Type
  char           i_code;    // Code
  unsigned short i_cksum;   // Prüfsumme
  unsigned short i_id;      // Identifikatior
  unsigned short i_seq;     // Sequenz Nummer
  unsigned long  timestamp; // Um die benötigte Zeit zu messen
} icmp_header_t;
Quellcode:inline void WinsockStartup()
{
    WORD wVersionRequired = MAKEWORD(2, 2);
    WSADATA wdData;

    WSAStartup(wVersionRequired, &wdData);
}

unsigned short 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);
}

DWORD PingComputer(const char *szIP, unsigned int nDataSize)
{
    SOCKET sckSock;    
    SOCKADDR_IN saDest, saFrom;
    int nRecvTimeOut = PING_RECVTIMEO;
    nDataSize += sizeof(icmp_header_t);
    char *szICMPData = 0;
    char szRecvBuff[65000 + sizeof(ip_header_t) + sizeof(icmp_header_t)];
    DWORD dwStart, dwStop;

    WinsockStartup();

    if((sckSock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP)) == INVALID_SOCKET)
        return PING_FAILED;

    if(setsockopt(sckSock, SOL_SOCKET, SO_RCVTIMEO, (char *) &nRecvTimeOut, sizeof(nRecvTimeOut)) == SOCKET_ERROR)
        return PING_FAILED;

    {
        unsigned long ulAddr = inet_addr(szIP);
        HOSTENT *pHostEntity = 0;

        if(ulAddr == INADDR_NONE)
        {
            pHostEntity = gethostbyname(szIP);
            memcpy(&ulAddr, pHostEntity->h_addr, pHostEntity->h_length);
        }

        saDest.sin_addr.s_addr = ulAddr;
        saDest.sin_family = (pHostEntity ? pHostEntity->h_addrtype : AF_INET);
        saDest.sin_port = 0;
    }

    {
        szICMPData = (char *) malloc(sizeof(icmp_header_t) + nDataSize);

        ((icmp_header_t *) szICMPData)->i_cksum = 0;
        ((icmp_header_t *) szICMPData)->i_code = 0;
        ((icmp_header_t *) szICMPData)->i_id = (unsigned short) GetCurrentProcessId();
        ((icmp_header_t *) szICMPData)->i_seq = 0;
        ((icmp_header_t *) szICMPData)->i_type = ICMP_ECHO;

        memset(szICMPData + sizeof(icmp_header_t), ';', nDataSize);        
    }

    {
        ((icmp_header_t *) szICMPData)->timestamp = GetTickCount();
        ((icmp_header_t *) szICMPData)->i_cksum = Checksum((unsigned short *) szICMPData, nDataSize + sizeof(icmp_header_t));
    }

    if(sendto(sckSock, szICMPData, sizeof(icmp_header_t) + nDataSize, 0, (SOCKADDR *) &saDest, sizeof(saDest)) == SOCKET_ERROR)
        return PING_FAILED;

    dwStart = GetTickCount();

    while(true)
    {
        int iResponseLen = 0;

        {
            int nFromLen = sizeof(saFrom);

            iResponseLen = recvfrom(sckSock, szRecvBuff, 65000 + sizeof(ip_header_t) + sizeof(icmp_header_t), 0, (SOCKADDR *) &saFrom, &nFromLen);
            dwStop = GetTickCount();

            if(iResponseLen == SOCKET_ERROR)
            {
                if(WSAGetLastError() == WSAETIMEDOUT)
                    return PING_TIMEOUT;
                else
                    return PING_FAILED;
            }
        }

    
        {
            ip_header_t *hdrIPHeader = (ip_header_t *) szRecvBuff;
            icmp_header_t *hdrICMPHeader = (icmp_header_t *) (szRecvBuff + hdrIPHeader->h_len * 4);
            
            if(hdrICMPHeader->i_id != (unsigned short) GetCurrentProcessId())    //Someone else's packet
                continue;

            if(hdrICMPHeader->i_type == ICMP_UNREACHABLE)
                if(hdrICMPHeader->i_code == ICMP_CODE_HOST_UNREACHABLE || hdrICMPHeader->i_code == ICMP_CODE_NETWORK_UNREACHABLE)
                    return PING_NOHOST;

            if(hdrICMPHeader->i_code == ICMP_ECHOREPLY)    //Ours...
                break;
        }
    }

    free(szICMPData);
    return dwStop - dwStart;
}

Für die blöden: Ich bin Black...

georg-wicherski@pixel-house.net | http://www.pixel-house.net/ - Coding Resource| http://www.google.de/