head	1.12;
access;
symbols
	LMTP2NNTP_1_2a1:1.11
	LMTP2NNTP_1_1_1:1.11
	LMTP2NNTP_1_1_0:1.11
	LMTP2NNTP_1_1b4:1.11
	LMTP2NNTP_1_1b3:1.11
	L2_CHANNEL_ONLY_REVAMPING_BEFORE:1.11
	LMTP2NNTP_1_1b2:1.11
	LMTP2NNTP_1_1b1:1.10
	L2_0_1_0:1.6;
locks; strict;
comment	@ * @;


1.12
date	2001.12.22.21.58.52;	author rse;	state dead;
branches;
next	1.11;

1.11
date	2001.10.12.14.48.00;	author ms;	state Exp;
branches;
next	1.10;

1.10
date	2001.09.26.09.00.21;	author ms;	state Exp;
branches;
next	1.9;

1.9
date	2001.09.26.08.55.19;	author ms;	state Exp;
branches;
next	1.8;

1.8
date	2001.09.13.19.18.34;	author rse;	state Exp;
branches;
next	1.7;

1.7
date	2001.09.13.16.19.06;	author ms;	state Exp;
branches;
next	1.6;

1.6
date	2001.09.10.06.43.10;	author ms;	state Exp;
branches;
next	1.5;

1.5
date	2001.09.10.04.27.36;	author ms;	state Exp;
branches;
next	1.4;

1.4
date	2001.09.07.13.03.07;	author ms;	state Exp;
branches;
next	1.3;

1.3
date	2001.09.06.19.29.14;	author ms;	state Exp;
branches;
next	1.2;

1.2
date	2001.09.06.14.31.33;	author ms;	state Exp;
branches;
next	1.1;

1.1
date	2001.09.05.16.15.48;	author ms;	state Exp;
branches;
next	;


desc
@@


1.12
log
@Remove socket monitor utility, because now we have SA and the
functionality either has to be applied again as an "satool" to SA or we
should use one of the existing tools like "netcat", etc.
@
text
@/*
**  L2 - OSSP Logging Library
**  Copyright (c) 2001 The OSSP Project (http://www.ossp.org/)
**  Copyright (c) 2001 Cable & Wireless Deutschland (http://www.cw.com/de/)
**
**  This file is part of OSSP L2, a flexible logging library which
**  can be found at http://www.ossp.org/pkg/l2/.
**
**  Permission to use, copy, modify, and distribute this software for
**  any purpose with or without fee is hereby granted, provided that
**  the above copyright notice and this permission notice appear in all
**  copies.
**
**  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
**  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
**  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
**  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
**  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
**  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
**  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
**  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
**  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
**  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
**  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
**  SUCH DAMAGE.
**
**  l2_sockmon.c: Socket monitor for use with l2_test.c
*/

#include <ctype.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>

#include "l2.h"
#include "l2_ut_sa.h"

#define BACKLOG              1024      /* max # pending connections */
#define BUFFSIZ               256      /* max string size           */
#define L2_SA_SOCKET_TIMEOUT   64
#define L2_SA_SOCKET_BUFSIZE 4096

char *strlowerdup(const char *);       /* prototypes */
void dowork(int);
int  myserver(int, int, int);
void die(const char *);
void closedie(sa_t *, const char *);
void usage(char *);

void die(const char *szMsg)
{
    perror(szMsg);
    exit(EXIT_FAILURE);
}

void closedie(sa_t *saSock, const char *szMsg)
{
    perror(szMsg);
    sa_destroy(saSock); /* saSock->destroy would really be nice here */
    exit(EXIT_FAILURE);
}

char *strlowerdup(const char *szIn)
{
    int  i       = 0;
    char *szTemp = NULL;

    assert(szIn != NULL);

    if ((szTemp = (char *)strdup(szIn)) == NULL)
        return NULL;
    else
    {
        for (i = 0; *(szTemp + i); i++)
            if (isupper(*(szTemp + i)))
                *(szTemp + i) = (char)tolower(*(szTemp + i));
        return szTemp;
    }
}

void dowork(int iSock)
{
    char szBuf[BUFFSIZ];
    int  cc;

    while (1) { /* Exits when read finishes */
        cc = read(iSock, szBuf, sizeof (szBuf));
        if (cc == -1)
            die("read()");

        if (cc == 0) {
            /* EOF */
            close(iSock);
            fprintf(stderr, "Connection closed\n");
            exit(EXIT_SUCCESS);
        }

        szBuf[cc + 1] = '\0';
        fprintf(stderr, "Read: %s", szBuf);

        if (write(iSock, szBuf, cc) == -1)
            die("write()");
    }
}

