C linux套接字：服务器在客户端之前退出

我有这个程序，只是一个简单的服务器和客户端连接的框架。我会让它成为一个聊天室。 （不要介意线程功能和信号…）

服务器：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>


#define BUFFERSIZE 512
#define TIMESIZE 32
#define QUIT "!quit"


// thread pou diavazei
void *readthread(void *argp);
// katharizei ligo prin kleisei to programma
void progreset();
// kleinei to prog me ctrl-c
void sigexit();


int sock, endchat;
char username1[50];
pthread_t thrread;


int main(int argc, char** argv) {
    int port, s;
    char username[50];
    struct sockaddr_in server, client;
    struct sockaddr *serverptr, *clientptr;
    unsigned int clientlen;
    char buf[BUFFERSIZE];
    int len;
    time_t sec;
    char timestr[TIMESIZE];


    signal(SIGPIPE, SIG_IGN);
    signal(SIGINT, sigexit);


    if (argc != 3) {
        printf("Error: Wrong arguments\n");
        printf("Usage: %s <username> <port>\n", argv[0]);
        return -1;
    }

    strcpy(username, argv[1]);
    port = atoi(argv[2]);

    // ftiaxno to socket
    if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Failed to create socket");
        return -1;
    }
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = htonl(INADDR_ANY);
    server.sin_port = htons((short)port);
    if (bind(s, (struct sockaddr *)&server, sizeof(server)) < 0) {
        perror("Failed to bind socket");
        return -1;
    }

    if (listen(s, 5) != 0) {
        perror("Error in listen()");
        return -1;
    }

    clientptr = (struct sockaddr *)&client;
    clientlen = sizeof(client);

    // perimeno sindesi apo ton pelati
    printf("Accepting connections on port %d..\n", port);
    if ((sock = accept(s, clientptr, &clientlen)) < 0) {
        perror("Error in accept()");
        return -1;
    }

    // pairno to ip tou pelati
    if (getpeername(sock, (struct sockaddr *)&client, &clientlen) < 0) {
        printf("Accepted connection\n");
    } else {
        printf("Accepted connection from %s\n", inet_ntoa(client.sin_addr));
    }

    // stelno kai pairno ta usernames
    bzero(buf, sizeof(buf));
    strcpy(buf, username);
    if (write(sock, buf, sizeof(buf)) < 0) {
        perror("write1");
        return -1;
    }

    bzero(buf, sizeof(buf));
    if (read(sock, buf, sizeof(buf)) < 0) {
        perror("read1");
        return -1;
    }
    strcpy(username1, buf);

    printf("Chatting with %s..\n\n", username1);








    progreset();
    return 0;
}


void *readthread(void *argp) {
    char buf[BUFFERSIZE];
    char timestr[TIMESIZE];
    int len;
    time_t sec;
    struct tm *timeinfo;


    while (1) {

    }



    endchat = 1;
    pthread_exit(0);
}


void progreset() {
    printf("\nExiting..\n");
    close(sock);
}


