UNP函数笔记十七: 客户/服务器程序设计范式

最新推荐文章于 2023-03-30 14:24:15 发布
最新推荐文章于 2023-03-30 14:24:15 发布
阅读量864 收藏
点赞数
分类专栏： 笔记 c unix 文章标签： 服务器 thread signal struct tcp null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxxmaker/article/details/7488270
版权
笔记 同时被 3 个专栏收录
82 篇文章 0 订阅
订阅专栏
c
58 篇文章 0 订阅
订阅专栏
unix
49 篇文章 0 订阅
订阅专栏

第三十章  客户/服务器程序设计范式:


示例:

#include "err_exit.h"
#include <sys/mman.h>

/*
 * Allocate an array of "nchildren" longs in shared memory that can
 * be used as a counter by each child of how many clients it services.
 * See pp. 467-470 of "Advanced Programming in the Unix Environment."
 */

long * 
meter(int nchildren)
{
    int    fd;
    long * ptr;

#ifdef MAP_ANON
    if ((ptr = mmap(0, nchildren*sizeof(long), PROT_READ | PROT_WRITE, 
                    MAP_ANON | MAP_SHARED, -1, 0)) == MAP_FAILED) {
        err_exit("mmap error");
    }
#else
    if ((fd = open("/dev/zero", O_RDWR, 0)) == -1) {
        err_exit("open /dev/zero error");
    }

    if ((ptr = mmap(0, nchildren*sizeof(long), PROT_READ | PROT_WRITE, 
                    MAP_SHARED, fd, 0)) == MAP_FAILED) {
        err_exit("mmap error");
    }
    Close(fd);
#endif

    return(ptr);
}


#include "myio.h"
#include "warp.h"
#include "tcp_connect.h"

#define MAXN 16384  /* max # bytes to request from server */

int 
main(int argc, char ** argv)
{
    int      i;
    int      j;
    int      fd;
    int      nchildren;
    int      nloops;
    int      nbytes;
    pid_t    pid;
    ssize_t  n;
    char     request[MAXLINE];
    char     reply[MAXN];

    if (argc != 6) {
        printf("usage: client <hostname or IPaddr> <port> <#children> "
               "<#loops/child> <#bytes/request>\n");
        exit(1);
    }

    nchildren = atoi(argv[3]);
    nloops = atoi(argv[4]);
    nbytes = atoi(argv[5]);
    snprintf(request, sizeof(request), "%d\n", nbytes);  /* newline at end */

    for (i = 0; i < nchildren; i++) {
        if ((pid = Fork()) == 0) {  /* child */
            for (j = 0; j < nloops; j++) {
                fd = tcp_connect(argv[1], argv[2]);

                n = strlen(request);
                if (write(fd, request, n) != n) {
                    err_msg("write error", errno);
                }

                if ((n = readn(fd, reply, nbytes)) != nbytes) {
                    err_msg("readn error", errno);
                }

                Close(fd);  /* TIME_WAIT on client, not server */
            }
            printf("child %d done\n", i);
            exit(0);
        }
        /* parent loops around to fork() again */
    }

    while (wait(NULL) > 0) {  /* now parent waits for all children */

    }

    if (errno != ECHILD) {
        err_msg("wait error", errno);
    }

    exit(0);
}


#ifndef __READLINE_R_H__
#define __READLINE_R_H__


#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#ifndef MAXLINE
#define MAXLINE 4096
#endif

typedef struct {
    int      read_fd;      /* caller's descriptor to read from */
    char   * read_ptr;     /* caller's buffer to read into */
    size_t   read_maxlen;  /* max #bytes to read */
    int      rl_cnt;       /* initialize to 0 */
    char   * rl_bufptr;    /* initialize to rl_buf */
    char     rl_buf[MAXLINE];
} Rline;

ssize_t 
my_read_r(Rline * rptr, char * ptr)
{
    if (rptr->rl_cnt <= 0) {
again:
        rptr->rl_cnt = read(rptr->read_fd, rptr->rl_buf, sizeof(rptr->rl_buf));
        if (rptr->rl_cnt < 0) {
            if (errno == EINTR) {
                goto again;
            }
            else {
                return(-1);
            }
        }
        else if (rptr->rl_cnt == 0) {
            return(0);
        }
        rptr->rl_bufptr = rptr->rl_buf;
    }

    rptr->rl_cnt--;
    *ptr = *rptr->rl_bufptr++ & 255;
    return(1);
}

void 
readline_rinit(int fd, void * ptr, size_t maxlen, Rline * rptr)
{
    rptr->read_fd = fd;  /* save caller's arguments */
    rptr->read_ptr = ptr;
    rptr->read_maxlen = maxlen;

    rptr->rl_cnt = 0;  /* and init our counter & pointer */
    rptr->rl_bufptr = rptr->rl_buf;
}