int myserver(int iFamily, int iProtocol, int iPort)
{
    sa_type_t  saType;
    sa_addr_t *saAddr;
    sa_t      *saListen, saAccept;
    int        iSock,    iSockopt;

    char                szBuf[BUFFSIZ];
    char                szAddrin4[INET_ADDRSTRLEN];
    char                szAddrin6[INET6_ADDRSTRLEN];
    struct sockaddr_in  faddr4,    caddr4;
    struct sockaddr_in6 faddr6,    caddr6;
    int                 iNewsock;
    int                 cc;
    socklen_t           faddrlen;

    /* Create socket address, the sa_addr object */
    /* starts in a state similar to INADDR_ANY   */
    if (sa_addr_create(&saAddr) != SA_OK)
        die("sa_addr_create()");

    /* Create socket */
    if (sa_create(&saListen) != SA_OK)
        closedie(saListen, "sa_create()");

    if (!(iProtocol == IPPROTO_UDP || iProtocol == IPPROTO_TCP))
        closedie(saListen, "unknown protocol");
    saType = (iProtocol == IPPROTO_UDP) ? SA_TYPE_DATAGRAM : SA_TYPE_STREAM;

    /* Configure socket parameters */
    sa_timeout(saListen, L2_SA_SOCKET_TIMEOUT, 0);
    sa_buffers(saListen, L2_SA_SOCKET_BUFSIZE, L2_SA_SOCKET_BUFSIZE);
    sa_type   (saListen, saType);

    /* Allow local addresses to be reused */
    if (sa_getfd(saListen, &iSock) != SA_OK)
        closedie(saListen, "sa_getfd()");
    iSockopt = 1;
    if (setsockopt(iSock, SOL_SOCKET, SO_REUSEADDR, (void *)&iSockopt, sizeof (iSockopt)) == -1)
        closedie(saListen, "setsockopt()");

    if (sa_bind(saListen, saAddr) != SA_OK)
        closedie(saListen, "sa_bind()");

    if (iProtocol == IPPROTO_UDP) {
        if (iFamily == AF_INET6) {
            /* initialize address structure */
            memset(&caddr6,  0, sizeof(caddr6));

            for (;;) { /* Receive messages */
                faddrlen = sizeof(caddr6);
                memset(szBuf, 0x0, BUFFSIZ); /* Init the buffer */
                cc = recvfrom(iSock, szBuf, BUFFSIZ, 0, (struct sockaddr *)\
                    &caddr6, &faddrlen);

                if (cc == -1)
                    die("recvfrom()");

                if (cc == 0) { /* EOF */
                    close(iSock);
                    fprintf(stderr, "Connection closed\n");
                    return 0;
                }

                if (cc != BUFFSIZ) {
                    szBuf[cc + 1] = '\0';
                    fprintf(stderr, "Read: %s", szBuf);

                    if (write(iSock, szBuf, cc) == -1)
                        die("write()");
                }
                else
                    return -1;
            }
        }
        else if (iFamily == AF_INET) {
            /* initialize address structure */
            memset(&caddr4, 0, sizeof(caddr4));

            for (;;) { /* Receive messages */
                faddrlen = sizeof(caddr4);
                memset(szBuf, 0x0, BUFFSIZ); /* Init the buffer */
                cc = recvfrom(iSock, szBuf, BUFFSIZ, 0, (struct sockaddr *)\
                    &caddr4, &faddrlen);

                if (cc == -1)
                    die("recvfrom()");

                if (cc == 0) { /* EOF */
                    close(iSock);
                    fprintf(stderr, "Connection closed\n");
                    return 0;
                }

                if (cc != BUFFSIZ) {
                    szBuf[cc + 1] = '\0';
                    fprintf(stderr, "Read: %s", szBuf);

                    if (write(iSock, szBuf, cc) == -1)
                        die("write()");
                }
                else
                    return -1;
            }
        }
    }
    else if (iProtocol == IPPROTO_TCP) { /* Only try to listen if we have TCP */
        if (sa_listen(saListen, BACKLOG) != SA_OK)
            closedie(saListen, "sa_listen()");

        /* Wait for a connection request */
        if (iFamily == AF_INET6) {
            /* initialize address structure */
            memset(&faddr6,  0, sizeof(faddr6));

            for (;;) {
                faddrlen = sizeof (faddr6);
                if (sa_accept(saListen, &saAddr, &saAccept) != SA_OK) {
                    sa_destroy(saAccept);
                    closedie(saListen, "sa_accept()");
                }

                if (sa_addr_a2u(saAddr, char **uri))
                if (inet_ntop(AF_INET6, &faddr6.sin6_addr, szAddrin6, sizeof(szAddrin6)) != NULL) {
                    fprintf(stderr, "Connection from %s/%d\n", szAddrin6, ntohs(faddr6.sin6_port));
                    dowork(iNewsock); /* do some sockwork */
                }
                else
                    die("inet_ntop()");
            }
        }
        else if (iFamily == AF_INET) {
            /* initialize address structure */
            memset(&faddr4,  0, sizeof(faddr4));

            for (;;) {
                faddrlen = sizeof (faddr4);
                iNewsock = accept(iSock, (struct sockaddr *)&faddr4, &faddrlen);
                if (iNewsock == -1) {
                    if (errno != EINTR && errno != ECONNABORTED) {
                        perror("accept()");
                    }
                    continue;
                }
                inet_ntop(AF_INET6, &faddr4.sin_addr, szAddrin4, sizeof(szAddrin4));
                fprintf(stderr, "Connection from %s/%d\n", szAddrin4, ntohs(faddr6.sin6_port));
                dowork(iNewsock); /* do some sockwork */
            }
        }
    } /* NOTREACHED */
    return -1; /* Failure due to non UDP/TCP request, or execution flow */
}

