Connexion à une machine virtuelle locale

Question

Je soupçonne que cela a une solution facile que je néglige, probablement à faire avec le client ou comment cela est mis en place.
De toute façon, j'essaye de mettre en place un serveur/client Echo simple pour comprendre les bases de la programmation de douille. J'ai une machine virtuelle exécutant Linux Mint, et l'hôte exécute Windows 10. La machine virtuelle que je suis en train de configurer pour exécuter le code c du serveur, et Windows exécutera le client.

J'ai commencé rendre le code du serveur

//Echo Server for UNIX: Using socket programming in C, a client sends a string 
//to this server, and the server responds with the same string sent back to the client 

#include <stdio.h> 
#include <sys/socket.h> 
#include <sys/types.h> 
#include <netinet/in.h> 
#include <arpa/inet.h> 
#include <unistd.h> 
#include <string.h> 

int main() 
{ 
    char stringBuffer[50]; //string buffer for reading incoming and resending 
    int listener, communicator, c; //store values returned by socket system call 

    if((listener = socket(AF_INET, SOCK_STREAM, 0)) == -1) //creates a new socket 
     puts("Could not create socket"); 
    puts("Socket Created"); 

    struct sockaddr_in servAddr, client; //structure from <netinet/in.h> for address of server 
    servAddr.sin_family = AF_INET; //addressing scheme set to IP 
    servAddr.sin_port = htons(8888); //server listens to port 5000 
    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); //symbolic constant of server IP address 

    //binds the socket to the address of the current host and port# the server will run on 
    if (bind(listener, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0){ 
     puts("Bind failed"); 
     return 1; 
    } 
    puts("Bind Successful"); 

    listen(listener, 5); //listens for up to 5 connections at a time 
    c = sizeof(struct sockaddr_in); 
    if ((communicator = accept(listener, (struct sockaddr*)&client, (socklen_t*)&c))<0) 
     puts("accept failed"); 
    puts("Connection Accepted"); 
    //wait until someone wants to connect, then whatever is sent can be read from communicator, which can then be sent back 

    while(1){ 
     bzero(stringBuffer, 50); //sets buffer to 0 
     read(communicator, stringBuffer, 50); //reads from communicator into buffer 
     write(communicator, stringBuffer, strlen(stringBuffer)+1); //returns back 
    } 
    return 0; 
} 

après que je l'ai testé en ouvrant un autre terminal dans la machine hôte et dactylographié « telnet localhost 8888 » et entrez ce que les chaînes que je voulais.

Ce test a travaillé maintenant, sur ma machine Windows pour créer le côté client de la programmation socket:

#include <winsock.h> 
#include <stdio.h> 
#include <string.h> 
#pragma comment(lib,"ws2_32.lib") //Winsock Library 

int main(int argc, char *argv[]) 
{ 

    WSADATA wsadata; //variable for using sockets in windows 
    SOCKET sock; //socket variable for network commands 
    char sendString[50], recieveString[50]; //variables for sending and recieving messages to/from server 

    //check if WSA initialises correctly 
    if (WSAStartup(MAKEWORD(2,2), &wsadata) != 0) 
     printf("Error Code: %d", WSAGetLastError()); 

    //creates new socket and saves into sock 
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) 
     printf("Could not create socket: %d", WSAGetLastError()); 
    printf("Socket created\n"); 

    struct sockaddr_in servAddr; 
    servAddr.sin_addr.s_addr = inet_addr("127.0.0.1"); //sets the IP address to the same machine as the server 
    servAddr.sin_family = AF_INET; //addressing scheme set to TCP/IP 
    servAddr.sin_port = htons(8888); //server address is on port 8888 

    //connects to device with specifications from servAddr 
    if (connect(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) { 
     printf("Connection Error %d\n", WSAGetLastError()); 
     return 1; 
    } 
    printf("Connection Accepted\n"); 

    while(1){ 
     fgets(sendString, 50, stdin); //uses stdin to get input to put into sendString 
     //sends sendString to server using sock's properties 
     if (send(sock, sendString, strlen(sendString) + 1, 0) < 0); { 
      printf("Send Failed"); 
      return 0; 
     } 

     //reads from server into recieveString 
     if ((recv(sock, recieveString, 50, 0)) == SOCKET_ERROR) 
      printf("Recieve Failed"); 
     printf("%s", recieveString); //prints out recieveString 
    } 
} 

Maintenant, avec le serveur toujours en cours d'exécution, lorsque je tente le côté client, je reçois la réponse "Erreur de connexion" (de la ligne 35). Après avoir regardé les exemples Unix et WinSock, je ne suis pas sûr de savoir pourquoi j'échouerais la connexion. Je soupçonne qu'il pourrait avoir quelque chose à voir avec une machine virtuelle Windows à Linux, mais je ne suis pas sûr.

--- UPDATE --- Après avoir mis à jour le point-virgule accidentel et ajouté WSAGetLastError, il affiche un code d'erreur de 10061; Cela se traduit par "Connexion refusée Aucune connexion n'a pu être établie car l'ordinateur cible l'a refusé activement, ce qui résulte généralement de la tentative de connexion à un service inactif sur l'hôte étranger, c'est-à-dire un serveur sans application serveur. "

Answer 1

[après la 3ème édition:]

Sry, juste relire votre question. L'élément important est ici:

La machine virtuelle que je configure pour exécuter le code c du serveur et Windows exécute le client.

127.0.0.1 est une adresse toujours uniquement locale à une boîte IP activée. Donc vous votre serveur écoute sur l'interface 127.0.0.1 locale à la VM Linux et le client essaye de se connecter à 127.0.0.0 local à la boîte de Windows. Ces deux interfaces sont et non. Le résultat est évident, à savoir que le client ne trouve rien à quoi se connecter.

127.0.0.1 (le soi-disant "IPv4 loopback interfac e") ne peut être utilisé pour les connexions locale exactement une boîte.

Answer 2

if (connect(sock, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0); { 
    printf("Connection Error"); 
    return 1; 
} 

Ceci est juste une erreur de syntaxe triviale. Vous entrez dans le bloc sans condition. Supprimez le premier point-virgule.

Cependant, il y a un point beaucoup plus important à faire. Lorsque vous obtenez une erreur d'un appel système tel que connect(), vous devez imprimer l'erreur. Pas seulement un message de votre propre conception. Sinon, vous ne savez pas si vous avez simplement un bug, ou un problème temporaire, ou un problème de longue durée, ou un problème permanent.

Modifier le printf() à:

printf("Connect error %s\n", WSAGetLastError()); 

puis ne le font pas comme si continuer l'erreur n'a pas eu lieu.

Notez que cela s'applique à tous les appels système, y compris spécifiquement socket(), bind(), listen(), connect(), accept(), recv(), send() et amis.