ssize_t 
readline_r(Rline * rptr)
{
    int    n;
    int    rc;
    char   c; 
    char * ptr;

    ptr = rptr->read_ptr;
    for (n = 1; n < rptr->read_maxlen; n++) {
        if ((rc = my_read_r(rptr, &c)) == 1) {
            *ptr++ = c;
            if (c == '\n') {
                break;
            }
        }
        else if (rc == 0) {
            if (n == 1) {
                return(0);  /* EOF, no data read */
            }
            else {
                break;  /* EOF, some data was read */
            }
        }
        else {
            return(-1);  /* error */
        }
    }

    *ptr = 0;
    return(n);
}

ssize_t 
Readline_r(Rline * rptr)
{
    ssize_t n = readline_r(rptr);
    if (n == -1) {
        printf("readline_r error : %s\n", strerror(errno));
    }
    return(n);
}


#endif


#include "readline_r.h"

#define MAXN 16384  /* max #bytes that a client can request */

void 
web_child(int sockfd)
{
    int      ntowrite;
    ssize_t  nread;
    char     line[MAXLINE];
    char     result[MAXN];
    Rline    rline;

    readline_rinit(sockfd, line, MAXLINE, &rline);
    for ( ; ; ) {
        if ((nread = Readline_r(&rline)) == 0) {
            return;  /* connection closed by other end */
        }

        /* line from client specifies #bytes to write back */
        ntowrite = atol(line);
        if ((ntowrite <= 0) || (ntowrite > MAXN)) {
            printf("client request for %d bytes\n", ntowrite);
            exit(1);
        }

        if (writen(sockfd, result, ntowrite) != ntowrite) {
            printf("writen error : %s\n", strerror(errno));
            exit(1);
        }
    }
}


#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <sys/resource.h>

void 
pr_cpu_time(void)
{
    double         user;
    double         sys;
    struct rusage  myusage;
    struct rusage  childusage;

    if (getrusage(RUSAGE_SELF, &myusage) < 0) {
        printf("getrusage error : %s\n", strerror(errno));
        exit(1);
    }
    if (getrusage(RUSAGE_CHILDREN, &childusage) < 0) {
        printf("getrusage error : %s\n", strerror(errno));
        exit(1);
    }

    user = (double)myusage.ru_utime.tv_sec + 
                   myusage.ru_utime.tv_usec/1000000.0;
    user += (double)childusage.ru_utime.tv_sec + 
                    childusage.ru_utime.tv_usec/1000000.0;
    sys = (double)myusage.ru_stime.tv_sec + 
                  myusage.ru_stime.tv_usec/1000000.0;
    sys += (double)childusage.ru_stime.tv_sec + 
                   childusage.ru_stime.tv_usec/1000000.0;

    printf("\nuser time = %g, sys time = %g\n", user, sys);
}


#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

void 
sig_int(int signo)
{
    pr_cpu_time();
    exit(0);
}

int 
main(int argc, char ** argv)
{
    int               listenfd;
    int               connfd;
    socklen_t         clilen;
    socklen_t         addrlen;
    struct sockaddr * cliaddr;

    if (argc == 2) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 3) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#>\n", argv[0]);
        exit(1);
    }

    cliaddr = Malloc(addrlen);

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        clilen = addrlen;
        connfd = Accept(listenfd, cliaddr, &clilen);

        web_child(connfd);  /* process the request */

        Close(connfd);  /* parent closes connected socket */
    }
}


#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

void 
sig_int(int signo)
{
    pr_cpu_time();
    exit(0);
}

void 
sig_chld(int signo)
{
    pid_t  pid;
    int    stat;

    while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) {
        /* printf("child %d terminated\n", pid); */
    }
    return;
}

int 
main(int argc, char ** argv)
{
    int               listenfd;
    int               connfd;
    pid_t             childpid;
    socklen_t         clilen;
    socklen_t         addrlen;
    struct sockaddr * cliaddr;

    if (argc == 2) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 3) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#>\n", argv[0]);
        exit(1);
    }

    cliaddr = Malloc(addrlen);

    if (my_signal(SIGCHLD, sig_chld) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }
    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        clilen = addrlen;
        if ((connfd = accept(listenfd, cliaddr, &clilen)) < 0) {
            if (errno == EINTR) {
                continue;  /* back to for() */
            }
            else {
                err_msg("accept error", errno);
                exit(1);
            }
        }

        if ((childpid = Fork()) == 0) {  /* child process */
            Close(listenfd);  /* close listening socket */
            web_child(connfd);  /* process request */
            exit(0);
        }
        Close(connfd);  /* parent closes connected socket */
    }
}


#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

int     nchildren;
pid_t * pids;