void sigexit() {
    printf("test\n");
    close(sock);
    signal(SIGINT, SIG_DFL);
    kill(getpid(),SIGINT);
    printf("ok\n");

    exit(0);
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义缓冲区大小512
#定义时间大小32
#定义退出“！退出”
//迪瓦泽伊酒店
void*readthread（void*argp）；
//Katharisei ligo prin kleisei至项目经理
void progrest（）；
//kleinei至程序控制-c
void sigexit（）；
int sock，endchat；
char username1[50]；
pthread_t thrread；
int main（int argc，字符**argv）{
国际港口，s；
字符用户名[50]；
服务器、客户端中的结构sockaddr_；
结构sockaddr*serverptr，*clientptr；
无符号整数clientlen；
charbuf[BUFFERSIZE]；
内伦；
时间秒；
char timestr[TIMESIZE]；
信号（信号管、信号灯）；
信号（SIGINT、SIGEXT）；
如果（argc！=3）{
printf（“错误：错误参数\n”）；
printf（“用法：%s\n”，argv[0]）；
返回-1；
}
strcpy（用户名，argv[1]）；
端口=atoi（argv[2]）；
//ftiaxno至插座
if（（s=socket（AF\u INET，SOCK\u STREAM，0））<0）{
perror（“未能创建套接字”）；
返回-1；
}
server.sinu family=AF\u INET；
server.sin_addr.s_addr=htonl（INADDR_ANY）；
server.sin_port=htons（（短）端口）；
if（绑定（结构sockaddr*）&服务器，大小（服务器））<0{
perror（“绑定套接字失败”）；
返回-1；
}
如果（听（s，5）！=0）{
perror（“listen（）中的错误”）；
返回-1；
}
clientptr=（struct sockaddr*）&client；
clientlen=sizeof（客户）；
//佩里门诺·辛德西
printf（“在端口%d上接受连接…\n”，端口）；
如果（（sock=accept（s、clientptr和clientlen））<0{
perror（“accept（）中的错误”）；
返回-1；
}
//佩尔诺至伊普图佩拉蒂
if（getpeername（sock，（struct sockaddr*）和clientlen）<0{
printf（“已接受的连接”）；
}否则{
printf（“已接受来自%s\n的连接”，inet_ntoa（client.sin_addr））；
}
//stelno kai pairno ta用户名
bzero（buf，sizeof（buf））；
strcpy（buf，用户名）；
if（写入（sock、buf、sizeof（buf））<0）{
perror（“书面文件1”）；
返回-1；
}
bzero（buf，sizeof（buf））；
如果（读取（sock、buf、sizeof（buf））<0）{
perror（“read1”）；
返回-1；
}
strcpy（username1，buf）；
printf（“与%s聊天…\n\n”，用户名1）；
progrest（）；
返回0；
}
void*readthread（void*argp）{
charbuf[BUFFERSIZE]；
char timestr[TIMESIZE]；
内伦；
时间秒；
结构tm*时间信息；
而(1){
}
endchat=1；
pthread_退出（0）；
}
void progrest（）{
printf（“\nxiting..\n”）；
关闭（袜子）；
}
void sigexit（）{
printf（“测试”）；
关闭（袜子）；
信号（SIGINT、SIG_DFL）；
kill（getpid（），SIGINT）；
printf（“ok\n”）；
出口（0）；
}

客户

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


#define BUFFERSIZE 512
#define TIMESIZE 32
#define QUIT "!quit"


// thread pou diavazei
void *readthread(void *argp);
// katharizei ligo prin kleisei to programma
void progreset();
// kleinei to prog me ctrl-c
void sigexit();


int sock, endchat;
char username1[50];
pthread_t thrread;


int main(int argc, char** argv) {
    int port;
    char username[50];
    struct sockaddr_in server, client;
    struct sockaddr *serverptr, *clientptr;
    unsigned int serverlen;
    struct hostent *rem;
    char buf[BUFFERSIZE];
    int len;
    time_t sec;
    char timestr[TIMESIZE];


    signal(SIGPIPE, SIG_IGN);
    signal(SIGINT, sigexit);


    if (argc != 4) {
        printf("Error: Wrong arguments\n");
        printf("Usage: %s <username> <ip address> <port>\n", argv[0]);
        return -1;
    }

    strcpy(username, argv[1]);
    port = atoi(argv[3]);

    // ftiaxno to socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Failed to create socket");
        return -1;
    }
    rem = gethostbyname(argv[2]);
    server.sin_family = AF_INET;
    bcopy((char*)rem->h_addr, (char*)&server.sin_addr, rem->h_length);
    server.sin_port = htons((short)port);
    serverptr = (struct sockaddr *)&server;
    serverlen = sizeof(server);

    // kano connect me to server
    if (connect(sock, serverptr, serverlen) < 0) {
        perror("Failed to connect");
        return -1;
    }

    // pairno kai stelno ta usernames
    bzero(buf, sizeof(buf));
    if (read(sock, buf, sizeof(buf)) < 0) {
        perror("read1");
        return -1;
    }
    strcpy(username1, buf);

    bzero(buf, sizeof(buf));
    strcpy(buf, username);
    if (write(sock, buf, sizeof(buf)) < 0) {
        perror("write1");
        return -1;
    }

    printf("Chatting with %s..\n\n", username1);







    sleep(1);










    progreset();
    return 0;
}


