VM到VM：插座连接（）返回-1

Question

因此，我正在研究远程LS分配，其中我们必须在两个远程计算机之间使用TCP套接字连接，并在另一侧运行client.c在另一侧和server.c。客户端程序输入命令；例如：ls 服务器将解析并将当前工作目录返回到客户端。

请注意，我在VM工作站上运行两个程序。一侧是Ubuntu，另一面是Red Hat 6。

问题：我的客户端程序无法连接到服务器，其Connect（）函数返回-1。

我已经尝试调试程序，因此我正在附加结果：调试结果

注释注：为了调试，具有硬编码的IP地址和端口NO。

这是代码：

客户端：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include<netdb.h>
#include <string.h>
#include<unistd.h>
 
 
 /*
 Client side socket flow
 socket()
    |
    |
    v
 connect() 
    |
    |
    v
  recv()    
 */
 
 int main(int argc, char *argv[]) {
     struct hostent *server;
         struct sockaddr_in server_address;
         int port_num;
         int communication_status;
     //create a socket
     int network_socket;

        //We will use 3 args while running client code.
        /*
        if (argc < 3)  {
      fprintf(stderr,"usage %s hostname port\n", argv[0]);
  
    }*/


     /*
     socket(arg1,arg2,arg3)
     - First arg: (AF_INET) = domain .. from IPV4 domain
     - Sec arg: SOCK_STREAM - TCP Stream/Connection-Oriented
     - Third arg: defines protocol - 0 for TCP <You can use RAW SOCKET HERE (SOCKETS WITH NO PROTOCOL)
     */
     network_socket = socket(AF_INET,SOCK_STREAM,0);
     
     /*
     - So we can pass port no as int
     - But data format is different from structure that we need to use a conversion function
     - conversion function thats going to put our integer
     port in right byte order is htons(agr = actual int port number we want to connect to)
     */
     //define port you need to conenct remotely
    port_num = 20102;
    server_address.sin_port = htons(port_num);
     //define server address
     /*
     -sin addr is field that contains structure itself
     - we can use any address -- use shortcut ip.0.0.0 (INADDR_ANY)
     *
       
/*
     -now we need to use connect() to connect to other socket
     - BUT FIRST WE NEED TO SPECIFY AN ADDRESS FOR SOCKET i.e. addr and port no
     */

     server_address.sin_family = AF_INET;
     server_address.sin_addr.s_addr = inet_addr("192.168.177.128");
     
     //now time to connect
     /*
       connect() 
       arg1: socket
       arg2: need to cast our server addfress structure to slightly different struct 
       from sockaddr_in to sockaddr*
       arg3: sizeof the address
       
      connect() returns integer
      0 - successful connection
      -1 - not successfull    
     */
     int connection_status;
     connection_status = connect(network_socket,(struct sockaddr *) &server_address,sizeof(server_address));
     //check for error with the connection
     if (connection_status == -1) {
        printf("There was an error making a connection to the remote socket \n\n");     
     }
     // recieve data from the server
     /*
     - recv() function 
     - first arg: socket 
     - 2nd arg: address of var where data recived will end up (here it is char array)
     - 3rd arg: optional flag parameter give 0
     */

     //string to hold data exchanged between client and server
     char buffer[256];   
     printf("Please enter the linux command: ");
     //clears the buffer content
     bzero(buffer,256); 
     //get linux command from the console
     fgets(buffer,255,stdin);

     communication_status = write(network_socket,buffer,strlen(buffer));
      //check for write status
      if (communication_status < 0) {
        perror("Error writing to socket!");
        exit(1);
      }
      //Now getting server response
      //clear the buffer
      bzero(buffer,256);
      communication_status = read(network_socket,buffer,255);

    if (communication_status < 0) {
      perror("Error reading from socket!");
      exit(1);
    }
    //now we have to print the server response
     printf("Server>>: %s\n", buffer);
     
     
     //close the socket
     close(network_socket);
        
     
     return 0;
         
 }

服务器端：

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netdb.h>
#include <stdlib.h>
#include <string.h>
#include<unistd.h>

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

//Checks if the num of argument is 2, if not error message is displayed.
    if(argc<2)  {
      fprintf(stderr,"Num of argument Error");
    }

 //buffer for data exchange
 char buffer[256];
 int clientlength, portnum, newSocket;
struct sockaddr_in server_address, cli_addr;
int communication_status,newsockfd;

//create server 
int server_socket;
server_socket = socket(AF_INET, SOCK_STREAM,0);
if(server_socket == -1) {
      perror("Could not connect to socket");
exit(1);
    }

//define the server address
bzero((char *) &server_address, sizeof(server_address));
//Coverts the character value to integer for the portno
portnum = atoi(argv[1]);
server_address.sin_family = AF_INET;
server_address.sin_port = htons(portnum);
server_address.sin_addr.s_addr = INADDR_ANY;

//bind the socket to our specified IP and port
//bind is used exactly like we call the connection() 
//OS gives resources like port number to Server through bind()

if ( bind(server_socket,(struct sockaddr*) &server_address,sizeof(server_address)) < 0 ) {
   perror("Can't bind");
   exit(1);
}
 
 /*
 listen() 
 first arg: socket
 second arg: backlog (how many connection can be waiting -
 essentially for this particular socket at a time - since
 we are using this for one client, we can use any number)
 */
 listen(server_socket,5);
 clientlength = sizeof(cli_addr);
 
 /*
 define integer to hold client's socket as once we able to listen() connection
 and we can actually start accepting() connections so we can read or write to 
 clients socket 
 */

//The new socket for the client informations
    /*
    if(newsockfd<1)
    {
      sleep(1);
    }
    */
    newSocket = accept(server_socket,(struct sockaddr *) &cli_addr, &clientlength);
 
 
 if (newSocket < 0) {
          perror("ERROR on accept");
          exit(1);
      }
    //Clears the buffer
    bzero(buffer,256); 

    communication_status = read(newSocket,buffer,255);

    if (communication_status < 0) {
        perror("ERROR reading from socket");
        exit(1);
    }

    //Buffer Stores the msg sent by the client
    printf("Here is the entered bash command: %s\n",buffer);

    communication_status = write(newSocket,"I got your message",18);

    if (communication_status < 0)
    {
        error("ERROR writing to socket");
    }

 char *prog;
    strcpy(prog, buffer);
    char *args[100];
    int child_pid;

    //Running the Bash Commands
    if(readAndParseCmdLine(&prog, args)) {
        child_pid =fork();

        if(child_pid == 0){ //child part
        printf("\n");
            execvp(prog, args);  // create and run the new process and close the child process
        printf("\n");
            prog = NULL;
            printf("Error in excuting the command- please make sure you type the right syntax.\n");
        } else{ //parent part
            wait(child_pid);
        }
      void main();
    }

 }
 
 //This function reads the linux command form the buffer and parse it
//
  int readAndParseCmdLine(char **prog, char **args){
  int i =0;
  char cmd[100]; //user command
    char * temp;
    temp = *prog;
         if(strcmp(temp,"exit")==0){return 0;} //end program if user type exit.

         char *tok;
        tok = strtok(temp," \n");

        while(tok != NULL){
            if(i==0){
                prog[0] = tok;
            }
            args[i] = tok;
        printf("\n");
            i=i+1;
            tok = strtok(NULL, " \n");
        }
    
        args[i]=NULL;
        return 1;
    }