/* server.c */

#include <stdio.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <pthread.h>

#include "wrap.h"

#define MAXLINE 80

#define SERV_PORT 8000

?

struct s_info {

struct sockaddr_in cliaddr;

int connfd;

};

?

void *do_work(void *arg)

{

int n,i;

struct s_info *ts = (struct s_info*)arg;

char buf[MAXLINE];

char str[INET_ADDRSTRLEN];

/*可以在創建線程前設置線程創建屬性,設為分離態,哪種效率高內？?答：線程前設置線程屬性*/

pthread_detach(pthread_self());

while (1) {

n = Read(ts->connfd, buf, MAXLINE);

if (n == 0) {

printf("the other side has been closed.\n");

break;

}

printf("received from %s at PORT %d\n",

inet_ntop(AF_INET, &(*ts).cliaddr.sin_addr, str, sizeof(str)),

ntohs((*ts).cliaddr.sin_port));

for (i = 0; i < n; i++) {

buf[i] = toupper(buf[i]);

???????}

Write(ts->connfd, buf, n);

}

Close(ts->connfd);

}

?

int main(void) {

struct sockaddr_in servaddr, cliaddr;

socklen_t cliaddr_len;

int listenfd, connfd;

int i = 0;

pthread_t tid;

struct s_info ts[383];

listenfd = Socket(AF_INET, SOCK_STREAM, 0);

bzero(&servaddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

servaddr.sin_port = htons(SERV_PORT);

Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

Listen(listenfd, 20);

printf("Accepting connections ...\n");

while (1) {

cliaddr_len = sizeof(cliaddr);

connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);

ts[i].cliaddr = cliaddr;

ts[i].connfd = connfd;

/*達到線程最大數時，pthread_create出錯處理,增加服務器穩定性*/

pthread_create(&tid, NULL, do_work, (void*)&ts[i]);

i++;

}

?Close(listenfd);

return 0;

}

/* client.c */

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <netinet/in.h>

#include "wrap.h"

#define MAXLINE 80

#define SERV_PORT 8000

int main(int argc, char *argv[])

{

struct sockaddr_in servaddr;

char buf[MAXLINE];

int sockfd, n;

sockfd = Socket(AF_INET, SOCK_STREAM, 0);

bzero(&servaddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

servaddr.sin_port = htons(SERV_PORT);

Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

while (fgets(buf, MAXLINE, stdin) != NULL) {

Write(sockfd, buf, strlen(buf));

n = Read(sockfd, buf, MAXLINE);

if (n == 0)

printf("the other side has been closed.\n");

else

Write(STDOUT_FILENO, buf, n);

}

Close(sockfd);

return 0;

}

#ifndef __WRAP_H_

#define __WRAP_H_

?

void perr_exit(const char *s);

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);

void Bind(int fd, const struct sockaddr *sa, socklen_t salen);

void Connect(int fd, const struct sockaddr *sa, socklen_t salen);

void Listen(int fd, int backlog);

int Socket(int family, int type, int protocol);

ssize_t Read(int fd, void *ptr, size_t nbytes);

ssize_t Write(int fd, const void *ptr, size_t nbytes);

void Close(int fd);

ssize_t Readn(int fd, void *vptr, size_t n);

ssize_t Writen(int fd, const void *vptr, size_t n);

static ssize_t my_read(int fd, char *ptr);

ssize_t Readline(int fd, void *vptr, size_t maxlen);

?

#endif

#include <stdlib.h>

#include <errno.h>

#include <sys/socket.h>

?

void perr_exit(const char *s)

{

????????perror(s);

????????exit(1);

}

?

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)

{

????????int n;

?

again:

????????if ( (n = accept(fd, sa, salenptr)) < 0) {

??????????????????if ((errno == ECONNABORTED) || (errno == EINTR))

???????????????????????????goto again;

??????????????????else

???????????????????????????perr_exit("accept error");

????????}

????????return n;

}

?

