【c】socket server / client

• common.h

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <time.h>
#include <string.h>
#include <pthread.h>

#define SERVER_PORT 5555
#define MAX_BUF 512
#define DEBUG_ON 1
#define TRUE 1


void print_debug(const char *msg);

void err_sys(const char *error);

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

int bind_R(int sockfd, struct sockaddr *addr, socklen_t len);

int inet_pton_R(int family, const char *strptr, void *addrptr);

int connect_R(int sockfd, const struct sockaddr *seraddr, socklen_t addrlen);

int listen_R(int sockfd, int backlog);

int accept_R(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

int getsockname_R(int sockfd, struct sockaddr *localaddr, socklen_t *addrlen);

int getpeername_R(int sockfd, struct sockaddr *peeraddr, socklen_t *addrlen);

int pthread_create_R(pthrad_t *tid, const pthread_attr_t *attr, void *(*func)(void *), void *arg);

void str_cli(FILE *fp_arg, int sockfd_arg);

• common.c

#include "common.h"

void print_debug(const char *msg) {
if (DEBUG_ON)
printf("\033[0;32m%s\033[0;0m", msg);
}

void err_sys(const char *error) {
if (error == NULL)
return;

printf("Error: %s\n", error);
exit(-1);
}

int socket_R(int family, int type, int protocol) {
int sockfd;

sockfd = socket(family, type, protocol);
if (sockfd < 0)
err_sys("socket");

print_debug("Socket successfully!\n");

return sockfd;
}

int bind_R(int sockfd, struct sockaddr *addr, socklen_t len) {
int ret;

ret = bind(sockfd, addr, len);
if (ret < 0)
err_sys("bind");

print_debug("Bind successfully!\n");

return ret;
}


int inet_pton_R(int family, const char *strptr, void *addrptr) {
int ret;
ret = inet_pton(family, strptr, addrptr);

if (ret != TRUE)
err_sys("inet_pton");

print_debug("inet_pton");

return ret;
}


int connect_R(int sockfd, const struct sockaddr *seraddr, socklen_t addrlen) {
int ret;

ret = connect(sockfd, seraddr, addrlen);

if (ret < 0) 
err_sys("connect");

print_debug("Connect successful!\n");

return ret;
}


int listen_R(int sockfd, int backlog) {
int ret;

ret = listen(sockfd, backlog);
if (ret < 0)
err_sys("listen");

print_debug("Listen successfully\n");

return ret;
}


int accept_R(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen) {
int ret;

ret = accept(sockfd, cliaddr, addrlen);
if (ret < 0)
err_sys("accept");

print_debug("Accept successfully\n");

return ret;
}


int getsockname_R(int sockfd, struct sockaddr *localaddr, socklen_t *addrlen) {
int ret;
ret = getsockname(sockfd, localaddr, addrlen);
if (ret < 0) 
err_sys("getsockname");

print_debug("Getsockname success!\n");

return ret;
}


int getpeername_R(int sockfd, struct sockaddr *peeraddr, socklen_t *addrlen) {
int ret;

ret = getpeername(sockfd, peeraddr, addrlen);
if (ret < 0)
err_sys("getpeername");

print_debug("Getpeername successful\n");

return ret;
}


int pthread_create_R(pthread_t *tid, const pthread_attr *attr, void *(*func)(void *), void *arg) {
pthread_create(tid, attr, func, arg);
}

• server.h

#include "common.h"

#define HOST_NAME "localhost"
#define BACKLOG 10

void work_cycle(int sockfd);

int createSocket(unsigned int port);

void str_echo(int sockfd);

• server.c

#include "server.h"

void str_echo(int sockfd) {
ssize_t n;
char buf[MAX_BUF];

again:
while ( (n = read(sockfd, buf, MAX_BUF)) > 0) 
write(sockfd, buf, n);

if (n<0 && errno==EINTR)
goto again;
else if (n < 0)
err_sys("str_echo");
}

int createSocket(unsigned int port) {
struct sockaddr_in server_addr;
struct hostent *h;
int sockfd; 
int ret;

if ((h = gethostbyname(HOST_NAME)) == NULL) {
printf("gethostbyname failed\n");
exit(-1);
}
printf("Host name: %s\n", h->h_name);

server_addr.sin_family = AF_INET;
server_addr.sin_port = htons((unsigned int)port);
server_addr.sin_addr.s_addr = INADDR_ANY; 
bzero(&(server_addr.sin_zero), 8);

sockfd = socket_R(AF_INET, SOCK_STREAM, 0);

bind_R(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr));

listen_R(sockfd, BACKLOG);

return sockfd;
}


void work_cycle(int sockfd) {
struct sockaddr_in client;
struct timeval tv;
time_t ticks;
int ret;
int conn_fd;
int max_fd = 0;
char buf[MAX_BUF];

fd_set readfds;
fd_set writefds;

tv.tv_sec = 2;
tv.tv_usec = 500000;

for (;;) {
FD_ZERO(&readfds);
FD_ZERO(&writefds);
FD_SET(sockfd, &readfds);

if (max_fd < sockfd)
max_fd = sockfd;

select(max_fd+1, &readfds, &writefds, NULL, &tv);

if (FD_ISSET(sockfd, &readfds)) {
print_debug("readfds has something to read\n");

int size_client = sizeof(struct sockaddr_in);

conn_fd = accept_R(sockfd, (struct sockaddr_in *)&client, &size_client);

if (fork() == 0) {
print_debug("Child process\n");
close(sockfd);
//ticks = time(NULL);
//snprintf(buf, sizeof(buf), "%.24s\r\n", ctime(&ticks));
//write(conn_fd, buf, strlen(buf));
str_ech(conn_fd);

exit(0);
}

close(conn_fd);
}

}
}


int main()
{
int listen_fd;

listen_fd = createSocket(SERVER_PORT);
work_cycle(listen_fd);

close(listen_fd);
return 0;
}

• client.h

#include "common.h"

#define SERVER_IP "127.0.0.1"

• client.c

#include "client.h"

void str_cli(FILE *fp, int sockfd) {
char sendline[MAX_BUF];
char recvline[MAX_BUF];
/*
while (fgets(sendline, MAX_BUF, fp) != NULL) {
write(sockfd, sendline, strlen(sendline));

ifd (rea)
} */
}


int connectServer() {
struct sockaddr_in server_addr;
int sockfd; 
int ret;
char buf[MAX_BUF];

bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
inet_pton_R(AF_INET, SERVER_IP, &server_addr.sin_addr);

server_addr.sin_port = htons((unsigned int)SERVER_PORT);

sockfd = socket_R(AF_INET, SOCK_STREAM, 0);

connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr));

memset(buf, 0, sizeof(buf));
ret = recv(sockfd, buf, MAX_BUF, 0);
if (ret > 0)
fputs(buf, stdout);
return sockfd;
}


int main()
{
int ret;

connectServer();

return 0;
}

• Makefile

all: server client

server: server.o common.o
client: client.o common.o

server.o: server.c server.h 
gcc -c server.c

client.o: client.c client.h
gcc -c client.c

common.o: common.c common.h
gcc -c common.c

clean:
rm *.o