void *readthread(void *argp) {
    char buf[BUFFERSIZE];
    char timestr[TIMESIZE];
    int len;
    time_t sec;
    struct tm *timeinfo;

    while (1) {
    }
    endchat = 1;
    pthread_exit(0);
}


void progreset() {
    printf("\nExiting..\n");
    close(sock);
}


void sigexit() {
    printf("test\n");
    close(sock);
    signal(SIGINT, SIG_DFL);
    kill(getpid(),SIGINT);
    printf("ok\n");

    exit(0);
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#定义缓冲区大小512
#定义时间大小32
#定义退出“！退出”
//迪瓦泽伊酒店
void*readthread（void*argp）；
//Katharisei ligo prin kleisei至项目经理
void progrest（）；
//kleinei至程序控制-c
void sigexit（）；
int sock，endchat；
char username1[50]；
pthread_t thrread；
int main（int argc，字符**argv）{
国际港口；
字符用户名[50]；
服务器、客户端中的结构sockaddr_；
结构sockaddr*serverptr，*clientptr；
无符号整数服务器；
结构宿主*rem；
charbuf[BUFFERSIZE]；
内伦；
时间秒；
char timestr[TIMESIZE]；
信号（信号管、信号灯）；
信号（SIGINT、SIGEXT）；
如果（argc！=4）{
printf（“错误：错误参数\n”）；
printf（“用法：%s\n”，argv[0]）；
返回-1；
}
strcpy（用户名，argv[1]）；
端口=atoi（argv[3]）；
//ftiaxno至插座
if（（sock=socket（AF_INET，sock_STREAM，0））<0）{
perror（“未能创建套接字”）；
返回-1；
}
rem=gethostbyname（argv[2]）；
server.sinu family=AF\u INET；
b复制（（char*）rem->h_addr，（char*）和server.sin_addr，rem->h_length）；
server.sin_port=htons（（短）端口）；
serverptr=（结构sockaddr*）&server；
serverlen=sizeof（服务器）；
//kano将我连接到服务器
如果（连接（sock、serverptr、serverlen）<0）{
perror（“连接失败”）；
返回-1；
}
//pairno kai stelno ta用户名
bzero（buf，sizeof（buf））；
如果（读取（sock、buf、sizeof（buf））<0）{
perror（“read1”）；
返回-1；
}
strcpy（username1，buf）；
bzero（buf，sizeof（buf））；
strcpy（buf，用户名）；
if（写入（sock、buf、sizeof（buf））<0）{
perror（“书面文件1”）；
返回-1；
}
printf（“与%s聊天…\n\n”，用户名1）；
睡眠（1）；
progrest（）；
返回0；
}
void*readthread（void*argp）{
charbuf[BUFFERSIZE]；
char timestr[TIMESIZE]；
内伦；
时间秒；
结构tm*时间信息；
而(1){
}
endchat=1；
pthread_退出（0）；
}
void progrest（）{
printf（“\nxiting..\n”）；
关闭（袜子）；
}
void sigexit（）{
printf（“测试”）；
关闭（袜子）；
信号（SIGINT、SIG_DFL）；
kill（getpid（），SIGINT）；
printf（“ok\n”）；
出口（0）；
}

在main（）函数中，服务器只是等待连接，然后退出。 连接休眠1秒后，客户端将停止连接

当我运行这个时，比如./server 1234 然后./client localhost 1234 两者都正常退出，但当我第二次运行服务器时，它显示绑定套接字失败：地址已在使用

怎么了？ 服务器必须总是在客户端之后退出吗

额外问题：我希望每个程序有两个线程，一个读一个写。它们能在同一个插座上工作吗

---

非常感谢

请务必在

int sock, ret, on;
struct sockaddr_in servaddr;

/* Create a new stream (TCP) socket */
sock = socket( AF_INET, SOCK_STREAM, 0 ):

/* Enable address reuse */
on = 1;
ret = setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );

/* Allow connections to port 8080 from any available interface */
memset( &servaddr, 0, sizeof(servaddr) );
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl( INADDR_ANY );
servaddr.sin_port = htons( 45000 );

/* Bind to the address (interface/port) */
ret = bind( sock, (struct sockaddr *)&servaddr, sizeof(servaddr) );