void 
sig_int(int signo)
{
    int  i;

    /* terminate all children */
    for (i = 0; i < nchildren; i++) {
        kill(pids[i], SIGTERM);
    }
    while (wait(NULL) > 0) {  /* wait for all children */
    
    }
    if (errno != ECHILD) {
        err_msg("wait error", errno);
    }

    pr_cpu_time();
    exit(0);
}

void 
child_main(int i, int listenfd, int addrlen)
{
    int               connfd;
    socklen_t         clilen;
    struct sockaddr * cliaddr;

    cliaddr = Malloc(addrlen);

    printf("child %ld starting\n", (long)getpid());
    for ( ; ; ) {
        clilen = addrlen;
        connfd = Accept(listenfd, cliaddr, &clilen);

        web_child(connfd);  /* process the request */
        Close(connfd);
    }
}

pid_t 
child_make(int i, int listenfd, int addrlen)
{
    pid_t  pid;

    if ((pid = Fork()) > 0) {
        return(pid);  /* parent */
    }

    child_main(i, listenfd, addrlen);  /* never returns */
}

int 
main(int argc, char ** argv)
{
    int        listenfd;
    int        i;
    socklen_t  addrlen;

    if (argc == 3) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 4) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#> <#children>\n", argv[0]);
        exit(1);
    }

    nchildren = atoi(argv[argc-1]);
    pids = Calloc(nchildren, sizeof(pid_t));

    for (i = 0; i < nchildren; i++) {
        pids[i] = child_make(i, listenfd, addrlen);  /* parent returns */
    }

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        pause();  /* everything done by children */
    }
}


#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

int     nchildren;
pid_t * pids;

struct flock  lock_it;
struct flock  unlock_it;
int    lock_fd = -1;  /* fcntl() will fail if my_lock_init() not called */

void 
my_lock_init(char * pathname)
{
    char  lock_file[1024];

    /* must copy caller's string, in case it's a constant */
    strncpy(lock_file, pathname, sizeof(lock_file));
    if ((lock_fd = mkstemp(lock_file)) == -1) {
        printf("mkstemp error : %s\n", strerror(errno));
        exit(1);
    }

    if (unlink(lock_file) == -1) {  /* but lock_fd remains open */
        printf("unlink error : %s\n", strerror(errno));
        exit(1);
    }

    lock_it.l_type = F_WRLCK;
    lock_it.l_whence = SEEK_SET;
    lock_it.l_start = 0;
    lock_it.l_len = 0;

    unlock_it.l_type = F_UNLCK;
    unlock_it.l_whence = SEEK_SET;
    unlock_it.l_start = 0;
    unlock_it.l_len = 0;
}

void 
my_lock_wait()
{
    while (fcntl(lock_fd, F_SETLKW, &lock_it) == -1) {
        if (errno == EINTR) {
            continue;
        }
        else {
            printf("fcntl error for my_lock_wait\n");
            exit(1);
        }
    }
}

void 
my_lock_release()
{
    if (fcntl(lock_fd, F_SETLKW, &unlock_it) == -1) {
        printf("fcntl error for my_lock_release\n");
        exit(1);
    }
}

void 
child_main(int i, int listenfd, int addrlen)
{
    int               connfd;
    socklen_t         clilen;
    struct sockaddr * cliaddr;

    cliaddr = Malloc(addrlen);

    printf("child %ld starting\n", (long)getpid());
    for ( ; ; ) {
        clilen = addrlen;
        my_lock_wait();
        connfd = Accept(listenfd, cliaddr, &clilen);
        my_lock_release();

        web_child(connfd);  /* process the request */
        Close(connfd);
    }
}

pid_t 
child_make(int i, int listenfd, int addrlen)
{
    pid_t  pid;

    if ((pid = Fork()) > 0) {
        return(pid);  /* parent */
    }

    child_main(i, listenfd, addrlen);  /* never returns */
}

void 
sig_int(int signo)
{
    int  i;

    /* terminate all children */
    for (i = 0; i < nchildren; i++) {
        kill(pids[i], SIGTERM);
    }
    while (wait(NULL) > 0) {  /* wait for all children */

    }
    if (errno != ECHILD) {
        err_msg("wait error", errno);
    }

    pr_cpu_time();
    exit(0);
}

int 
main(int argc, char ** argv)
{
    int        listenfd;
    int        i;
    socklen_t  addrlen;

    if (argc == 3) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 4) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#> <#children>\n", argv[0]);
        exit(1);
    }

    nchildren = atoi(argv[argc-1]);
    pids = Calloc(nchildren, sizeof(pid_t));

    my_lock_init("/tmp/lock.XXXXXX");  /* one lock file for all children */
    for (i = 0; i < nchildren; i++) {
        pids[i] = child_make(i, listenfd, addrlen);  /* parent returns */
    }

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        pause();  /* everything done by children */
    }
}