void usage(char *szApp)
{
    fprintf(stderr, "Usage: %s <IPv4-or-IPv6> <TCP-or-UDP> <Port>\n", szApp);
    exit(EXIT_FAILURE); /* The user doesn't know how to use this */
}

int main(int argc, char *argv[])
{
    int iFam      = -1;
    int iProto = -1;
    int iPort  = 0;

    if (argc != 4)
        usage(argv[0]);

    if (!strcmp(argv[1], "IPv6"))
        iFam = AF_INET6;
    else if (!strcmp(argv[1], "IPv4"))
        iFam = AF_INET;
    else
        usage(argv[0]);

    if (!strcmp(argv[2], "UDP"))
        iProto = IPPROTO_UDP;
    else if (!strcmp(argv[2], "TCP"))
        iProto = IPPROTO_TCP;
    else
        usage(argv[0]);

    iPort = htons(atoi(argv[3]));
    return myserver(iFam, iProto, iPort);
}
@


1.11
log
@Intermediate committal of local socket code translation to libsa-type calls.
@
text
@@


1.10
log
@More cleanup.
@
text
@d41 1
d43 4
a46 2
#define BACKLOG 1024    /* max # pending connections */
#define BUFFSIZ 256     /* max string size           */
d52 2
a53 1
void closedie(int, const char *);
d61 1
a61 1
void closedie(int iSock, const char *szMsg)
d64 1
a64 1
    close(iSock);
d113 5
d121 4
a124 5
    struct sockaddr_in  laddr4,   faddr4,    caddr4;
    struct sockaddr_in6 laddr6,   faddr6,    caddr6;
    int                 iSock,    iNewsock;
    int                 iSockopt, iProtofam;
    int                 iTrans,   cc;
d127 21
a147 31
    /* Set up an IPv4 TCP socket to listen on for connections. */
    if (iFamily == AF_INET6)
    {
        /* initialize address structure */
        memset(&laddr6,  0, sizeof(laddr6));

        laddr6.sin6_family      = AF_INET6;
        laddr6.sin6_flowinfo    = 0;
        laddr6.sin6_port        = iPort;
        laddr6.sin6_addr        = in6addr_any; /* Structure assignment */
    }
    else if (iFamily == AF_INET)
    {
        /* initialize address structure */
        memset(&laddr4,  0, sizeof(laddr4));

        laddr4.sin_family       = AF_INET;
        laddr4.sin_port         = iPort;
        laddr4.sin_addr.s_addr  = INADDR_ANY;
    }
    else
        return -1; /* Not IPv4 or IPv6 */

    iProtofam = (iFamily   == AF_INET)     ? PF_INET    : PF_INET6;
    iTrans    = (iProtocol == IPPROTO_UDP) ? SOCK_DGRAM : SOCK_STREAM;
    iSock     = socket(iProtofam, iTrans, iProtocol);

    if (iSock == -1)
        die("socket()");

    /* Allow local addresses to be reused. */
