TCP回射程序

最新推荐文章于 2021-10-05 09:58:36 发布

原创最新推荐文章于 2021-10-05 09:58:36 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

网络编程专栏收录该内容

82 篇文章

订阅专栏

本文介绍了一个简单的TCP服务器和客户端程序的实现，通过C语言代码展示了如何建立连接、发送及接收数据的基本过程。服务器采用多进程处理多个客户端连接。

服务器端 tcpserv.c

#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <string.h>
#include <stdlib.h>

#define LISTENQ 1024
#define MAXLINE 4096
#define SERV_PORT 9877
#define SA struct sockaddr

int main(int argc, char* argv[])
{
    int listenfd, connfd;
    pid_t childpid;
    socklen_t   clilen;
    struct sockaddr_in cliaddr, servaddr;

    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, (SA*)&servaddr, sizeof(servaddr));

    listen(listenfd, LISTENQ);

    for(;;)
    {
        clilen = sizeof(cliaddr);
        connfd = accept(listenfd, (SA*)&cliaddr, &clilen);

        if((childpid = fork()) == 0)
        {
            close(listenfd);
            str_echo(connfd);
            exit(0);
        }
        close(connfd);
    }

    exit(0);
}

客户端 tcpcli.c

#include <unistd.h>
#include <stdio.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <stdlib.h>

#define SERV_PORT 9877
#define SA struct sockaddr

int main(int argc, char* argv[])
{
    int sockfd;
    struct sockaddr_in servaddr;

    if(argc != 2)
    {
        err_quit("usage: tcpcli <IPaddress>");
    }
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));

    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

    connect(sockfd, (SA*)&servaddr, sizeof(servaddr));

    str_cli(stdin,sockfd);

    exit(0);
}

str_cli.h

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

#define MAXLINE 4096

void str_cli(FILE* fp, int sockfd);

str_cli.c

#include "str_echo.h"

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

again:
    while((n = read(sockfd, buf, MAXLINE)) > 0)
    {
        writen(sockfd, buf, n);
    }
    
    if(n < 0 && errno == EINTR)
    {
        goto again;
    }
    else if(n < 0)
    {
        err_sys("str_echo: read error");
    }
}

str_echo.h

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

#define MAXLINE 4096

void str_echo(int sockfd);

str_echo.c

#include "str_echo.h"

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

again:
    while((n = read(sockfd, buf, MAXLINE)) > 0)
    {
        writen(sockfd, buf, n);
    }
    
    if(n < 0 && errno == EINTR)
    {
        goto again;
    }
    else if(n < 0)
    {
        err_sys("str_echo: read error");
    }
}

writen.h

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

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

writen.c

#include "writen.h"

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);
}

readline.h

#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

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

readline.c

#include "readline.h"

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++)
    {    
    again:
        if((rc = read(fd, &c, 1)) == 1)
        {
            *ptr++ = c;
            if(c == '\n')
            {
                break;   
            }   
        }                        
        else if(rc == 0)   
        {
            *ptr = 0;
            return (n-1);   
        }
        else
        {
            if(errno == EINTR)
            {
                goto again;   
            }
            return(-1);   
        }   
    }
    *ptr = 0;
    return(n);
}

error.h

#ifndef ERROR_H
#define ERROR_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <syslog.h>
#include <errno.h>
#include "constant.h"

static void err_doit(int, int, const char *, va_list);

void err_ret(const char *fmt, ...);
void err_sys(const char *fmt, ...);
void err_dump(const char *fmt, ...);
void err_msg(const char *fmt, ...);
void err_quit(const char *fmt, ...);

#endif

error.c

#include "error.h"

int daemon_proc;        /* set nonzero by daemon_init() */

static void err_doit(int, int, const char *, va_list);

/* Nonfatal error related to system call
 *  * Print message and return */

void err_ret(const char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    err_doit(1, LOG_INFO, fmt, ap);
    va_end(ap);
    return;
}

/* Fatal error related to system call
 *  * Print message and terminate */

void err_sys(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    err_doit(1, LOG_ERR, fmt, ap);
    va_end(ap);
    exit(1);
}

/* Fatal error related to system call
 *  * Print message, dump core, and terminate */

void err_dump(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    
    err_doit(1, LOG_ERR, fmt, ap);
    
    va_end(ap);
    
    abort();        /* dump core and terminate */
    
    exit(1);        /* shouldn't get here */
}
/* Fatal error unrelated to system call
 *  * Print message and terminate */

void err_quit(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    
    err_doit(0, LOG_ERR, fmt, ap);
    
    va_end(ap);
    
    exit(1);
}

/* Print message and return to caller
 *  * Caller specifies "errnoflag" and "level" */

static void err_doit(int errnoflag, int level, const char *fmt, va_list ap)
{
    int errno_save,n;
    char buf[MAXLINE + 1];
    errno_save = errno;        /* value caller might want printed */
#ifdef HAVE_VSNPRINTF
    vsnprintf(buf, MAXLINE, fmt, ap);    /* safe */
#else
    vsprintf(buf, fmt, ap);                    /* not safe */
#endif
    n = strlen(buf);
    if (errnoflag)
        snprintf(buf + n, MAXLINE - n, ": %s", strerror(errno_save));
    strcat(buf, "\n");
    
    if (daemon_proc) {
        syslog(level, buf);
    }
    else 
    {
        fflush(stdout);        /* in case stdout and stderr are the same */

        fputs(buf, stderr);
        fflush(stderr);
    }
    return;
}

constant.h

#ifndef Constant_H
#define Constant_H

#ifndef MAXLINE
#define MAXLINE 4096
#endif

#ifndef LISTENQ
#define LISTENQ 1024
#endif

#ifndef BUFFSIZE
#define BUFFSIZE 8092
#endif

#endif

makefile

bins = tcpserv tcpcli
objs = tcpserv.o tcpcli.o str_echo.o str_cli.o writen.o readline.o error.o
srcs = tcpserv.c tcpcli.c str_echo.c str_echo.h str_cli.c str_cli.h \
writen.c writen.h readline.c readline.h error.c error.h

$(bins):$(objs)
	gcc -o tcpserv tcpserv.o str_echo.o writen.o readline.o error.o
	gcc -o tcpcli tcpcli.o str_cli.o writen.o readline.o error.o

$(objs):$(srcs)
	gcc -c tcpserv.c
	gcc -c tcpcli.c
	gcc -c str_echo.c str_echo.h error.h
	gcc -c str_cli.c str_cli.h
	gcc -c writen.c writen.h
	gcc -c readline.c readline.h
	gcc -c error.c error.h

clean:
	rm -rf $(bins) *.o *.h.gch