#include <fcntl.h>
#include <sys/mman.h>

#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

int     nchildren;
pid_t * pids;

pthread_mutex_t * mptr;  /* actual mutex will be in shared memory */

void 
my_lock_init(char * pathname)
{
    int                  fd;
    int                  error;
    pthread_mutexattr_t  mattr;

    if ((fd = open("/dev/zero", O_RDWR, 0)) == -1) {
        err_msg("open /dev/zero error", errno);
    }

    if ((mptr = mmap(0, sizeof(pthread_mutex_t), PROT_READ | PROT_WRITE,
                     MAP_SHARED, fd, 0)) == MAP_FAILED) {
        err_msg("mmap error", errno);
    }
    Close(fd);

    if ((error = pthread_mutexattr_init(&mattr)) != 0) {
        err_msg("pthread_mutexattr_init error", error);
    }
    if ((error = pthread_mutexattr_setpshared(&mattr, 
                     PTHREAD_PROCESS_SHARED)) != 0) { /* process lock */
        err_msg("pthread_mutexattr_setpshared error", error);
    }
    if ((error = pthread_mutex_init(mptr, &mattr)) != 0) {
        err_msg("pthread_mutex_init error", error);
    }
}

void 
my_lock_wait()
{
    Pthread_mutex_lock(mptr);
}

void 
my_lock_release()
{
    Pthread_mutex_unlock(mptr);
}

void 
child_main(int i, int listenfd, int addrlen)
{
    int               connfd;
    socklen_t         clilen;
    struct sockaddr * cliaddr;

    cliaddr = Malloc(addrlen);

    printf("child %ld starting\n", (long)getpid());
    for ( ; ; ) {
        clilen = addrlen;
        my_lock_wait();
        connfd = Accept(listenfd, cliaddr, &clilen);
        my_lock_release();

        web_child(connfd);  /* process the request */
        Close(connfd);
    }
}

pid_t 
child_make(int i, int listenfd, int addrlen)
{
    pid_t  pid;

    if ((pid = Fork()) > 0) {
        return(pid);  /* parent */
    }

    child_main(i, listenfd, addrlen);  /* never returns */
}

void 
sig_int(int signo)
{
    int  i;

    /* terminate all children */
    for (i = 0; i < nchildren; i++) {
        kill(pids[i], SIGTERM);
    }
    while (wait(NULL) > 0) {  /* wait for all children */

    }
    if (errno != ECHILD) {
        err_msg("wait error", errno);
    }

    pr_cpu_time();
    exit(0);
}

int 
main(int argc, char ** argv)
{
    int        listenfd;
    int        i;
    socklen_t  addrlen;

    if (argc == 3) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 4) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#> <#children>\n", argv[0]);
        exit(1);
    }

    nchildren = atoi(argv[argc-1]);
    pids = Calloc(nchildren, sizeof(pid_t));

    my_lock_init(NULL);
    for (i = 0; i < nchildren; i++) {
        pids[i] = child_make(i, listenfd, addrlen);  /* parent returns */
    }

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        pause();  /* everything done by children */
    }
}


#include <unistd.h>

#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "read_fd.h"
#include "write_fd.h"
#include "web_child.h"
#include "pr_cpu_time.h"

#define   max(a, b)       ((a) > (b) ? (a) : (b))

typedef struct {
    pid_t  child_pid;     /* process ID */
    int    child_pipefd;  /* parent's stream pipe to/from child */
    int    child_status;  /* 0 = ready */
    long   child_count;   /* # connections handled */
} Child;

Child  * cptr;  /* array of Child structures; calloc'ed */

int  nchildren;

void 
child_main(int i, int listenfd, int addrlen)
{
    char     c;
    int      connfd;
    ssize_t  n;

    printf("child %ld starting\n", (long)getpid());
    for ( ; ; ) {
        if ((n = read_fd(STDERR_FILENO, &c, 1, &connfd)) < 0) {
            err_msg("read_fd error", errno);
        }
        else if (n == 0) {
            printf("read_fd returned 0\n");
            exit(1);
        }

        if (connfd < 0) {
            printf("no descriptor from read_fd\n");
            exit(1);
        }

        web_child(connfd);  /* process request */
        Close(connfd);

        /* tell parent we're ready again */
        if (write(STDERR_FILENO, "", 1) != 1) {
            err_msg("write error", errno);
        }
    }
}

pid_t 
child_make(int i, int listenfd, int addrlen)
{
    int    sockfd[2];
    pid_t  pid;

    if (socketpair(AF_LOCAL, SOCK_STREAM, 0, sockfd) == -1) {
        err_msg("socketpair error", errno);
    }

    if ((pid = Fork()) > 0) {
        Close(sockfd[1]);
        cptr[i].child_pid = pid;
        cptr[i].child_pipefd = sockfd[0];
        cptr[i].child_status = 0;
        return(pid);        /* parent */
    }

    /* child's stream pipe to parent */
    if (dup2(sockfd[1], STDERR_FILENO) == -1) {
        err_msg("dup2 error", errno);
    }
    Close(sockfd[0]);
    Close(sockfd[1]);
    Close(listenfd);  /* child does not need this open */
    child_main(i, listenfd, addrlen);  /* never returns */
}

