POP3 Problem

[Kmitska]

Hallo Leute,

ich habe nun vor einen E-Mail Client zu programmieren.
Habe folgenden Link bekommen, der zur Einführung zur POP3 dienen soll:
http://tools.ietf.org/html/rfc1939

Ich würde gerne die E-Mails laden und über mein Programm lesen können.
Auf dieser Seite steht, dass ich mich mit dem Server unterhalten soll indem ich Befehle eingebe.

Nun die Frage: Wie geht denn so etwas?
Was ich versucht habe:
- Verbindung zur: pop3.live.com Port: 995 (Hotmail)
- Und eine while-Schleife eingebaut, das auf eingehende Nachrichten abwartet
-> Leider kam nichts

Mit freundlichen Grüßen,
Kmitska

[nufan]

Hallo
Ohne deinen Code zu sehen, können wir dir nur sehr schwer helfen.

[cloidnerux]

Nun die Frage: Wie geht denn so etwas?
Was ich versucht habe:
- Verbindung zur: pop3.live.com Port: 995 (Hotmail)
- Und eine while-Schleife eingebaut, das auf eingehende Nachrichten abwartet
-> Leider kam nichts

Die Frage ist, wie du die Anfrage gestellt hast.
So wie ich das sehe, musst du dem Server ein Textbasierten POP3 befehl zusenden via TCP/IP und dann auf die entsprechende Antwort warten und dann den nächsten Befehl und so weiter.
Aber ohne Code, wie dani93 schon erwähnt hat, können wir da nicht viel sagen.

[Kmitska]

Also der Code ist eigentlich ganz einfach,

der MAIN teil:

Code: Alles auswählen

int main ( void )
{
    Socket client;
    client.create();
    client.connect( "pop.gmail.com", 995 );

    string ID;

    client.recv(ID);
    cout << "> " << ID << endl;
    client.close();
}

und hier ist die Socket-Klasse, die ich aus meinem Buch habe (C++ von A-Z, Galileo Computing)

Code: Alles auswählen

// socket.cpp
#include <cstdlib>
#include <winsock.h>
#include <io.h>
#include <iostream>
#include "socket.h"
using namespace std;

// Konstruktor
Socket::Socket() : m_sock(0) {
   // Winsock.DLL Initialisieren
   WORD wVersionRequested;
   WSADATA wsaData;
   wVersionRequested = MAKEWORD (1, 1);
   if (WSAStartup (wVersionRequested, &wsaData) != 0) {
      throw SockExcept(
             "Fehler beim Initialisieren von Winsock");
   }
}

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

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

// Erzeugt das Socket  - UDP
bool Socket::UDP_create() {
   m_sock = ::socket(AF_INET,SOCK_DGRAM,0);
   if (m_sock < 0) {
      throw SockExcept("Fehler beim Anlegen eines Socket");
   }
}

// Erzeugt die Bindung an die Serveradresse
// - genauer an einen 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;     
}

// Teile dem Socket mit, 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;
}

// Bearbeite die Verbindungswünsche von Clients
// Der Aufruf von accept() blockiert solange,
// bis ein Client Verbindung aufnimmt
bool Socket::accept ( Socket& new_socket ) const {
   int addr_length = sizeof ( m_addr );
   new_socket.m_sock = ::accept( m_sock,
      ( sockaddr * ) &m_addr, ( int * ) &addr_length );
   if ( new_socket.m_sock <= 0 )
      return false;
   else
      return true;
}

// Baut die 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 {
       /* Für den Fall der Fälle: Wandle den Servernamen *
        * bspw. "localhost" in eine IP-Adresse um        */
       host_info = gethostbyname( host.c_str() );
       if (NULL == host_info) {
          throw SockExcept("Unbekannter Server");
       }
       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 string s ) const {
   int status = ::send ( m_sock, s.c_str(), s.size(),  0 );
   if ( status == -1 ) {
      return false;
   }
   else {
      return true;
   }
}

