Fatal编程技术网
  • cplusplus/
  • C++ 客户端未通过套接字接收回数据[传输端点已连接]

C++ 客户端未通过套接字接收回数据[传输端点已连接]

c++ c sockets network-programming

C++ 客户端未通过套接字接收回数据[传输端点已连接],c++,c,sockets,network-programming,port,C++,C,Sockets,Network Programming,Port,我有两个程序Node-A和Node-B，其中Node-A向Node-B发送一些char*数据，Node-B向Node-A发送一个ack（char*数据）。也就是说，clientNodeA_线程向Node-B的serverNodeB_线程发送数据。代码如下： 诺迪亚 节点 我能够将数据从Node-A客户端发送到Node-B服务器，Node-B也能够发送Ack数据（如Wireshark中所验证的），但它没有到达Node-A接收代码 这方面的任何帮助都会非常有用。问题是，您将客户端套接字绑定到本地地址

我有两个程序Node-A和Node-B，其中Node-A向Node-B发送一些char*数据，Node-B向Node-A发送一个ack（char*数据）。也就是说，clientNodeA_线程向Node-B的serverNodeB_线程发送数据。代码如下：

诺迪亚

节点

我能够将数据从Node-A客户端发送到Node-B服务器，Node-B也能够发送Ack数据（如Wireshark中所验证的），但它没有到达Node-A接收代码

这方面的任何帮助都会非常有用。

问题是，您将客户端套接字绑定到本地地址，但没有绑定被动服务器套接字

不要绑定客户端套接字，通常不需要这样做。不过，您确实需要在本地绑定服务器套接字，否则当您调用
listen

时，系统只会将其绑定到随机端口，问题已解决！我只是将NodeA的socket创建和绑定部分移动到main函数中，以便客户端和服务器线程共享它，而客户端和服务器线程只执行发送和接收功能

谢谢@Joachim Pileborg

你不需要那么大的
usleep
在创建线程之后，
pthread\u join
会一直阻塞，直到它所连接的线程退出。顺便说一下，在
clientNodeA\u thread
函数中，你可以将一个包含11个字符的字符串（加上终止符）复制到
缓冲区中，然后在第13位添加终止符，请记住，索引是基于零的。这并不重要，因为您从源字符串中复制了足够多的内容，
strncpy
将添加终止符。我正在绑定clientA套接字，因为我想在Node-B服务器上解码它们。。。我正在使用环回地址和特定端口号绑定客户端a.Idk，请您详细说明一下您认为这里的问题是什么？非常感谢..你提到我没有在Node-a的服务器线程上使用bind吗？我不是很确定，但是我们必须使用bind两次吗？因为我只用一个端口号来监听？如果我这样做，我不会无法绑定错误吗？@user5105767但您将客户端套接字绑定到本地地址，这是不需要的，因为当您连接时，它将获得本地绑定地址。服务器套接字需要绑定到固定的本地地址，否则客户端将不知道要连接到哪个地址。我建议您阅读，它告诉您需要为服务器套接字执行什么操作。@user5105767在
serverNodeA\u线程中的
bind
是否使用
listenSock
？谢谢您的评论。我已经用bind和listenSock修改了serverNodeA线程。看起来Node-A服务器仍然无法检测任何传入的数据包。我已经用我现在使用的代码更新了原来的帖子。我还删除了clientNodeAthread中的bind和listenSock。。你现在能看出什么不对劲吗？我是新的插座，嘿，谢谢你的链接！

int main()
    {
      pthread_t clientNodeA, serverNodeA;

      usleep(3000000);
      pthread_create(&clientNodeA, NULL, clientNodeA_thread, "clientNodeA");
      pthread_create(&serverNodeA, NULL, serverNodeA_thread, "serverNodeA");
      usleep(100000000);

      pthread_join(clientNodeA, NULL);
      pthread_join(serverNodeA, NULL);
      return 0;
    }

    void* clientNodeA_thread(void* pString)
    {
        int connSock, in, i, ret, flags;
        struct sockaddr_in servaddr, NodeAaddr;
        struct sctp_status status;
        char buffer[MAX_BUFFER+1];
        /* Sample input*/
         strncpy(buffer, "FrmNodeAClt", 12);
         buffer[12]='\0';

         connSock = socket( AF_INET, SOCK_STREAM, IPPROTO_SCTP );

         if(connSock == -1)
           die("socket()");
         #if 0
         bzero( (void *)&NodeAaddr, sizeof(NodeAaddr) );
         NodeAaddr.sin_family = AF_INET;
         NodeAaddr.sin_port = htons(MY_PORT_NUM_NodeA2);
         NodeAaddr.sin_addr.s_addr = inet_addr( "127.0.0.1" );
         #endif

         bzero( (void *)&servaddr, sizeof(servaddr) );
         servaddr.sin_family = AF_INET;
         servaddr.sin_port = htons(MY_PORT_NUM_NodeB);
         servaddr.sin_addr.s_addr = inet_addr( "127.0.0.1" );



    ret = connect( connSock, (struct sockaddr *)&servaddr, sizeof(servaddr) );

         if(ret == -1)
            die("connect()");

           ret = sctp_sendmsg( connSock, (void *)buffer, (size_t)strlen(buffer),
                              NULL, 0, 0, 0, 0, 0, 0 );
        return 0;
    }

    void* serverNodeA_thread(void* pString)
    {
      int listenSock, connSock, ret, in , flags, i;
      struct sockaddr_in servaddr;
      struct sockaddr_in src_addr;
      struct sctp_initmsg initmsg;
      int addr_len = 0;

      listenSock = socket( AF_INET, SOCK_STREAM, IPPROTO_SCTP );
      bzero( (void *)&servaddr, sizeof(servaddr) );
      servaddr.sin_family = AF_INET;
      servaddr.sin_addr.s_addr = inet_addr( "127.0.0.1" );
      servaddr.sin_port = htons(MY_PORT_NUM_ENB2);

  ret = bind( listenSock, (struct sockaddr *)&servaddr, sizeof(servaddr) );

      /* Specify that a maximum of 5 streams will be available per socket */
      memset( &initmsg, 0, sizeof(initmsg) );
      initmsg.sinit_num_ostreams = 5;
      initmsg.sinit_max_instreams = 5;
      initmsg.sinit_max_attempts = 4;
      ret = setsockopt( listenSock, IPPROTO_SCTP, SCTP_INITMSG, 
                         &initmsg, sizeof(initmsg) );

      listen( listenSock, 5 );

      while( 1 ) {

      char buffer[MAX_BUFFER + 1];
      int len ;  

      bzero(buffer, MAX_BUFFER + 1);

      printf("Awaiting a new connection\n");

      connSock = accept( listenSock, (struct sockaddr *)NULL, (int *)NULL );
      if(connSock == -1)
          die("accept()");
        else
          printf("New client connected....\n");
          addr_len = sizeof (src_addr);
          recvfrom(connSock, buffer, sizeof(buffer), 0, &src_addr, &addr_len);
          printf("Received data from NodeB : %s\n", (char*)buffer);
      }
    }



