C

Question

尝试在服务器端使用多线程实现客户端-服务器程序时遇到一个小问题。我的想法是让服务器永远旋转，在可能的情况下接受客户端，然后使用线程将其发送到client_handle（）函数。

这是问题所在：我的服务器和客户端正在使用下面显示的代码。在服务器的初始响应时，它无法发送ALL_GOOD_CD。我不确定为什么会这样，因为我之前在一行中打印了客户端的套接字fd，它似乎与接受时给我们的文件描述符匹配。

一个想法是我的套接字ID没有正确地传递给线程。我的客户端似乎从未收到ALL_GOOD_CD（与服务器连接后，它在recv()调用中被阻止）。我是线程和套接字的新手，任何事情都会有所帮助；谢谢！

这是运行所需的客户端代码：

#include <stdio.h>      /* for printf() and fprintf() */
#include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
#include <arpa/inet.h>  /* for sockaddr_in and inet_addr() */
#include <stdlib.h>     /* for atoi() and exit() */
#include <string.h>     /* for memset() */
#include <unistd.h>     /* for close() */

void DieWithError(char *errorMessage);  /* Error handling function */
int main(int argc, char *argv[])
{
    int sock;                           /* Socket descriptor */
    struct sockaddr_in server_addr;     /* Server address */
    unsigned short server_port;         /* Server port */
    char *server_ip;                    /* Server IP address (dotted quad) */
    char server_response[300];   /* Buffer to hold response from the server */
    char* username;

    /* Test for correct number of arguments */
    if (argc != 4) {
        fprintf(stderr, "Usage: %s <server_ip> <server_port> <username>\n", argv[0]);
        exit(1);
    }

    server_ip = argv[1];            /* Second arg: server IP address (dotted quad) */
    server_port = atoi(argv[2]);    /* Third arg: server port number */
    username = argv[3];             /* Fourth arg: username */

    /* Create a reliable, stream socket using TCP */
    if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        DieWithError("socket() failed");

    /* Construct the server address structure */
    memset(&server_addr, 0, sizeof(server_addr));       /* Zero out structure */
    server_addr.sin_family      = AF_INET;              /* Internet address family */
    server_addr.sin_addr.s_addr = inet_addr(server_ip); /* Server IP address */
    server_addr.sin_port        = htons(server_port);   /* Server port */

    /* Establish the connection to the server */
    if (connect(sock, (struct sockaddr*) &server_addr, sizeof(server_addr)) < 0)
        DieWithError("connect() failed, could not find server.");

    printf("connected\n");

    memset(&server_response, 0, 300);
    if (recv(sock, server_response, 300, 0) < 0)
        DieWithError("recv() for initial response failed");

    printf("received initial reponse\n");
}

void DieWithError(char* errorMessage) {
    fprintf(stderr, "Dying with error sadface: %s\n", errorMessage);
    exit(1);
}

以下是尽可能缩小的服务器代码：

#include <stdio.h>      /* for printf() and fprintf() */
#include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
#include <arpa/inet.h>  /* for sockaddr_in and inet_addr() */
#include <stdlib.h>     /* for atoi() and exit() */
#include <string.h>     /* for memset() */
#include <unistd.h>     /* for close() */
#include <pthread.h>    /* multithreading the clients! */

#define MAXMSGSIZE 150
#define MAXCLIENTS 5
#define TOO_MANY_CD 0
#define ALL_GOOD_CD 1
#define OTHER_BAD_CD 2

struct client {
    char* username;
    char** subs;
    int socket;
    char temp_msg[MAXMSGSIZE*2];
};

void DieWithError(char* errorMessage);  /* Error handling function */
void handle_client(void* new_socket); /* Client handling function */

static struct client** clients;
static pthread_t* threads;
static pthread_mutex_t clients_mutex;
static pthread_mutex_t threads_mutex;