d150 1
a150 6
        closedie(iSock, "setsockopt(SO_REUSEADDR)");

    if (iFamily == AF_INET6) {
        if (bind(iSock, (struct sockaddr *)&laddr6, sizeof (laddr6)) == -1)
            closedie(iSock, "bind()");
    }
d152 2
a153 4
    else if (iFamily == AF_INET) {
        if (bind(iSock, (struct sockaddr *)&laddr4, sizeof (laddr4)) == -1)
            closedie(iSock, "bind()");
    }
d218 2
a219 2
        if (listen(iSock, BACKLOG) == -1)
            closedie(iSock, "listen()");
d228 3
a230 6
                iNewsock = accept(iSock, (struct sockaddr *)&faddr6, &faddrlen);
                if (iNewsock == -1) {
                    if (errno != EINTR && errno != ECONNABORTED) {
                        perror("accept()");
                    }
                    continue;
d233 1
d264 6
d276 9
a284 4
    if (argc != 4) {
        fprintf(stderr, "Usage: %s <IPv4-or-IPv6> <TCP-or-UDP> <Port>\n", argv[0]);
        exit(EXIT_FAILURE); /* The user doesn't know how to use this */
    }
d286 6
a291 3
    iFam    = (!strcmp(argv[1], "IPv6")) ? AF_INET6    : AF_INET;
    iProto  = (!strcmp(argv[2], "UDP"))  ? IPPROTO_UDP : IPPROTO_TCP;
    iPort   = htons(atoi(argv[3]));
d293 1
@


1.9
log
@Cleanup before conversion to use sa_family socket calls.
@
text
@d54 1
a54 1
    exit(1);
d61 1
a61 1
    exit(1);
d96 1
a96 1
            return;
d146 2
a147 4
    if (iSock == -1) {
        perror("socket");
        return -1;
    }
d283 1
a283 1
        exit(1); /* Dink donk if the user doesn't know how to use this */
@


1.8
log
@use assert(3) instead of home-brewn stuff
@
text
@d30 1
d34 1
d36 1
d45 20
a64 1
char *strlowerdup(const char *pszIn)
d66 2
a67 2
    int  i        = 0;
    char *pszTemp = NULL;
d69 1
a69 1
    assert(pszIn != NULL);
d71 1
a71 1
    if ((pszTemp = (char *)strdup(pszIn)) == NULL)
d75 4
a78 4
        for (i = 0; *(pszTemp + i); i++)
            if (isupper(*(pszTemp + i)))
                *(pszTemp + i) = (char)tolower(*(pszTemp + i));
        return pszTemp;
d84 1
a84 1
    char pszBuf[BUFFSIZ];
d88 3
a90 5
        cc = read(iSock, pszBuf, sizeof (pszBuf));
        if (cc == -1) {
            perror("read");
            exit(1);
        }
d94 2
a95 2
            (void) close(iSock);
            (void) printf("Connection closed\n");
d99 2
a100 2
        pszBuf[cc + 1] = '\0';
        (void) printf("Read: %s", pszBuf);
d102 2
a103 4
        if (write(iSock, pszBuf, cc) == -1) {
            perror("write");
            exit(1);
        }
d109 3
a111 1
    char pszBuf[BUFFSIZ];
d151 1
a151 1
    /* Tell the system to allow local addresses to be reused. */
d153 2
a154 6
    if (setsockopt(iSock, SOL_SOCKET, SO_REUSEADDR, (void *)&iSockopt,\
        sizeof (iSockopt)) == -1) {
        perror("setsockopt(SO_REUSEADDR)");
        (void) close(iSock);
        return -1;
    }
d157 2
a158 5
        if (bind(iSock, (struct sockaddr *)&laddr6, sizeof (laddr6)) == -1) {
            perror("bind"); /* Bad bind */
            (void) close(iSock);
            return -1;
            }
d160 1
d162 2
a163 5
        if (bind(iSock, (struct sockaddr *)&laddr4, sizeof (laddr4)) == -1) {
            perror("bind"); /* Bad bind */
            (void) close(iSock);
            return -1;
            }
d173 2
a174 2
                memset(pszBuf, 0x0, BUFFSIZ); /* Init the buffer */
                cc = recvfrom(iSock, pszBuf, BUFFSIZ, 0, (struct sockaddr *)\
d177 2
a178 4
                if (cc == -1) {
                    perror("recvfrom");
                    exit(1);
                }
d180 4
a183 5
                if (cc == 0) {
                    /* EOF */
                    (void) close(iSock);
                    (void) printf("Connection closed\n");
                    return;
d187 2
a188 2
                    pszBuf[cc + 1] = '\0';
                    (void) printf("Read: %s", pszBuf);
d190 2
a191 4
                    if (write(iSock, pszBuf, cc) == -1) {
                        perror("write");
                        exit(1);
                    }
d199 1
a199 1
            memset(&caddr4,  0, sizeof(caddr4));
d203 2
a204 2
                memset(pszBuf, 0x0, BUFFSIZ); /* Init the buffer */
                cc = recvfrom(iSock, pszBuf, BUFFSIZ, 0, (struct sockaddr *)\
d207 2
a208 4
                if (cc == -1) {
                    perror("recvfrom");
                    exit(1);
                }
d210 4
a213 5
                if (cc == 0) {
                    /* EOF */
                    (void) close(iSock);
                    (void) printf("Connection closed\n");
                    return;
d217 2
a218 2
                    pszBuf[cc + 1] = '\0';
                    (void) printf("Read: %s", pszBuf);
d220 2
a221 4
                    if (write(iSock, pszBuf, cc) == -1) {
                        perror("write");
                        exit(1);
                    }
d229 2
a230 5
        if (listen(iSock, BACKLOG) == -1) {
            perror("listen"); /* Listen just blew up */
            (void) close(iSock);
            return -1;
        }
d242 1
a242 1
                        perror("accept");
d246 7
a252 3
                (void) printf("Connection from %s/%d\n",\
                    inet_ntop(faddr6.sin6_addr), ntohs(faddr6.sin6_port));
                dowork(iNewsock); /* do some sockwork */
d264 1
a264 1
                        perror("accept");
d268 2
a269 2
                (void) printf("Connection from %s/%d\n",\
                    inet_ntop(faddr4.sin_addr), ntohs(faddr4.sin_port));
d273 2
a274 4
        /* NOTREACHED */
    }
    else
        return -1; /* We are being asked to serve other than TCP or UDP */
d284 1
a284 1
        (void) fprintf(stderr, "Usage: %s <IPv4-or-IPv6> <TCP-or-UDP> <Port>\n", argv[0]);
@


1.7
log
@Added debug infrastructure, assertions, fixed one bug.
@
text
@d35 1
d47 1
a47 1
    ASSERT(pszIn);
@


1.6
log
@Bug fixes, cleanup, and removed makefile redundancies (see end.)
@
text
@d36 2
d46 1
a46 2
/*    ASSERT(pszIn);*/
/*    ASSERT(*pszIn);*/
a63 2
/*    ASSERT(iSock);*/

a97 1
/*    ASSERT(iPort);*/
@


1.5
log
@Removed redundant call to memset for address structures.
@
text
@a29 2
#include <l2.h>

d92 1
a92 1
    struct sockaddr_in  laddr4,   faddr4,    CADDR4;
@


1.4
log
@Bug fixes to both IPv4 and IPv6 socket binding.
@
text
@d94 1
a94 1
    struct sockaddr_in  laddr4,   faddr4,    caddr4;
d105 1
a105 2
        /* initialize address structures */
        memset(&laddr6,  0, sizeof(laddr6));
d115 1
a115 2
        /* initialize address structures */
        memset(&laddr4,  0, sizeof(laddr4));
d160 1
a160 2
            /* initialize address structures */
            memset(&caddr6,  0, sizeof(caddr6));
d195 1
a195 2
            /* initialize address structures */
            memset(&caddr4,  0, sizeof(caddr4));
d239 1
a239 2
            /* initialize address structures */
            memset(&faddr6,  0, sizeof(faddr6));
d257 1
a257 2
            /* initialize address structures */
            memset(&faddr4,  0, sizeof(faddr4));
@


1.3
log
@The monitor can now server UDP sockets and IPv6 connections.
@
text
@d30 2
d105 4
d116 4
d162 4
d198 4
d243 4
d262 4
@


1.2
log
@Included logic to monitor IPv6 and UDP connections.
@
text
@d39 1
a39 1
char *strcasedup(const char *pszIn)
d91 6
a96 2
    struct sockaddr_in  laddr,    faddr;
    int                 iSock,    iNewsock, iSockopt, iProtofam;
d101 15
a115 3
    laddr.sin_family      = iFamily;
    laddr.sin_port        = iPort;
    laddr.sin_addr.s_addr = INADDR_ANY;
d117 3
a119 2
    iProtofam             = (iFamily == AF_INET) ? PF_INET : PF_INET6;
    iSock = socket(iProtofam, SOCK_STREAM, iProtocol);
d123 1
a123 1
        return (-1);
d132 16
a147 1
        return (-1);
d149 65
a213 4
    if (bind(iSock, (struct sockaddr *)&laddr, sizeof (laddr)) == -1) {
        perror("bind"); /* Bad bind */
        (void) close(iSock);
        return (-1);
a214 5
fprintf(stderr, "Listening on %d or 0x%x\n", iPort, iPort);
    if (listen(iSock, BACKLOG) == -1) {
        perror("listen"); /* Listen just blew up */
        (void) close(iSock);
        return (-1);
d216 36
a251 7
    /* Wait for a connection request. */
    for (;;) {
        faddrlen = sizeof (faddr);
        iNewsock = accept(iSock, (struct sockaddr *)&faddr, &faddrlen);
        if (iNewsock == -1) {
            if (errno != EINTR && errno != ECONNABORTED) {
                perror("accept");
a252 1
            continue;
d254 1
a254 2
        (void) printf("Connection from %s/%d\n", inet_ntoa(faddr.sin_addr), ntohs(faddr.sin_port));
        dowork(iNewsock); /* do some sockwork */
d256 2
a257 1
    /*NOTREACHED*/
d262 3
a264 4
    char *pszArgv = NULL;
    int iFamily   = -1;
    int iNetproto = -1;
    int iNetport  = 0;
d266 2
a267 2
    if (argc < 2) {
        (void) fprintf(stderr, "Usage: %s [IPv6] [UDP] <Port>\n", argv[0]);
d271 3
a273 6
    if ((pszArgv = strcasedup(*argv)) == NULL)
        return -1;

    iFamily    = (strstr(pszArgv, "ipv6")) ? AF_INET6    : AF_INET;
    iNetproto  = (strstr(pszArgv, "udp"))  ? IPPROTO_UDP : IPPROTO_TCP;
    iNetport   = htons(atoi(argv[argc - 1]));
d275 1
a275 2
    free (pszArgv);
    return myserver(iFamily, iNetproto, iNetport);
@


1.1
log
@Added socket monitoring tool for testing the socket channel handler.
@
text
@d39 1
a39 1
void do_work(int sock)
d41 20
a60 1
    char buf[BUFFSIZ];
d63 1
a63 1
/*    ASSERT(sock); */
d66 1
a66 1
        cc = read(sock, buf, sizeof (buf));
d74 1
a74 1
            (void) close(sock);
d79 2
a80 2
        buf[cc + 1] = '\0';
        (void) printf("Read: %s", buf);
d82 1
a82 1
        if (write(sock, buf, cc) == -1) {
d89 1
a89 1
int myserver(int port)
d91 3
a93 3
    struct sockaddr_in  laddr,   faddr             ;
    int                 sock,    new_sock, sock_opt;
    socklen_t           faddrlen                   ;
d95 1
a95 1
/*    ASSERT(port); */
d97 2
a98 2
    laddr.sin_family      = AF_INET;
    laddr.sin_port        = port;
a99 1
    sock                  = socket(PF_INET, SOCK_STREAM, 0);
d101 4
a104 1
    if (sock == -1) {
d110 3
a112 2
    sock_opt = 1;
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&sock_opt, sizeof (sock_opt)) == -1) {
d114 1
a114 1
        (void) close(sock);
d117 1
a117 1
    if (bind(sock, (struct sockaddr *)&laddr, sizeof (laddr)) == -1) {
d119 1
a119 1
        (void) close(sock);
d122 2
a123 1
    if (listen(sock, BACKLOG) == -1) {
d125 1
a125 1
        (void) close(sock);
d131 2
a132 2
        new_sock = accept(sock, (struct sockaddr *)&faddr, &faddrlen);
        if (new_sock == -1) {
d139 1
a139 1
        do_work(new_sock);  /* do some sockwork */
d146 7
a152 2
    if (argc != 2) {
        (void) fprintf(stderr, "Usage: %s <port>\n", argv[0]);
d155 10
a164 2
    (void) myserver(htons(atoi(argv[1])));
    return 0;
@