为什么在服务器和客户端的sin_port中指定相同的端口？

Question

I am learning Socket-programming in C++. I understand that the socket must bind to the server address and in the client side, there is an internal bind() when connect() is called. The server listens on the port specified in sin_port of the struct sockaddr_in .

But when I specify the same port to sin_port of the struct sockaddr_in in client, does that mean that both client and server are bound on the same port. I hope this is the part, I am going wrong.

Here are the codes :

SERVER :

#include<iostream>
#include<sys/socket.h>
#include<sys/types.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netdb.h>
using namespace std;
int main(){

    int sockid=socket(AF_INET,SOCK_STREAM,0);
    if(sockid<0){
        cout<<"failed socket";
    }
    struct sockaddr_in server, client;
    int cz=sizeof(client);
    server.sin_family=AF_INET;
    server.sin_port=htons(9999);
    server.sin_addr.s_addr=htonl(INADDR_ANY);

    if(bind(sockid,(struct sockaddr*)&server, sizeof(server))<0){
        cout<<"Failed binding";
        return 0;
    }
    cout<<"binded\n";

    if(listen(sockid,3)<0){//
        cout<<"\nFailed Listening";
        return 0;
    }

    int client_socket=accept(sockid,(struct sockaddr*)&client, (socklen_t*)&cz);

    if(client_socket<0){
        cout<<"Failed connecting";
        return 0;
    }
    cout<<"Connected....\n";

    char buff[1024]={0};

    cout<<"enter message: ";
    cin>>buff;
    if(send(client_socket,buff,strlen(buff),0)<0){
        cout<<"\nFailed sending\n";
        return 0;
    }
    cout<<"Message sent";




    return 0;
}

CLIENT

#include<arpa/inet.h>
#include<netdb.h>
#include<iostream>
#include<sys/socket.h>
#include<sys/types.h>
#include<unistd.h>
#include<netinet/in.h>
using namespace std;
int main(){

    int sockid=socket(AF_INET,SOCK_STREAM,0);
    if(sockid<0){
        cout<<"failed socket";
    }
    struct sockaddr_in  client;

    int cz=sizeof(client);
    client.sin_family=AF_INET;
    client.sin_port=htons(9999);
    client.sin_addr.s_addr=INADDR_ANY;




    int server_socket=connect(sockid,(struct sockaddr*)&client, sizeof(client));

    if(server_socket<0){
        cout<<"Failed connecting";
        return 0;
    }
    cout<<"Connected\n";

    char buff[250];//

    recv(sockid,buff,1024,0);
    cout<<"Received msg: "<<buff;

    return 0;
}

Answer 1

The server should bind to the same port the client connect s to. That way, the server and client will be talking to each other. Typically, the server bind s to a well-known port and listen s. The client doesn't call bind , which results in it binding to a random port. But it does call connect to connect to the server's well-known port. The server listens on, sends from, and receives on the well-known port. The client connects to, sends to, and receives from the well-known port.

Also, don't actually ever do this:

recv(sockid,buff,1024,0);
cout<<"Received msg: "<<buff;

TCP is not a message-based protocol. The recv function, when called on a TCP socket, does not receive a message nor even know what a message is. When you call a stream's operator<< and pass it a char * , like you are, it expects that char * to point to a valid C-style string, which is not assured in this code. Worse, you've ignored the return value from recv which is the only way to know how many bytes you received.

There's a similar issue here:

if(send(client_socket,buff,strlen(buff),0)<0){

You don't send the terminating zero byte, so there is no way for the receiver to figure out where the message ends other than by the fact that you then close the connection. This works only in the exact case where you want to send precisely one message and then close the connection without any possibility of a response. And, in this case, the receiver needs to keep calling recv until it gets an indication that the connection has been closed before it considers itself to have received a message.