void 
sig_int(int signo)
{
    int  i;

    /* terminate all children */
    for (i = 0; i < nchildren; i++) {
        kill(cptr[i].child_pid, SIGTERM);
    }
    while (wait(NULL) > 0) {  /* wait for all children */

    }
    if (errno != ECHILD) {
        err_msg("wait error", errno);
    }

    pr_cpu_time();

    for (i = 0; i < nchildren; i++) {
        printf("child %d, %ld connections\n", i, cptr[i].child_count);
    }

    exit(0);
}

int 
main(int argc, char ** argv)
{
    int               listenfd;
    int               i;
    int               navail;
    int               maxfd;
    int               nsel;
    int               connfd;
    int               rc;
    ssize_t           n;
    fd_set            rset;
    fd_set            masterset;
    socklen_t         addrlen;
    socklen_t         clilen;
    struct sockaddr * cliaddr;

    if (argc == 3) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 4) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#> <#children>\n", argv[0]);
        exit(1);
    }

    FD_ZERO(&masterset);
    FD_SET(listenfd, &masterset);
    maxfd = listenfd;
    cliaddr = Malloc(addrlen);

    nchildren = atoi(argv[argc-1]);
    navail = nchildren;
    cptr = Calloc(nchildren, sizeof(Child));

    /* prefork all the children */
    for (i = 0; i < nchildren; i++) {
        child_make(i, listenfd, addrlen);  /* parent returns */
        FD_SET(cptr[i].child_pipefd, &masterset);
        maxfd = max(maxfd, cptr[i].child_pipefd);
    }

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        rset = masterset;
        if (navail <= 0) {
            FD_CLR(listenfd, &rset);  /* turn off if no available children */
        }
        if ((nsel = select(maxfd + 1, &rset, NULL, NULL, NULL)) == -1) {
            err_msg("select error", errno);
        }

        /* check for new connections */
        if (FD_ISSET(listenfd, &rset)) {
            clilen = addrlen;
            connfd = Accept(listenfd, cliaddr, &clilen);

            for (i = 0; i < nchildren; i++) {
                if (cptr[i].child_status == 0) {
                    break;  /* available */
                }
            }

            if (i == nchildren) {
                printf("no available children\n");
                exit(1);
            }
            cptr[i].child_status = 1;  /* mark child as busy */
            cptr[i].child_count++;
            navail--;

            if ((n = write_fd(cptr[i].child_pipefd, "", 1, connfd)) < 0) {
                err_msg("write_fd error", errno);
            }
            Close(connfd);
            if (--nsel == 0) {
                continue;  /* all done with select() results */
            }
        }

        /* find any newly-available children */
        for (i = 0; i < nchildren; i++) {
            if (FD_ISSET(cptr[i].child_pipefd, &rset)) {
                if ((n = read(cptr[i].child_pipefd, &rc, 1)) < 0) {
                    err_msg("read error", errno);
                }
                else if (n == 0) {
                    printf("child %d terminated unexpectedly\n", i);
                    exit(1);
                }
                cptr[i].child_status = 0;
                navail++;
                if (--nsel == 0) {
                    break;  /* all done with select() results */
                }
            }
        }
    }
}


#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

void * 
doit(void * arg)
{
    Pthread_detach(pthread_self());
    web_child((int)arg);
    Close((int)arg);
    return(NULL);
}

void 
sig_int(int signo)
{
    pr_cpu_time();
    exit(0);
}

int 
main(int argc, char ** argv)
{
    int               listenfd;
    int               connfd;
    pthread_t         tid;
    socklen_t         clilen;
    socklen_t         addrlen;
    struct sockaddr * cliaddr;

    if (argc == 2) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 3) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#>\n", argv[0]);
        exit(1);
    }

    cliaddr = (struct sockaddr *)Malloc(addrlen);

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        clilen = addrlen;
        connfd = Accept(listenfd, cliaddr, &clilen);

        Pthread_create(&tid, NULL, &doit, (void *)connfd);
    }
}


#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

typedef struct {
    pthread_t  thread_tid;    /* thread ID */
    long       thread_count;  /* # connections handled */
} Thread;

Thread * tptr;  /* array of Thread structures; calloc'ed */

int              listenfd;
int              nthreads;
socklen_t        addrlen;
pthread_mutex_t  mlock = PTHREAD_MUTEX_INITIALIZER;

