Anno1989
Bekanntes Mitglied
Hi, habe im Internet folgenden Code gefunden:
Andere IP eingesetzt und kompilliert, es gibt einen sendto error 10004:
WSAEINTR
(10004)
Interrupted function call.
A blocking operation was interrupted by a call to WSACancelBlockingCall.
Ich habe nur leider gar keine Ahnung, was ich falsch mache. Die Firewall meldet sich, drücke ich auf zulassen kommt dieser Error, drücke ich auf ablehnen kommt dass die daten geshcickt wurden, aber es wird leider nichts geschickt, habe das per Wireshark nachgeprüft.
Kann mir da wer unter die Arme greifen, was ich falsch mache?
Edit: Bis zum unterstrichenen geht alles gut....
Code:
#include <winsock2.h> // definiert z.B. Protokolle (IPPROTO_RAW) oder Ports/Sockets (IPPORT_FTP)
#include <stdio.h> // Standard I/O Funktionen wie printf()
#include <string.h> // String und Memory Funktionen wie strcmp() und memset()
#include <ws2tcpip.h> // beinhaltet spezifische Information für Winsock2 wzB. IP_HDRINCL
#pragma comment(lib, "Ws2_32.lib")
#pragma comment(lib, "wininet.lib")
#define NUM_ELEMENTS(x) (sizeof((x)) / sizeof((x)[0]))
struct IPHDR
{
unsigned char verlen; // IP version & length
/* verlen hat 8 Bits, die ersten 4 für die Version
und die letzten 4 für die Länge.
Beispiel: HEX 0x65 ist Binär 0x01100101
Aufgeteilt also 0110 = DEZ 6 und 0101 = DEZ 5
Daraus resultiert Version 6 und Länge 20
*/
unsigned char tos; // IP type of service
/* 1 Byte:
1000 -- minimize delay
0100 -- maximize throughput
0010 -- maximize reliability
0001 -- minimize monetary cost
0000 -- normal service
*/
unsigned short totallength; // Total length
/* 2 Bytes = 16 bits
Länge des IP-Paketes einschließlich der nachfolgenden Daten
*/
unsigned short id; // Unique identifier
/* 16 bit breit.
Dieses und die beiden folgenden Felder 'Flags' und 'Fragment Offset'
steuern die Reassembly (=Zusammensetzen von zuvor fragmentierten IP
Datenpakete). Eindeutige Kennung eines Datagramms. Anhand dieses
Feldes und der 'Source Address' kann der Empfänger die
Zusammengehörigkeit von Fragmenten detektieren und sie wieder
reassemblieren.
*/
unsigned short offset; // Fragment offset field
unsigned char ttl; // Time to live
unsigned char protocol; // Protocol(TCP, UDP, etc.)
unsigned short checksum; // IP checksum
// 16 bit breit. Eine Prüfsumme ausschließlich für den Header
unsigned int srcaddr; // Source address
unsigned int dstaddr; // Destination address
}; // Ende struct IPHDR
struct TCPHDR
{
unsigned short srcport; // Port über den wir senden
unsigned short dstport; // Port den wir ansprechen wollen
unsigned int seqno;
unsigned int ackno;
unsigned char offset;
unsigned char flags; // Art des Pakets:
// FIN / SYN / RST
// PSH / ACK / URG
// ENC / CWR
unsigned short window;
unsigned short checksum;
unsigned short urgptr;
};
struct FORCSUM
{
unsigned int srcaddr;
unsigned int dstaddr;
unsigned char padzero;
unsigned char protocol;
unsigned short tcplength;
};
// Funktions Prototypen
int RawSocket(char destIP[], int destPort, int fd, char srcIP[], int srcPort, int tcpFlag);
int csum(const void *bufv, int length);
void IP_auslesen(char* IP_ADRESSE);
int SockAttempt(int * fd);
int main(int argc, char *argv[])
{
//Deklaration der benötigte Variablen
char srcIP[MAX_PATH], destIP[MAX_PATH];
int destPort, srcPort, tcpFlag, fd;
//Initialisierung der Variablen
IP_auslesen(srcIP);
strcpy(destIP,"193.99.144.71"); // ping auf www.heise.de
destPort = 80;
srcPort = 1723; // PPTP Port
tcpFlag = 2; // SYN Flag
fd = 0;
system("CLS");
printf("Settings:\r\n");
printf("---------\r\n");
printf("Source IP : %s\r\n",srcIP);
printf("Source Port : %i\r\n",srcPort);
printf("Destination IP : %s\r\n",destIP);
printf("Destination Port: %i\r\n",destPort);
printf("\r\n");
printf("Now attempting to create socket...\r\n");
if(SockAttempt(&fd)==0)
{
printf("... successful !!!\r\n\r\n");
}
printf("Creating own TCP/IP headers...\r\n");
RawSocket(destIP, destPort, fd, srcIP, srcPort, tcpFlag);
closesocket(fd);
WSACleanup();
system("PAUSE");
return 0;
}
int SockAttempt(int * fd)
{
WORD sockVersion;
WSADATA wsaData;
int iErr = 0, opt = 1;
sockVersion = MAKEWORD(2, 2);
if (WSAStartup(sockVersion, &wsaData)!=0)
{
printf("WSAStartup Error -> ");
iErr = WSAGetLastError();
}
else
{
*fd = WSASocket(AF_INET,SOCK_RAW,IPPROTO_RAW,NULL,0,WSA_FLAG_OVERLAPPED);
if (*fd == SOCKET_ERROR)
{
printf("WSASocket Error -> ");
iErr = WSAGetLastError();
}
else
{
if (setsockopt(*fd, IPPROTO_IP, IP_HDRINCL,(char*)&opt, sizeof(opt)) == SOCKET_ERROR)
{
printf("setsockopt Error -> ");
iErr = WSAGetLastError();
}
}
}
return iErr;
}
int RawSocket(char destIP[], int destPort, int fd, char srcIP[], int srcPort, int tcpFlag)
{
struct sockaddr_in to;
struct FORCSUM forcsum;
struct TCPHDR tcp;
struct IPHDR ip;
char buf[60] = {0};
int iErr;
to.sin_family = AF_INET;
to.sin_port = htons((u_short)destPort);
to.sin_addr.s_addr = inet_addr(destIP);
// IP header erstellen
ip.verlen = 0x45;
ip.tos = 0x00;
ip.totallength = 24;
ip.id = 1;
ip.offset = 0;
ip.ttl = 0x80;
ip.protocol = IPPROTO_TCP;
ip.checksum = 0;
ip.dstaddr = inet_addr(destIP);
ip.srcaddr = inet_addr(srcIP);
// TCP header erstellen
tcp.dstport = htons((u_short)destPort);
tcp.ackno = 0;
tcp.offset = (unsigned char)(80);
tcp.flags = tcpFlag;
tcp.window = htons(0x4000);
tcp.urgptr = 0;
tcp.checksum = 0;
forcsum.dstaddr = ip.dstaddr;
forcsum.padzero = 0;
forcsum.protocol = IPPROTO_TCP;
forcsum.tcplength = htons(sizeof(tcp));
tcp.srcport = htons((u_short)srcPort);
tcp.seqno = htonl((unsigned short)((rand()<<16)|rand()));
forcsum.srcaddr = inet_addr(srcIP);
memcpy(buf, &forcsum, sizeof(forcsum));
memcpy(buf+sizeof(forcsum), &tcp, sizeof(tcp));
tcp.checksum = csum(buf, sizeof(forcsum)+sizeof(tcp));
memcpy(buf, &ip, sizeof(ip));
memcpy(buf+sizeof(ip), &tcp, sizeof(tcp));
memset(buf+sizeof(ip)+sizeof(tcp), 0,sizeof(buf)-sizeof(ip)-sizeof(tcp));
ip.checksum = csum(buf, sizeof(ip)+sizeof(tcp));
memcpy(buf, &ip, sizeof(ip));
printf("done...\r\n");
printf("Attempting to send data...\r\n");
[B][U] iErr = sendto(fd, buf, sizeof(ip)+sizeof(tcp), 0,(struct sockaddr*)&to, sizeof(to));
if(iErr == SOCKET_ERROR)
{
iErr = WSAGetLastError();
printf("sendto Error: %i\r\n\r\n",iErr);
}
else
printf("Bytes Sent: %i\r\n\r\n",iErr);
return 0;
}
[/U]
[/B]
int csum(const void *bufv, int length)
{
const unsigned short *buf = (const unsigned short *)bufv;
unsigned long result = 0;
while (length > 1) {
result += *(buf++);
length -= sizeof(*buf);
}
if (length) result += *(unsigned char*)buf;
result = (result >> 16) + (result & 0xFFFF);
result += (result >> 16);
result = (~result)&0xFFFF;
return (int)result;
}
void IP_auslesen(char* IP_ADRESSE)
{
struct hostent* h;
WSADATA wsaData;
UCHAR ucAddress[4];
CHAR szHostName[MAX_PATH];
int x;
WSAStartup(MAKEWORD(1, 1), &wsaData);
if(SOCKET_ERROR != gethostname(szHostName, NUM_ELEMENTS(szHostName)))
{
if(NULL != (h = gethostbyname(szHostName)))
{
for(x = 0; (h->h_addr_list[x]); x++)
{
ucAddress[0] = h->h_addr_list[x][0];
ucAddress[1] = h->h_addr_list[x][1];
ucAddress[2] = h->h_addr_list[x][2];
ucAddress[3] = h->h_addr_list[x][3];
wsprintf(IP_ADRESSE, "%d.%d.%d.%d", ucAddress[0], ucAddress[1], ucAddress[2], ucAddress[3]);
}
}
}
WSACleanup();
}
WSAEINTR
(10004)
Interrupted function call.
A blocking operation was interrupted by a call to WSACancelBlockingCall.
Ich habe nur leider gar keine Ahnung, was ich falsch mache. Die Firewall meldet sich, drücke ich auf zulassen kommt dieser Error, drücke ich auf ablehnen kommt dass die daten geshcickt wurden, aber es wird leider nichts geschickt, habe das per Wireshark nachgeprüft.
Kann mir da wer unter die Arme greifen, was ich falsch mache?
Edit: Bis zum unterstrichenen geht alles gut....