// Daten empfangen via TCP
int Socket::recv ( 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");
     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?");
   }
   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(), s.size(), 0,
                 (struct sockaddr *) &addr_sento,
                  sizeof (addr_sento));
   if (rc == SOCKET_ERROR) {
      throw SockExcept(
         "Konnte Daten nicht senden - sendto()");
   }        
   return true;
}

// Daten empfangen vie UDP
int Socket::UDP_recv( 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()");
      return 0;
   }
   else {
      s = buf;
      return n;
   } 
}

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

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

Edit by cloidnerux: Code Tags eingefügt

[cloidnerux]

Also der Code ist eigentlich ganz einfach,

Und da liegt auch das Problem, das du keine Antwort erhälst: Du stellst keine Anfrage.
Mit Create und Connect stellst du eine Verbindung her, aber nur auf Stack-Ebene.
Daher wird noch kein Dienst oder Server oder was auch immer angesprochen, sondern es besteht nur die Möglichkeit das zu tun. Daher musst du jetzt erstmal eine Anfrage stellen auf die der Server dann reagieren kann.

[Kmitska]

Hmm, ok...
Habe nun so gemacht:
string ID;
client.send("stat"); //habe dies hinzugefügt erhalte aber immer noch keine Antwort.
client.recv(ID);

Wie mach ich denn jetzt so etwas?

[cloidnerux]

Wieso nutzt du Port 995, wenn im RFC Port 110 angegeben ist?
So wie ich das sehe, ist Port 995 für eine "Secure"-Verbindung, sprich ssl verschlüsselte Verbindungen.

Dann solltest du sicherstellen, das dein Programm sich auch wirklich mit dem Server verbindet.
Daher entweder mit irgend einem Programm die Netzwerk Verbindungen überwachen oder gleich mit Wireshark den kompletten Netzwerkverkehr.

Zudem empfiehlt es sich, das RFC-Dokument durchzulesen, da es viel Ausschluss darüber gibt, was gemacht werden muss und was passieren sollte.

Dann wundert es mich gerade doch gewaltig, das dein Compiler bei dieser Zeile nicht rummeckert:

Code: Alles auswählen

client.recv(ID);

"recv" erwartet einen Pointer auf einen String, nicht den String...

[Kmitska]

Also habe jetzt so etwas gemacht:

Code: Alles auswählen

int main ( void )
{
    Socket client;
    client.create();
    client.connect( "pop.gmail.com", 110 );

    string ID;
    while(true)
    {
        client.recv(ID);
        cout << "> " << ID << endl;
    }
    client.close();
}

ich müsste laut der Seite eine Nachricht erhalten...
Und was client.recv(ID); angeht, auf diese Art und Weise hatte ich sogar einen Chat programmiert und es hat wunderbar funktioniert.

=========== EDIT ==========:
Wenn ich Port 110 mache, lasst sich das Programm nicht mehr leicht schließen, gehe davon aus (laut Foren), dass das Port von gmail POP server 995 ist.

[Kmitska]

Someone who might help? :/

[cloidnerux]

Someone who might help? :/

Dein Problem ist jetzt nicht einfach nur ein simpler Fehler, sondern sehr komplex, da du hier Programmieren musst und nicht einfach nur ein Beispielprogramm nachschreiben sollst.
Daher musst DU dem Fehler auf den Grund gehen und verstehen warum, bzw warum es eben nicht Funktioniert.
Daher müsstest du erstmal überprüfen, ob eine Verbindung Aufgebaut wird, ob Daten versendet werden(Wireshark), ob die Ports richtig sind, ob du die richtigen Pakete versendet, vlt sogar selbst ein paar ICMP-Packages senden.
Deine Klasse testen, evt es mit einer anderen Implementation testen oder deinen Code noch einmal stück für Stück durchgehen.

Es kann sich auch um triviale Fehler handeln, z.B dass deine Klasse den Hostnamen nicht auflösen kann.
Daher hast du entweder die Möglichkeit zu warten bis evt irgendjemand eine Idee oder Lösung für dein Problem hat oder setzt dich selber daran und versuchst selber dem Problem auf die Spur zu kommen.

MfG cloidnerux.