连接被拒绝实施TCP服务器

Question

I'm trying to make a server and client. But when I try to connect the client to the server, I get connection refused. The other answers on stack overflow said to make sure you have listen() and accept(), which I do, and to check the firewalls. So I turned off all the firewalls just to make sure.

I still get connection refused, so I tried ./telnet 10.1.10.13 9696 , and got:

Trying 10.1.10.13... telnet: connect to address 10.1.10.13: Connection refused telnet: Unable to connect to remote host

Here's the code for the server

int setUpServer(struct fuzzerObj *ptr)
{
    /* Declarations */
    int hostSocket, yes = 1, rtrn;

    union
    {
        struct sockaddr_in in;

    }address;

   /* Create Socket */
   hostSocket = socket(AF_INET, SOCK_STREAM, 0);
   if(hostSocket < 0)
   {
       errorHandler("Could not create socket\n", FUNCTION_ID_SET_UP_SERVER);
       return -1;
   }

   /* Reuse Address */
   rtrn = setsockopt(hostSocket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
   if(rtrn < 0)
   {
        errorHandler("Couldn't Reuse Address\n", FUNCTION_ID_SET_UP_SERVER);
        return -1;
   }

   errno = 0;

   /* Set Up Struct */
   address.in.sin_len = sizeof(address.in);
   address.in.sin_family = AF_INET;
   address.in.sin_port = BBPORT_NUMBER;
   address.in.sin_addr.s_addr = htonl(INADDR_ANY);
   memset(address.in.sin_zero, 0, sizeof(address.in.sin_zero));

   /* Bind Address to Socket */
   rtrn = bind(hostSocket, (struct sockaddr*) &address, address.in.sin_len);
   if(rtrn < 0)
   {
       errorHandler("Can't Bind Address to Socket\n", FUNCTION_ID_SET_UP_SERVER);
       perror("");
       return -1;
   }

   /* listen */
   rtrn = listen(hostSocket, ptr->numberOfClients);
   if(rtrn < 0)
    {
        errorHandler("Can't Listen\n", FUNCTION_ID_SET_UP_SERVER);
        return -1;
    }

   while(1) acceptClient(hostSocket);

   return 0;
}

int acceptClient(int fd)
{
    struct sockaddr_storage addr;
    socklen_t addr_len = sizeof(addr);

    int clientFd = accept(fd, (struct sockaddr *) &addr, &addr_len);
    if(clientFd < 0)
    {
        printf("Can't Accept Client\n");
        return -1;
    }

    return clientFd;
}

and the code for the client:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdbool.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>

#define BLACKBOX_PORT 9696

int main(int argc, char *argv[])
{
    /* Check To See If an argument was passed */
    if(argc < 2)
    {
         printf("No enough Arguments\n");
         return -1;
    }

     /* Declaration's */
     const char *ip = argv[1];
     int sockfd, fd, rtrn;
     char *inBuf;
     struct sockaddr_in servaddr,cliaddr;
     socklen_t len = sizeof(cliaddr);

     /* Get Socket to Connect to Fuzz Server */
     sockfd = socket(PF_INET, SOCK_STREAM, 0);
     if(sockfd < 0)
     {
         perror("Can't Create Socket");
         return -1;
     }

     /* Fill Out Struct */
     servaddr.sin_family = AF_INET;
     servaddr.sin_port = htons(BLACKBOX_PORT);
     inet_pton(AF_INET, ip, &servaddr.sin_addr);

     /* Attempt Connection */
     fd = connect(sockfd,(struct sockaddr *)&servaddr, sizeof(servaddr));
     if(fd < 0)
     {
        perror("Can not connect to BlackBox Fuzz server");
        return -1;
     }

    /* Allocate Space in Memory for Incoming Connection */
    inBuf = (char *) malloc(1025);
    if(inBuf == NULL)
    {
        perror("Mem Error");
        return -1;
    }

    /* Read From Socket */
    rtrn = read(fd, inBuf, 1024);
    if(rtrn < 0)
    {
        perror("Can't Read Data From BlackBox Server");
        return -1;
    }
    printf("Received Data: %s\n", inBuf);    
    free(inBuf);
    return 0;
}

Output from client:

./client 10.1.10.13 Can not connect to BlackBox Fuzz server Connection refused

Any help would be appreciated, thanks.

Answer 1

Assuming that you're running this code on a little-endian machine, you need to use htons() when assigning the port number on the server side too.

(On big-endian machines htons() is a "no-op", but you should always use it to ensure portability)