int main(int argc, char *argv[])
{
    int server_sock;                /* Server socket descriptor */
    unsigned short server_port;     /* Echo server port */
    struct sockaddr_in server_addr; /* sockaddr_in struct to hold information about the server */
    int server_addr_size;           /* Size of server_addr struct in bytes */
    int client_sock;
    int empty_thread;
    pthread_attr_t thread_attr;

    if (argc != 2) {  /* Test for correct number of arguments */
        fprintf(stderr, "Usage: %s <server_port>\n", argv[0]);
        exit(1);
    }

    clients = (struct client**) calloc(1, sizeof(struct client*) * MAXCLIENTS);
    if (clients == NULL)
        DieWithError("calloc() for clients failed");
    threads = (pthread_t*) calloc(1, sizeof(pthread_t) * MAXCLIENTS);
    if (clients == NULL)
        DieWithError("calloc() for clients failed");

    pthread_mutex_init(&clients_mutex, NULL);
    pthread_mutex_init(&threads_mutex, NULL);
    pthread_attr_init(&thread_attr);
    pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);

    server_port = atoi(argv[1]);

    /* Create a reliable, stream socket using TCP */
    if ((server_sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        DieWithError("socket() failed");

    // Zero out server_addr var and fill with information
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(server_port);

    // Bind server with sock, IP, and port so that the clients can connect to us
    if (bind(server_sock, (struct sockaddr*) &server_addr, sizeof(server_addr)) < 0)
        DieWithError("bind() failed");

    // Allow this server to accept 5 clients at a time (queue has 0 capacity because we multithread)
    if (listen(server_sock, 0) < 0)
        DieWithError("listen() failed");

    // Display some information so we can connect with client
    printf("Using\n\tport: %d\n\tIP: %s\n", server_port, inet_ntoa(server_addr.sin_addr));
    server_addr_size = sizeof(server_addr);
  for (;;) {
    int* new_socket = (int*)malloc(sizeof(int));
    if ((*new_socket = accept(server_sock, 
        (struct sockaddr*) &server_addr, &server_addr_size)) < 0) {
      printf("accept() failed");
      continue;
    }
    int free_spot = -1;
    for (int i = 0; i < MAXCLIENTS; i++)
        if (!threads[i]) free_spot = i;
    if (free_spot == -1) {
        printf("no empty threads (max clients handled currently)");
        send(*new_socket,(void*) OTHER_BAD_CD, sizeof(OTHER_BAD_CD), 0);
        close(*new_socket);
        continue;
    }

    if (pthread_create(&threads[free_spot], &thread_attr,
        (void*) &handle_client, (void*) new_socket)) {
      printf("pthread_create failed");
      close(*new_socket);
      continue;
    }
    printf("sent new client %d to handle_client()\n", *new_socket);
  }
}

void handle_client(void* new_socket) {
    int socket = *(int*)new_socket;
    free(new_socket);
    printf("handling new client %d\n", socket);
    struct client* curr_cl;
    pthread_mutex_lock(&clients_mutex);
    printf("locked mutex?\n");
    if (send(socket, (void*)ALL_GOOD_CD, sizeof(ALL_GOOD_CD), 0) < 0) {
        printf("inital all good resp failed");
        send(socket, (void*)OTHER_BAD_CD, sizeof(OTHER_BAD_CD), 0);
        return;
    }
    printf("sent stuff\n");
    int free_spot = -1;
    for (int i = 0; i < MAXCLIENTS; i++)
        if (!clients[i]) free_spot = i;

    printf("filtered through clients and got free spot %d\n", free_spot);
    if (free_spot == -1) {
        printf("didn't find free spot :(\n");
        send(socket, (void*)TOO_MANY_CD, sizeof(TOO_MANY_CD), 0);
        pthread_mutex_unlock(&clients_mutex);
        return;
    }
    printf("found free spot %d for client %d", free_spot, socket);
    clients[free_spot] = (struct client*) calloc(1, sizeof(struct client));
    if (clients[free_spot] == NULL) {
        send(socket, (void*)OTHER_BAD_CD, sizeof(OTHER_BAD_CD), 0);
        pthread_mutex_unlock(&clients_mutex);
        return;
    }
    curr_cl = clients[free_spot];

    if (recv(socket, curr_cl->username, sizeof(curr_cl->username), 0) < 0) {
        send(socket, (void*)OTHER_BAD_CD, sizeof(OTHER_BAD_CD), 0);
        pthread_mutex_unlock(&clients_mutex);
        return;
    }

    // Subscribe client to #ALL automatically
    curr_cl->subs[0] = "#ALL";

    if (send(socket, (void*)ALL_GOOD_CD, sizeof(ALL_GOOD_CD), 0) < 0) {
        printf("send() for final all good failed\n");
        send(socket, (void*)OTHER_BAD_CD, sizeof(OTHER_BAD_CD), 0);
        pthread_mutex_unlock(&clients_mutex);
        return;
    }
    printf("\taccepted new client %s and now listening\n", curr_cl->username);
    pthread_mutex_unlock(&clients_mutex);
    return;
}

void DieWithError(char* errorMessage) {
    fprintf(stderr, "Dying with error sadface: %s\n", errorMessage);
    exit(1);
}

这是Makefile

# the compiler: gcc for C
CC = gcc

# compiler flags
CFLAGS = -g

make: ttweetcl.c ttweetsrv.c
    gcc -o ttweetcli ttweetcl.c && gcc -o ttweetsrv ttweetsrv.c -lpthread

.PHONY: clean
clean:
    rm -f ./ttweetcli ./ttweetsrv

Answer 1

解决了！一个评论（现已删除）注意到，我没有以printf()结尾\n，因此没有刷新缓冲区。既然我已经添加了所有\n，则代码将按预期执行。