127.0.0.1 und localhost

[R3dNeXX]

hi leute,

ich habe ein Programm, mit dem man Text an den Server senden kann und der den Text dann ausgibt, also ein TCP-Echo als Client-Server-Programm.
Ich verstehe bloß nicht, wieso mein Programm funktioniert, wenn ich beim Client als Server-IP localhost eingebe, 127.0.0.1 als Server-IP geht aber nicht !

Hier der Code:
socket.h

#ifndef _SOCKET_H
#define _SOCKET_H
#include <iostream>
#include <Windows.h>
#include <WinSock.h>
#include <string>
using namespace std;

// max. Anzahl Verbindungen
const int MAXCONNECTIONS = 5;
// max. Anzahl Daten, die auf einmal empfangen werden
const int MAXRECV = 1024;

class Socket
{
private:
	// Socket-Deskriptor
	int m_sock;
	// Struktur sockaddr_in
	sockaddr_in m_addr;

public:
	Socket();
	~Socket();

	// Socket erstellen - TCP
	bool create();
	// Socket erstellen - UDP
	bool UDP_create();
	bool bind(const int port);
	bool listen() const;
	bool accept(Socket&) const;
	bool connect(const string host, const int port);

	// Datenübertragung TCP
	bool send(const string) const;
	int recv(string&) const;
	// Datenübertragung UDP
	bool UDP_send(const string, const string, const int port) const;
	int UDP_recv(string&) const;

	// Socket schließen
	bool close() const;
	// WSACleanup()
	void cleanup() const;
	bool is_valid() const;
};

class SockExcept
{
private:
	string except;

public:
	SockExcept(string s) : except(s) {};
	~SockExcept() {};
	string get_SockExcept() {return except;};
};
#endif

socket.cpp

#include <iostream>
#include <Windows.h>
#include <WinSock.h>
#include <string>
#include "socket.h"
using namespace std;

Socket::Socket() : m_sock(0)
{
	// WinSock.dll initialisieren
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD(2, 0);
	if (WSAStartup(wVersionRequested, &wsaData) != 0)
	{
		throw SockExcept("Fehler beim Initialisieren von Winsock\n");
		cleanup();
	}
}

Socket::~Socket()
{
	if (is_valid())
		::closesocket(m_sock);
}

bool Socket::is_valid() const
{
	return m_sock != -1;
}

// erzeugt das Socket-TCP
bool Socket::create()
{
	m_sock = (int)::socket(AF_INET, SOCK_STREAM, 0);
	if (m_sock < 0)
	{
		throw SockExcept("Fehler beim Anlegen eines Socket\n");
	}
	return true;
}

// erzeugt das Socket-UDP
bool Socket::UDP_create()
{
	m_sock = (int)::socket(AF_INET, SOCK_DGRAM, 0);
	if (m_sock < 0)
	{
		throw SockExcept("Fehler beim Anlegen eines Socket\n");
		exit(1);
	}
	return true;
}

// Bindung an bestimmten Port
bool Socket::bind(const int port)
{
	if (!is_valid())
	{
		return false;
	}
	m_addr.sin_family = AF_INET;
	m_addr.sin_addr.s_addr = INADDR_ANY;
	m_addr.sin_port = htons(port);

	int bind_return = ::bind(m_sock, (struct sockaddr*) &m_addr, sizeof(m_addr));
	if (bind_return == -1)
		return false;

	return true;
}

// Socket mitteilen, dass Verbindungswünsche von Clients entgegengenommen werden
bool Socket::listen() const
{
	if (!is_valid())
		return false;

	int listen_return = ::listen(m_sock, MAXCONNECTIONS);
	if (listen_return == -1)
		return false;

	return true;
}

// Verbindungswünsche von Clients bearbeiten
// Aufruf von accept() blockiert so lange, bis ein Client Verbindung aufnimmt
bool Socket::accept(Socket& new_Socket) const
{
	int addr_length = sizeof(m_addr);
	new_Socket.m_sock = (int)::accept(m_sock, (sockaddr*) &m_addr, (int*) &addr_length);

	if (new_Socket.m_sock <= 0)
		return false;
	else
		return true;
}

// baut Verbindung zum Server auf
bool Socket::connect(const string host, const int port)
{
	if (!is_valid())
	{
		return false;
	}

	struct hostent *host_info;
	unsigned long addr;
	memset(&m_addr, 0, sizeof(m_addr));
	if (addr = inet_addr(host.c_str()) != INADDR_NONE)
	{
		// argv[1] ist eine numerische IP_Adresse
		memcpy((char*) &m_addr.sin_addr, &addr, sizeof(addr));
	}
	else
	{
		// Servernamen (z.B. localhost) in IP-Adresse umwandeln
		host_info = gethostbyname(host.c_str());
		if (host_info == NULL)
		{
			throw SockExcept("Unbekannter Server\n");
			exit(1);
		}
		memcpy((char*) &m_addr.sin_addr, host_info->h_addr, host_info->h_length);
	}

	m_addr.sin_family = AF_INET;
	m_addr.sin_port = htons(port);
	int status = ::connect(m_sock, (sockaddr*) &m_addr, sizeof(m_addr));
	if (status == 0)
		return true;
	else
		return false;
}