void * 
thread_main(void * arg)
{
    int               connfd;
    socklen_t         clilen;
    struct sockaddr * cliaddr;

    cliaddr = Malloc(addrlen);

    printf("thread %d starting\n", (int) arg);
    for ( ; ; ) {
        clilen = addrlen;
        Pthread_mutex_lock(&mlock);
        connfd = Accept(listenfd, cliaddr, &clilen);
        Pthread_mutex_unlock(&mlock);
        tptr[(int)arg].thread_count++;

        web_child(connfd);  /* process request */
        Close(connfd);
    }
}

void 
thread_make(int i)
{
    Pthread_create(&tptr[i].thread_tid, NULL, &thread_main, (void *)i);
    return;   /* main thread returns */
}

void 
sig_int(int signo)
{
    int  i;

    pr_cpu_time();

    for (i = 0; i < nthreads; i++) {
        printf("thread %d, %ld connections\n", i, tptr[i].thread_count);
    }

    exit(0);
}

int 
main(int argc, char ** argv)
{
    int  i;

    if (argc == 3) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 4) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#> <#threads>\n", argv[0]);
        exit(1);
    }

    nthreads = atoi(argv[argc-1]);
    tptr = Calloc(nthreads, sizeof(Thread));

    for (i = 0; i < nthreads; i++) {
        thread_make(i);  /* only main thread returns */
    }

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        pause();  /* everything done by threads */
    }
}


#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

typedef struct {
    pthread_t  thread_tid;    /* thread ID */
    long       thread_count;  /* # connections handled */
} Thread;

Thread * tptr;  /* array of Thread structures; calloc'ed */

#define MAXNCLI  32

int              clifd[MAXNCLI];
int              iget;
int              iput;
pthread_mutex_t  clifd_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t   clifd_cond = PTHREAD_COND_INITIALIZER;
int              nthreads;

void * 
thread_main(void * arg)
{
    int  connfd;

    printf("thread %d starting\n", (int)arg);
    for ( ; ; ) {
        Pthread_mutex_lock(&clifd_mutex);
        while (iget == iput) {
            Pthread_cond_wait(&clifd_cond, &clifd_mutex);
        }
        connfd = clifd[iget];  /* connected socket to service */
        if (++iget == MAXNCLI) {
            iget = 0;
        }
        Pthread_mutex_unlock(&clifd_mutex);
        tptr[(int)arg].thread_count++;

        web_child(connfd);  /* process request */
        Close(connfd);
    }
}

void 
thread_make(int i)
{
    Pthread_create(&tptr[i].thread_tid, NULL, &thread_main, (void *)i);
    return;   /* main thread returns */
}

void 
sig_int(int signo)
{
    int  i;

    pr_cpu_time();

    for (i = 0; i < nthreads; i++) {
        printf("thread %d, %ld connections\n", i, tptr[i].thread_count);
    }

    exit(0);
}

int 
main(int argc, char ** argv)
{
    int               i;
    int               listenfd;
    int               connfd;
    socklen_t         addrlen;
    socklen_t         clilen;
    struct sockaddr * cliaddr;

    if (argc == 3) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 4) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#> <#threads>\n", argv[0]);
    }

    cliaddr = Malloc(addrlen);

    nthreads = atoi(argv[argc-1]);
    tptr = Calloc(nthreads, sizeof(Thread));
    iget = iput = 0;

    /* create all the threads */
    for (i = 0; i < nthreads; i++) {
        thread_make(i);  /* only main thread returns */
    }

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        clilen = addrlen;
        connfd = Accept(listenfd, cliaddr, &clilen);

        Pthread_mutex_lock(&clifd_mutex);
        clifd[iput] = connfd;
        if (++iput == MAXNCLI) {
            iput = 0;
        }
        if (iput == iget) {
            printf("iput = iget = %d\n", iput); /* children too less to hold */
            exit(1);
        }
        Pthread_cond_signal(&clifd_cond);
        Pthread_mutex_unlock(&clifd_mutex);
    }
}


#include "myio.h"
#include "warp.h"
#include "my_signal.h"
#include "tcp_listen.h"
#include "web_child.h"
#include "pr_cpu_time.h"

typedef struct {
    pthread_t  thread_tid;    /* thread ID */
    long       thread_count;  /* #connections handled */
} Thread;

Thread  * tptr;  /* array of Thread structures; calloc'ed */

int        listenfd;
int        nthreads;
socklen_t  addrlen;

void * 
thread_main(void * arg)
{
    int               connfd;
    socklen_t         clilen;
    struct sockaddr * cliaddr;

    cliaddr = Malloc(addrlen);

    printf("thread %d starting\n", (int)arg);
    for ( ; ; ) {
        clilen = addrlen;
        connfd = Accept(listenfd, cliaddr, &clilen);
        tptr[(int)arg].thread_count++;

        web_child(connfd);  /* process the request */
        Close(connfd);
    }
}

