VM to VM: Socket Connect() returning -1

Question

So, I am working on an remote ls assignment in which we have to use TCP socket connection between two remote computers and run client.c on one side and server.c on another. Client program enters command; for e.g: ls the server will parse it and returns the current working directory to client.

Note that I am running both programs on VM Workstation. One side is Ubuntu and another is Red Hat 6.

Issue: My client program couldn't connect to the server and its connect() function is returning -1.

I have tried to debug my program and so I am attaching the results:debug result

Note: I have hardcoded IP address and port no for the sake of debugging.

Here are the codes:

Client side:

#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;
         
 }

Server side:

#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;
    }