[C++] Protocollo FTP..

[Stobby]

Salve a tutti,
per motivi di studio sto scrivendo un piccolo programma in C++ che, avvalendosi della libreria winsock2 opera in modalità client sul protocollo FTP.
Attualmente sarei interessato a riuscire a gestire un trasferimento di dati in Active mode, tuttavia mi trovo di fronte ad un problema che mi sta creando non pochi grattacapi.
Secondo le specifiche del protocollo FTP, quando la connessione è in Active mode, il client contatta il server da una porta random N verso la porta 21 e, una volta stabilita la connessione, tramite il comando PORT segnala al server la porta su cui il client è in ascolto per la trasmissione dati (che deve essere la porta N+1).
Attualmente mi trovo nella situazione di essere in grado di avviare la connessione sulla porta 21 in modo corretto, tuttavia, non riesco a stabilire la connessione dati (porta 20 lato server). Il mio problema principale infatti risiede nel fatto che non sono in grado di leggere la porta che randomicamente è scelta da windows per uscire dal mio pc (client) e quindi non sono in grado di determinare quale è la porta N+1 da comunicare come argomento del comando PORT... ho letto praticamente tutto quello che msdn fornisce a livello di documentazione ma non ho trovato risposte.
Ringrazio tutti coloro che potranno darmi una mano.

Ciao

[Ikon O'Cluster]

Premetto che le API WinSock2 non le conosco. Ma mi sono documentato appositamente e ho letto che si basano sui socket BSD quindi forse ti posso aiutare. Inoltre non ho freschissimo il protocollo FTP, ma mi sembra di avere tutti gli elementi significativi grazie alla tua spiegazione.

Mi sembra di capire che il server è pre-esistente. Il tuo problema è il client. Io adesso mi esprimo usando solo socket BSD, penso che la fatica per adattare il lavoro sia poca per chi conosce come funzionano le API WinSock. Tutto quello che scrivo ora (malgrado i nomi delle funzioni) sta sul client.

Prendiamo la funzione che contatta un server ad un dato indirizzo e porta TCP:

int client(const char* ip_addr, int tcp_port) {
   int ret;

   int sv_sd = socket(PF_INET, SOCK_STREAM, 0);
   if(sv_sd < 0) return -1;

   struct sockaddr_in sv_addr;
   bzero(&sv_addr, sizeof(sv_addr));

   sv_addr.sin_family = AF_INET;
   sv_addr.sin_port = htons(tcp_port);
   sv_addr.sin_addr.s_addr = inet_addr(ip_addr);

   ret = connect(sv_sd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
   if(ret < 0) return -1;
   return sv_sd;
}

E la funzione per mettere in ascolto un socket su una data porta TCP:

int server(unsigned short int tcp_port, int queue_len) {
      int ret;

      int sv_sd = socket(PF_INET, SOCK_STREAM, 0);
      if(sv_sd < 0) return -1;

      struct sockaddr_in sv_addr;
      bzero(&sv_addr, sizeof(sv_addr));

      sv_addr.sin_family = AF_INET;
      sv_addr.sin_port = htons(tcp_port);
      sv_addr.sin_addr.s_addr = INADDR_ANY;

      ret = bind(sv_sd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
      if(ret < 0) return -1;

      ret = listen(sv_sd, queue_len);
      if(ret < 0) return -1;

      int cl_sd;
      struct sockaddr_in cl_addr;
      int cl_addr_len = sizeof(cl_addr);
      cl_sd = accept(sv_sd, (struct sockaddr*)&cl_addr, &cl_addr_len);
      return cl_sd;
}

Adesso usiamole così:

char sv_ip_addr[16] = "127.0.0.1"; // Loopback a scopo di test
unsigned short sv_ftp_ctrl_port = 21;
unsigned short cl_ftp_data_port = 12345; // Porta casuale

int ftp_ctrl_sd = client(sv_ip_addr, sv_ftp_ctrl_port);
if(ftp_ctrl_sd < 0) return -1;
//...

int ftp_data_sd = server(cl_ftp_data_port, 10);
if(ftp_data_sd < 0) return -1;
//...

// In questo punto la porta da comunicare attraverso il socket ftp_ctrl_sd è cl_ftp_data_port!

Spero che ti sia utile...

P.S.: Il codice non è testato.

[Stobby]

Ciao!
Innanzitutto, grazie per la disponibilità .
Ho letto il tuo codice, e fondamentalmente corrisponde molto a quanto scritto da me utilizzando le Windows API.
Credo a questo punto che il problema sia più orientato allo stabilire la connessione in modo corretto.

Di fatto io utilizzo il seguente codice

send(ConnectSocket,ricevuto,strlen(ricevuto),0);
cout << "connessione in corso...\n";
listen(ListenSocket, SOMAXCONN);
TransferSocket = accept(ListenSocket, NULL, NULL);
cout << "connesso...\n";
iResult =recv(TransferSocket, recvbuf,DEFAULT_BUFLEN,0);

e riesco a fare connettere il client con il server sul canale dati.
Ricevo tuttavia il seguente messaggio di errore

425 cannot open data connection

Probabilmente è un errore di protocollo, forse non invio tutti i dati necessari al server..

[Stobby]

Fatto,
sono riuscito a risolvere il problema!

Chiamavo in modo non corretto la funzione getaddrinfo(). A causa di un funesto copia - incolla (dannosissimo!) invocavo la funzione passando i parametri come client invece che come server... [getaddrinfo(ADDR, PORT, &hints, &results) invece che getaddrinfo(NULL,PORT, &hints, &result)]....una svista parecchio dolorosa (in termini di ore di sonno perdute...)


Grazie ancora per l'aiuto!

Ciao

[Ikon O'Cluster]

Mai copia-incollare quando si programma! E' una pratica altamente bug-prone!