void 
thread_make(int i)
{
    Pthread_create(&tptr[i].thread_tid, NULL, &thread_main, (void *)i);
    return;  /* main thread returns */
}

void 
sig_int(int signo)
{
    int  i;

    pr_cpu_time();

    for (i = 0; i < nthreads; i++) {
        printf("thread %d, %ld connections\n", i, tptr[i].thread_count);
    }

    exit(0);
}

int 
main(int argc, char ** argv)
{
    int  i;

    if (argc == 3) {
        listenfd = tcp_listen(NULL, argv[1], &addrlen);
    }
    else if (argc == 4) {
        listenfd = tcp_listen(argv[1], argv[2], &addrlen);
    }
    else {
        printf("usage: %s [ <host> ] <port#> <#threads>\n", argv[0]);
        exit(1);
    }

    nthreads = atoi(argv[argc-1]);
    tptr = Calloc(nthreads, sizeof(Thread));

    for (i = 0; i < nthreads; i++) {
        thread_make(i);  /* only main thread returns */
    }

    if (my_signal(SIGINT, sig_int) == SIG_ERR) {
        err_msg("my_signal error", errno);
    }

    for ( ; ; ) {
        pause();  /* everything done by threads */
    }
}


ken_scott
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Berkeley socket 套接字编程详解
hust_wh的专栏
08-25 1万+
                                              Berkeley 套接字6.1 引言网络程序设计全靠套接字接受和发送信息，尽管套接字这个词好象显得有些神秘，但其实这个概念极易理解。这章主要讲述Sockets　API（Application Program Interface），以及一些其他的细节（比如Socket 的历史、数据中的常用结构等），通过这些介