// Daten versenden via TCP
bool Socket::send(const std::string s) const
{
	int status = ::send(m_sock, s.c_str(), (int)s.size(), 0);
	if (status == -1)
		return false;
	else
		return true;
}

// Daten empfangen via TCP
int Socket::recv(std::string &s) const
{
	char buf[MAXRECV+1];
	s = "";
	memset(buf, 0, MAXRECV+1);

	int status = ::recv(m_sock, buf, MAXRECV, 0);
	if (status > 0 || status != SOCKET_ERROR)
	{
		s = buf;
		return status;
	}
	else
	{
		throw SockExcept("Fehler in Socket::recv\n");
		exit(1);
		return 0;
	}
}

// Daten versenden via UDP
bool Socket::UDP_send(const string addr, const string s, const int port) const
{
	struct sockaddr_in addr_sento;
	struct hostent *h;
	int rc;

	h = gethostbyname(addr.c_str());
	if (h == NULL)
	{
		throw SockExcept("Unbekannter Host\n");
		exit(1);
	}
	addr_sento.sin_family = h->h_addrtype;
	memcpy((char*) &addr_sento.sin_addr.s_addr, h->h_addr_list[0], h->h_length);
	addr_sento.sin_port = htons(port);
	rc = sendto(m_sock, s.c_str(), (int)s.size(), 0, (struct sockaddr *) &addr_sento, sizeof(addr_sento));

	if (rc == SOCKET_ERROR)
	{
		throw SockExcept("Konnte Daten nicht senden - sendto()\n");
		exit(1);
	}
	return true;
}

// Daten empfangen via UDP
int Socket::UDP_recv(std::string &s) const
{
	struct sockaddr_in addr_recvfrom;
	int len, n;
	char buf[MAXRECV+1];
	s = "";
	memset(buf, 0, MAXRECV+1);
	len = sizeof(addr_recvfrom);
	n = recvfrom(m_sock, buf, MAXRECV, 0, (struct sockaddr*) &addr_recvfrom, &len);

	if (n == SOCKET_ERROR)
	{
		throw SockExcept("Fehler bei recvfrom()\n");
		exit(1);
		return 0;
	}
	else
	{
		s = buf;
		return n;
	}
}

// Winsock.dll freigeben
void Socket::cleanup() const
{
	WSACleanup();
}

// Socket schließen und Winsock.dll freigeben
bool Socket::close() const
{
	closesocket(m_sock);
	cleanup();
	return true;
}

Server

#include <iostream>
#include <fstream>
#include <string>
#include <conio.h>
#include "socket.h"

int main(int argc, char *argv[])
{
	Socket sock1;
	sock1.create();
	ofstream output("serverlog.txt", ios::out|ios::app);
	cout << "Server gestartet\n";

	// Port 15000 verwenden
	sock1.bind(15000);
	sock1.listen();
	if (output.is_open() != true)
		cerr << "Fehler beim Oeffnen von serverlog.txt\n";

	while (true)
	{
		Socket sock2;
		sock1.accept(sock2);
		string s;
		sock2.recv(s);
		cout << "Nachricht von Client erhalten: ";
		cout << s << endl;
		output << s << endl;
		sock2.close();
	}

	output.close();
	sock1.close();

	_getch();
	return 0;
}

Client

#include <iostream>
#include <string>
#include <conio.h>
#include "socket.h"
using namespace std;

int main(int argc, char *argv[])
{
	Socket sock;
	sock.create();
	if (argc < 2)
	{
		cout << "Usage: " << *argv << " ServerAdresse\n";
		exit(1);
	}

	// Adresse des Servers
	string argv_1 = argv[1];
	// mit Server auf Port 15000 verbinden
	sock.connect(argv_1, 15000);
	cout << "Nachricht an Server: ";
	string s;
	getline(cin, s, '\n');
	sock.send(s);

	sock.close();

	_getch();
	return 0;
}

Wäre schön, wenn ihr mir helfen könnt !

thx und mfg

[C++ Forumbot]

Dieser Thread wurde von Moderator/in rüdiger aus dem Forum Rund um die Programmierung in das Forum WinAPI verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

[Vermillion]

Da hast du aber viel Code und wenig Informationen gepostet...

Ansonsten versuchs mal so:

long getAddrFromString(char* hostnameOrIp, SOCKADDR_IN* addr)
{ 
  unsigned long ip;
  HOSTENT* he;
  /* Parameter prüfen */
  if(hostnameOrIp==NULL || addr==NULL)
    return SOCKET_ERROR;
  /* ist eine IP in hostnameOrIp ? */
  ip=inet_addr(hostnameOrIp);
  /* bei einem fehler liefert inet_addr den Rückgabewert INADDR_NONE */
  if(ip!=INADDR_NONE)
  {
    addr->sin_addr.s_addr=ip;
    return 0;
  }
  else
  {
    /* Hostname in hostnameOrIp auflösen */
    he=gethostbyname(hostnameOrIp);
    if(he==NULL)
    {
      return SOCKET_ERROR;
    }
    else
    {
      /*die 4 Bytes der IP von he nach addr kopieren */
      memcpy(&(addr->sin_addr),he->h_addr_list[0],4);
    }
    return 0;

[R3dNeXX]

ok, hat funktioniert !

danke für die hilfe

mfg