Return to tcp.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lrzsz / src

Annotation of embedaddon/lrzsz/src/tcp.c, revision 1.1

1.1     ! misho       1: /*
        !             2:   tcp.c - tcp handling for lrzsz
        !             3:   Copyright (C) 1997 Uwe Ohse
        !             4: 
        !             5:   This program is free software; you can redistribute it and/or modify
        !             6:   it under the terms of the GNU General Public License as published by
        !             7:   the Free Software Foundation; either version 2, or (at your option)
        !             8:   any later version.
        !             9: 
        !            10:   This program is distributed in the hope that it will be useful,
        !            11:   but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            12:   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            13:   GNU General Public License for more details.
        !            14: 
        !            15:   You should have received a copy of the GNU General Public License
        !            16:   along with this program; if not, write to the Free Software
        !            17:   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
        !            18:   02111-1307, USA.
        !            19: 
        !            20:   originally written by Uwe Ohse
        !            21: */
        !            22: 
        !            23: #include "config.h"
        !            24: 
        !            25: #include <sys/types.h>
        !            26: #include <sys/socket.h>
        !            27: #include <netinet/in.h>
        !            28: #include <netdb.h>
        !            29: #ifdef HAVE_ARPA_INET_H
        !            30: #include <arpa/inet.h>
        !            31: #endif
        !            32: #include <errno.h>
        !            33: #include <ctype.h>
        !            34: #include <stdio.h>
        !            35: #include <signal.h>
        !            36: 
        !            37: #include "zglobal.h"
        !            38: #include <stdlib.h>
        !            39: #include "error.h"
        !            40: 
        !            41: static RETSIGTYPE
        !            42: tcp_alarm_handler(int dummy LRZSZ_ATTRIB_UNUSED)
        !            43: {
        !            44:     /* doesn't need to do anything */
        !            45: }
        !            46: 
        !            47: 
        !            48: /* server/lsz:
        !            49:  * Get a TCP socket, bind it, listen, figure out the port,
        !            50:  * and build the magic string for lrz in "buf".
        !            51:  */
        !            52: int 
        !            53: tcp_server (char *buf)
        !            54: {
        !            55:        int sock;
        !            56:        struct sockaddr_in s;
        !            57:        struct sockaddr_in t;
        !            58:        int on=1;
        !            59:        size_t len;
        !            60: 
        !            61:        if ((sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        !            62:                error(1,errno,"socket");
        !            63:        }
        !            64:        if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof (on)) < 0) {
        !            65:                error(1,errno,"setsockopt (reuse address)");
        !            66:        }
        !            67:        memset (&s, 0, sizeof (s));
        !            68:        s.sin_family = AF_INET;
        !            69:        s.sin_port=0; /* let system fill it in */
        !            70:        s.sin_addr.s_addr=htonl(INADDR_ANY);
        !            71:        if (bind(sock, (struct sockaddr *)&s, sizeof (s)) < 0) {
        !            72:                error(1,errno,"bind");
        !            73:        }
        !            74:        len=sizeof(t);
        !            75:        if (getsockname (sock, (struct sockaddr *) &t, &len)) {
        !            76:                error(1,errno,"getsockname");
        !            77:        }
        !            78:        sprintf(buf,"[%s] <%d>\n",inet_ntoa(t.sin_addr),ntohs(t.sin_port));
        !            79: 
        !            80:        if (listen(sock, 1) < 0) {
        !            81:                error(1,errno,"listen");
        !            82:        }
        !            83:        getsockname (sock, (struct sockaddr *) &t, &len);
        !            84: 
        !            85:        return (sock);
        !            86: }
        !            87: 
        !            88: /* server/lsz: accept a connection */
        !            89: int 
        !            90: tcp_accept (int d)
        !            91: {
        !            92:        int so;
        !            93:        struct  sockaddr_in s;
        !            94:        size_t namelen;
        !            95:        int num=0;
        !            96: 
        !            97:        namelen = sizeof(s);
        !            98:        memset((char*)&s,0, namelen);
        !            99: 
        !           100: retry:
        !           101:        signal(SIGALRM, tcp_alarm_handler);
        !           102:        alarm(30);
        !           103:        if ((so = accept(d, (struct sockaddr*)&s, &namelen)) < 0) {
        !           104:                if (errno == EINTR) {
        !           105:                        if (++num<=5)
        !           106:                                goto retry;
        !           107:                }
        !           108:                error(1,errno,"accept");
        !           109:        }
        !           110:        alarm(0);
        !           111:        return so;
        !           112: }
        !           113: 
        !           114: /* client/lrz:
        !           115:  * "Connect" to the TCP socket decribed in "buf" and
        !           116:  * return the connected socket.
        !           117:  */
        !           118: int 
        !           119: tcp_connect (char *buf)
        !           120: {
        !           121:        int sock;
        !           122:        struct sockaddr_in s_in;
        !           123:        char *p;
        !           124:        char *q;
        !           125: 
        !           126:        memset(&s_in,0,sizeof(s_in));
        !           127:        s_in.sin_family = AF_INET;
        !           128: 
        !           129:        /* i _really_ distrust scanf & co. Or maybe i distrust bad input */
        !           130:        if (*buf!='[') {
        !           131:                error(1,0,_("tcp_connect: illegal format1\n"));
        !           132:        }
        !           133:        p=strchr(buf+1,']');
        !           134:        if (!p) {
        !           135:                error(1,0,_("tcp_connect: illegal format2\n"));
        !           136:        }
        !           137:        *p++=0;
        !           138:        s_in.sin_addr.s_addr=inet_addr(buf+1);
        !           139: #ifndef INADDR_NONE
        !           140: #define INADDR_NONE (-1)
        !           141: #endif
        !           142:        if (s_in.sin_addr.s_addr== (unsigned long) INADDR_NONE) {
        !           143:                struct hostent *h=gethostbyname(buf+1);
        !           144:                if (!h)
        !           145:                        error(1,0,_("tcp_connect: illegal format3\n"));
        !           146:                memcpy(& s_in.sin_addr.s_addr,h->h_addr,h->h_length);
        !           147:        }
        !           148:        while (isspace((unsigned char)(*p)))
        !           149:                p++;
        !           150:        if (*p!='<') {
        !           151:                error(1,0,_("tcp_connect: illegal format4\n"));
        !           152:        }
        !           153:        q=strchr(p+1,'>');
        !           154:        if (!q)
        !           155:                error(1,0,_("tcp_connect: illegal format5\n"));
        !           156:        s_in.sin_port = htons(strtol(p+1,NULL,10));
        !           157: 
        !           158:        if ((sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
        !           159:                error(1,errno,"socket");
        !           160:        }
        !           161: 
        !           162:        signal(SIGALRM, tcp_alarm_handler);
        !           163:        alarm(30);
        !           164:        if (connect (sock, (struct sockaddr *) &s_in, sizeof (s_in)) < 0) {
        !           165:                error(1,errno,"connect");
        !           166:        }
        !           167:        alarm(0);
        !           168:        return (sock);
        !           169: }