设备属性权限导致的编译错误
guofeizhi的博客
08-14 6664
先记录下来，后续研究原因。   static DEVICE_ATTR(debug_mesg, S_IRUGO | S_IWUGO, show_debug_mesg, store_debug_mesg); 将S_IWUGO改为S_IWUSR就好了。   In file included from /home/android/work2/R20/LA.UM.6.6/LINUX/android...
20230330完整编译晶视CV1826的buildroot的SDK
南岭笑笑生之家
03-30 1037
drwxrwxr-x 5 rootroot rootroot 4096 3月 30 11:06 sample-demo/drwxrwxr-x 3 rootroot rootroot 4096 3月 30 11:06 host-tools/-rw-rw-r-- 1 rootroot rootroot 3820 3月 30 11:06 .gitignore。-rw-rw-r-- 1 rootroot rootroot 865 3月 30 11:06 README.md。
C++之boost库报错：note: in expansion of macro BOOST_MPL_ASSERT_NOT(八十六)
Android系统攻城狮
07-28 3814
1.下载编译、安装boost1.55版本 https://sourceforge.net/projects/boost/files/boost/1.55.0 解压编译 # ./b2 # cmake -DCMAKE_CXX_FLAGS="-Wno-error=old-style-cast" Or 在test.cmake添加 set(CMAKE_CXX_FLAGS "-Wno-error=old-style-cast")
socket编程1（linux环境下）
持之以恒
05-24 525
描述：有服务端（server）客户端（client）程序，要求实现，服务端从文件中读取文件信息，一次读取10个字节，然后发送到客户端显示，每次读取之后睡眠1秒钟。server.c: /*server.c*/ #include &lt;sys/types.h&gt; #include &lt;sys/socket.h&gt; #include &lt;stdio.h&gt; #inc...
【Redis-6.0.8】观察记录一下Redis的编译过程
Edidaughter的博客
04-19 1152
版本【6.0.8】 [root@localhost redis-6.0.8]# pwd /home/muten/module/redis-6.0.8/redis-6.0.8 [root@localhost redis-6.0.8]# make cd src && make all make[1]: 进入目录“/home/muten/module/redis-6.0.8/redis-6.0.8/src” CC Makefile.dep make[1]: 离开目录“/home/mu.
UNP学习笔记讲义
04-29
Linux 网络编程修炼指南内功心法，这个是博主https://blog.csdn.net/q1007729991/article/details/69101159，大家可以互相学习
实时性能监控，做对了！ https://www.netdata.cloud-C/C++开发
05-26
Netdata提供Unp Netdata Netdata Netdata是分布式的，用于系统和应用程序的实时性能和运行状况监视。 它是您在所有系统和容器上安装的高度优化的监视代理。 Netdata使用高度交互的Web仪表板实时提供了无与伦比的洞察...
unp.rar_W. Richard Stevens_c/C++_unp
09-21
通过研究Stevens的代码，可以学习到如套接字编程、TCP/IP协议栈的实现、并发服务器设计等核心概念。同时，"www.pudn.com.txt"提供的信息可能帮助用户找到更多的学习资料和上下文，从而提升他们的编程技能和理解。
UNP v1：套接字联网API（第3版）中文PDF版
06-30
《UNIX网络编程 卷1:套接字联网API(中文版 第3版)》...全书不但介绍了基本编程内容，还涵盖了与套接字编程相关的高级主题，对于客户/服务器程序的各种设计方法也作了完整的探讨，最后还深入分析了流这种设备驱动机制。
syllabus:UNP 的 Java OOP 继承类教学大纲
06-08
Java编程 查看带有表列表的 README.md 讲师： M. Saiful mukharom, 个人网站： 需要帮忙？ 讨论并制造。 班级说明 本java类教学大纲讨论面向对象的java编程课程，即抽象、封装、继承和多态。...
socket指南(1)
weixin_43754520的博客
09-09 419
socket使用指南
《UNIX网络编程 卷1》 笔记： 服务器程序设计范式
alenliu's blog
07-28 5292
本节也是系列的最后一节，我们讨论TCP服务器的设计范式。 为了简单比较不同设计的服务器性能，我们实现了一个用于测试的客户端程序，它使用多进程建立多个连接，每个连接从服务器获取特定的字节数。使用如下： client 第一个命令行参数是hostname服务器IP，第二个参数port是服务器端口号，第三个参数children是客户要创建的子进程个数，第四个参数loops是每个子进程建
UNIX网络编程(UNP) 第五章学习笔记
404lz保留地
11-23 261
在本章中，我们将完成一个可以回射的服务器和客户端，并且我们需要理解在每一个环节可能出现什么问题，并且加以预防 代码（带注释） // server #include "../unp.h" int main(int argc, char **argv) { int listenfd,connfd; pid_t child_pid; socklen_t clilen; s...
accept函数_嵌入式linux网络编程——5年程序员从函数代码讲解DNS，小白慎入
weixin_39552472的博客
11-18 181
本文主要给大家分享网络概念中的DNS，前边的章节已经给大家讲述了链路层、物理层、网络层、应用层、传输层，以及套接字socket等，欢迎学习嵌入式网络编程的朋友关注、转载和发表评论！ (绝对的好文，建议先收藏和转载！)本次分享的主要内容为：(本文通过函数例程讲解DNS，较抽象，一时没看懂的朋友建议先收藏！)1.1理解 DNS1.2和 DNS 有关的函数和结构1.3DNS 例程2.1套接字的 Clie...
TCP客户端程序
qq_26646107的博客
08-18 197
tcp客户端测试程序： ./client_test 127.0.0.1 9000 1 1 5 在这里插入代码片 #include <stdio.h> #include <stdlib.h> #include <signal.h> #include <errno.h> #include "client_test.h" int tcp_connect(const char *addr, const char *port) { struct sockad
客户/服务器程序设计范式（9类）
yvhqbat的博客
06-07 634
1. 迭代服务器 在完全处理某个客户的请求之后才转向下一个客户。 2. 并发服务器 为每个客户调用fork派生一个子进程。 为每个客户创建一个线程。 预先派生子进程，让服务器在启动阶段调用fork创建一个子进程池，每个客户请求由当前可用子进程池中的某个闲置子进程处理。 预先创建线程，让服务器在启动阶段创建一个线程池，每个客户由当前可用线程池中的某个闲置线程处理。 I/O多路复用： 使用selec
unix网络编程各种TCP客户-服务器程序设计实例（三）
07-12 310
第五种  TCP预先派生子进程服务器程序： 对预先派生子进程服务器的最后一种改动就是由父进程调用accept，然后再将所接受的已连接描述字传递给子进程。父进程必须跟踪子进程的忙闲状态，以便给空闲子进程传递新的描述字。为每个子进程维护一个信息结构，用来管理各子进程。 在调用fork之前，先创建一个字节流管道（Unix域的字节流套接口），它是Unix域的字节流套接口。当子进程派生后
SPProcPool: Unix/Linux 上的进程池服务器框架
iunknown
12-09 197
SPProcPool 是一个 linux/unix 平台上的进程池服务器框架，使用 c++ 实现。主要包含了几种不同类型的进程池的实现： 一个基于 Leader/Follower 模式的服务器端进程池（类似 apache 的 prefork 模型）； 一个组合了 Prefork 和线程池的服务器端框架（类似 apache 的 worker 模型）； 一个基于文件句柄传递的服务器端进程池； ...
UNIX网络编程的unp.h源码
最新发布
07-27
但是，你可以在网络上找到UNIX网络编程（UNP）一书的相关源码。这本书由W. Richard Stevens和Bill Fenner合著，其中提供了一些示例代码和库函数的实现。 你可以在以下位置找到相关源码： 1. 书籍官方网站：你可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值