void Bind(int fd, const struct sockaddr *sa, socklen_t salen)

{

????????if (bind(fd, sa, salen) < 0)

??????????????????perr_exit("bind error");

}

?

void Connect(int fd, const struct sockaddr *sa, socklen_t salen)

{

????????if (connect(fd, sa, salen) < 0)

??????????????????perr_exit("connect error");

}

?

void Listen(int fd, int backlog)

{

????????if (listen(fd, backlog) < 0)

??????????????????perr_exit("listen error");

}

?

int Socket(int family, int type, int protocol)

{

????????int n;

?

????????if ( (n = socket(family, type, protocol)) < 0)

??????????????????perr_exit("socket error");

????????return n;

}

?

ssize_t Read(int fd, void *ptr, size_t nbytes)

{

????????ssize_t n;

?

again:

????????if ( (n = read(fd, ptr, nbytes)) == -1) {

??????????????????if (errno == EINTR)

???????????????????????????goto again;

??????????????????else

???????????????????????????return -1;

????????}

????????return n;

}

?

ssize_t Write(int fd, const void *ptr, size_t nbytes)

{

????????ssize_t n;

?

again:

????????if ( (n = write(fd, ptr, nbytes)) == -1) {

??????????????????if (errno == EINTR)

???????????????????????????goto again;

??????????????????else

???????????????????????????return -1;

????????}

????????return n;

}

?

void Close(int fd)

{

????????if (close(fd) == -1)

??????????????????perr_exit("close error");

}

ssize_t Readn(int fd, void *vptr, size_t n)

{

????????size_t?nleft;

????????ssize_t nread;

????????char??*ptr;

?

????????ptr = vptr;

????????nleft = n;

????????while (nleft > 0) {

??????????????????if ( (nread = read(fd, ptr, nleft)) < 0) {

???????????????????????????if (errno == EINTR)

????????????????????????????????????nread = 0;

???????????????????????????else

????????????????????????????????????return -1;

??????????????????} else if (nread == 0)

???????????????????????????break;

?

??????????????????nleft -= nread;

??????????????????ptr += nread;

????????}

????????return n - nleft;

}

?

ssize_t Writen(int fd, const void *vptr, size_t n)

{

????????size_t nleft;

????????ssize_t nwritten;

????????const char *ptr;

?

????????ptr = vptr;

????????nleft = n;

????????while (nleft > 0) {

??????????????????if ( (nwritten = write(fd, ptr, nleft)) <= 0) {

???????????????????????????if (nwritten < 0 && errno == EINTR)

????????????????????????????????????nwritten = 0;

???????????????????????????else

????????????????????????????????????return -1;

??????????????????}

?

??????????????????nleft -= nwritten;

??????????????????ptr += nwritten;

????????}

????????return n;

}

static ssize_t my_read(int fd, char *ptr)

{

????????static int read_cnt;

????????static char *read_ptr;

????????static char read_buf[100];

?

????????if (read_cnt <= 0) {

again:

??????????????????if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {

???????????????????????????if (errno == EINTR)

????????????????????????????????????goto again;

???????????????????????????return -1;

??????????????????} else if (read_cnt == 0)

???????????????????????????return 0;

??????????????????read_ptr = read_buf;

????????}

????????read_cnt--;

????????*ptr = *read_ptr++;

????????return 1;

}

?

ssize_t Readline(int fd, void *vptr, size_t maxlen)

{

????????ssize_t n, rc;

????????char???c, *ptr;

?

????????ptr = vptr;

????????for (n = 1; n < maxlen; n++) {

??????????????????if ( (rc = my_read(fd, &c)) == 1) {

???????????????????????????*ptr++ = c;

???????????????????????????if (c?== '\n')

????????????????????????????????????break;

??????????????????} else if (rc == 0) {

???????????????????????????*ptr = 0;

???????????????????????????return n - 1;

??????????????????} else {

???????????????????????????return -1;

???????}

????????}??????????????????

????????*ptr?= 0;

????????return n;

}