int connSock;

/*NodeA context maintenance */
struct NodeAStruct {
  char ipAddr[20];
  unsigned int portNum;
};

static int NodeAInstCount;
struct NodeAStruct NodeAInst[7];

int main()
{

  pthread_t clientNodeA, serverNodeA;

  pthread_create(&serverNodeA, NULL, serverNodeB_thread, "serverNodeA");
  usleep(10000000);

  pthread_join(clientNodeA, NULL);
  pthread_join(serverNodeA, NULL);

  return 0;
}

void* serverNodeB_thread(void* pString)
{
  int listenSock, ret, flags, i;
  struct sockaddr_in src_addr;
  struct sockaddr_in servaddr;
  struct sctp_initmsg initmsg;
  struct sctp_event_subscribe events;
  struct sctp_sndrcvinfo sndrcvinfo;
  char sendBuffer[MAX_BUFFER+1];
  unsigned int NodeA_PORT_NUM;
  char* NodeA_IP_ADDR;  
  char  from_ip[1024] = "", myip[2014] = "";
  int addr_len = 0;

  listenSock = socket( AF_INET, SOCK_STREAM, IPPROTO_SCTP ); 
  bzero( (void *)&servaddr, sizeof(servaddr) );
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl( INADDR_ANY );
  //servaddr.sin_addr.s_addr = htonl("127.0.0.1");
  servaddr.sin_port = htons(MY_PORT_NUM_NodeB);

  ret = bind( listenSock, (struct sockaddr *)&servaddr, sizeof(servaddr) );

  /* Specify that a maximum of 5 streams will be available per socket */
  memset( &initmsg, 0, sizeof(initmsg) );
  initmsg.sinit_num_ostreams = 5;
  initmsg.sinit_max_instreams = 5;
  initmsg.sinit_max_attempts = 4;
  ret = setsockopt( listenSock, IPPROTO_SCTP, SCTP_INITMSG, 
                     &initmsg, sizeof(initmsg) );

  listen( listenSock, 5 );

  while( 1 ) {

  char buffer[MAX_BUFFER + 1];
  int len ;  

  bzero(buffer, MAX_BUFFER + 1);
  printf("Awaiting a new connection\n");

  connSock = accept( listenSock, (struct sockaddr *)NULL, (int *)NULL );
  if(connSock == -1)
      die("accept()");
    else
    {
      printf("New client connected....\n");     
      addr_len = sizeof (src_addr);
      recvfrom(connSock, buffer, sizeof(buffer), 0, &src_addr, &addr_len);

      printf("Received message: %s from NodeA IP: %s Port: %u  \n", (char*)buffer, inet_ntop(AF_INET, &src_addr.sin_addr, from_ip, sizeof(from_ip)), ntohs(src_addr.sin_port));
      strcpy(NodeAInst[NodeAInstCount].ipAddr, inet_ntop(AF_INET, &src_addr.sin_addr, from_ip, sizeof(from_ip)));
      NodeAInst[NodeAInstCount].portNum = ntohs(src_addr.sin_port);
      printf("NodeA instance [%d] added \n", NodeAInstCount);

     /* Send data to NodeA*/
     strncpy(sendBuffer, "From NodeB", 12);
     sendBuffer[12]='\0';
     NodeA_PORT_NUM = NodeAInst[NodeAInstCount].portNum;
     usleep(10000000);
     ret = sctp_sendmsg( connSock, (void *)sendBuffer, (size_t)strlen(sendBuffer),
                          NULL, 0, 0, 0, 0, 0, 0 );
     if(ret>0) {
        printf("Data sent to NodeA \n");
     }
     else {
        printf("Sending data to NodeA failed");
     }
     usleep(6000000);
     NodeAInstCount++;

    }
  }
}