127.0.0.1 und localhost



  • 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



  • 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.



  • 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;
    


  • ok, hat funktioniert !

    danke für die hilfe 😉

    mfg


Log in to reply