UDP echo demo

[netcomm.h]

#ifndef NETCOMM_H
#define NETCOMM_H

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

#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define MAXLINE 1000
#define LISTENQN 6
#define SERPORT 2400


/*
 * Read n bytes from a descriptor
 */
ssize_t
readn(int fd, void *vptr, size_t n)
{
    size_t nread;
    size_t nleft;
    char   *ptr;

    nread = 0;
    nleft = n;
    ptr = vptr;

    while (nleft > 0)
    {
        if ( (nread = read(fd, ptr, nleft)) < 0)
        {
            if (errno == EINTR) /* Read again */
                nread = 0;
            else
                return -1;
        }
        else if (nread == 0) /* EOF */
            break;

        nleft -= nread;
        ptr   += nread;
    }

    return (n - nleft);
}

/*
 * Write n bytes into a descriptor
 */
ssize_t
writen(int fd, void *vptr, size_t n)
{
    size_t nleft;
    size_t nwriten;
    void   *ptr;

    nleft   = n;
    nwriten = 0;
    ptr     = vptr;

    while (nleft > 0)
    {
        if ( (nwriten = write(fd, ptr, nleft)) <= 0)
        {
            if (nwriten < 0 && errno == EINTR)
                nwriten = 0;
            else
                return (-1);
        }

        nleft -= nwriten;
        ptr   += nwriten;
    }

    return (n);
}

/*
 * Read a line from descriptor
 */
ssize_t
readline(int fd, void *vptr, size_t maxlen)
{
    int  n, rc;
    char *ptr;
    char c;

    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) /* EOF */
        {
            *ptr = 0;
            return (n - 1);
        } else
        {
            if (errno == EINTR)
               goto again;
            return (-1);
        }
    }

    *ptr = 0;
    return n;
}
#endif

 

[echo_client.c]

/*
 * Echo client demo with UDP protocol
 */
#include "netcomm.h"

static void echo_client(FILE *, int, struct sockaddr *, socklen_t);

int
main(int argc, char **argv)
{
    int                clifd;
    struct sockaddr_in serveraddr;

    if (argc != 2) {
        printf("Usage:echo_client <IP>\n");
        exit(-1);
    }

    /* Initialize client fd */
    if ( (clifd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        printf("Create socket error!\n");
        exit(-1);
    }

    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    if (inet_pton(AF_INET, argv[1], &serveraddr.sin_addr) < 0) {
        printf("inet_pton error!\n");
        exit(-1);
    }
    serveraddr.sin_port = htons(SERPORT);
    echo_client(stdin, clifd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

    exit(0);
}


static void
echo_client(FILE *fp, int connfd, struct sockaddr * pserveraddr,
        socklen_t servaddrlen) {
    char      send[MAXLINE], receive[MAXLINE];
    socklen_t len;

    while ( fgets(send, MAXLINE, fp) != NULL) {
        if (sendto(connfd, send, sizeof(send), 0,
                pserveraddr, sizeof(*pserveraddr)) < 0) {
            printf("sendto error!\n");
            exit(-1);
        }

        if (recvfrom(connfd, receive, MAXLINE, 0,
                pserveraddr, &len) == 0) {
            printf("str_client: server terminated.\n");
            return;
        }

        fputs(receive, stdout);
    }
}

 

[echo_server.c]

/*
 * Echo server demo with the UDP protocol
 */
#include "netcomm.h"

static void
dg_echo(int connfd, struct sockaddr *pcliaddr, socklen_t clilen);

int
main(int argc, char **argv)
{
    int                sockfd;
    struct sockaddr_in serveraddr, cliaddr;

    /* Initialize server addr */
    if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        printf("Create socket error!\n");
        exit(-1);
    }

    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(SERPORT);

    /* Bind server addr to socket fd */
    if (bind(sockfd, (const struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0){
        printf("bind addr error!\n");
        exit(-1);
    }
    dg_echo(sockfd, (const struct sockaddr *)&cliaddr, sizeof(cliaddr));
}


static void
dg_echo(int connfd, struct sockaddr *pcliaddr, socklen_t clilen) {
    size_t n;
    socklen_t len;
    char      buf[MAXLINE];

    for (; ;) {
        len = clilen;
        if ( (n = recvfrom(connfd, buf, MAXLINE, 0,
               pcliaddr, &len)) >= 0) {
            if (sendto(connfd, buf, n, 0, pcliaddr, len) < 0) {
                printf("sendto error!\n");
                return;
            }
        } else {
            printf("recvfrom error!\n");
            return;
        }
    }
}