소켓으로 짜는 프로그램인데요...포크로..

아래의 기능을 포크를 이용해서 다시 만들고 있습니다.
처음 접속되고 나서 데이터가 한번은 잘 넘어갑니다.
그런데 연결된 상태에서 다시 한번 데이터를 넘기면

A에는 ******Broken pipe*****
B에는 *****recv error: Interrupted system call******

에러가 나서 두컴퓨터가 죽어버립니다.
어디가 문제인가요? 다시 한번 고수님들의 의견을 묻고 싶습니다.

#include <errno.h>       /* obligatory includes */
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <netdb.h>

#define PORTNUM 60001 /* random port number, we need something */
#define MAXHOSTNAME 20
#define MAXLINE 1024


int establish(unsigned short);
void fireman(void);
int get_connection(int s);
void do_something(int);
int read_save(int);

char command[256],option[256];
char rline[MAXLINE],my_msg[MAXLINE];

char client_ip[16]="";
int command_nflag,command_nsize,option_nflag,option_nsize,send_size;
int main()
{
        int s_fd,c_fd,clilen;
        struct sockaddr_in server_addr,client_addr;
        if ((s_fd= establish(PORTNUM)) < 0)     // socket() bind() listen()
        {
                perror("establish");
                exit(1);
        }
        clilen=sizeof(server_addr);
        sigset(SIGCHLD,fireman);                // this eliminates zombies
        if ((c_fd = accept(s_fd,(struct sockaddr *)&server_addr,&clilen)) < 0)
        {
                perror("accept");
                exit(1);
        }
        while(send_size=read_save(c_fd))                 // read and save
        {

                switch(fork()) {
                        case -1 :                               // fork error
                                perror("fork");
                                close(s_fd);
                                close(c_fd);
                                exit(1);
                        case 0 :                    // we're the child, do something
                                close(s_fd);
                                do_something(c_fd);
                                exit(0);
                        default :                     //  we're the parent so look for
                                close(c_fd);
                                continue;
                }
        }
}

int establish(unsigned short portnum)
{
        int    server_fd,client_fd;
        struct sockaddr_in server_addr;

        if ((server_fd= socket(AF_INET, SOCK_STREAM, 0)) < 0)           // create socket
        {
                perror("socket");
                exit(1);
        }

        bzero((char *)&server_addr,sizeof(server_addr));
        server_addr.sin_family= AF_INET;
        server_addr.sin_addr.s_addr=htonl(INADDR_ANY);           // server ip address
        server_addr.sin_port= htons(portnum);// this is portnumber

        if (bind(server_fd,(struct sockaddr *)&server_addr,sizeof(struct sockaddr_in)) < 0)
        {
                close(server_fd);
                return(-1);                            // bind address to socket
        }

        if(listen(server_fd, 3)<0)              // listen
        {
                perror("listen");
                exit(1);
        }
        return(server_fd);
}

// as children die we should get catch their returns or else we get
// zombies, A Bad Thing.  fireman() catches falling children.
//
void fireman(void)
{
        while (waitpid(-1, NULL, WNOHANG) > 0);
}



// this is the function that plays with the socket.  it will be called
// after getting a connection.
//
void do_something(int s)
{
        int ser_cli_fd;
        struct sockaddr_in name_addr;
        if((ser_cli_fd=socket(AF_INET,SOCK_STREAM,0))<0)
        {
                perror("socket");
                exit(1);
        }

        bzero((char *)&name_addr,sizeof(name_addr));
        name_addr.sin_family=AF_INET;
        name_addr.sin_addr.s_addr=inet_addr(client_ip);
        name_addr.sin_port=htons(atoi("60003"));           

        if(connect(ser_cli_fd,(struct sockaddr *)&name_addr,sizeof(struct sockaddr_in))<0)
        {
                printf("Connect failed server_ip: %s\n",client_ip);
                exit(1);
        }

        if(send(ser_cli_fd,rline,send_size,0)<0)
        {
                perror("send error");
                exit(1);
        }
}

int read_save(int t_fd)
{
        int recv_size,ip_nflag,ip_nsize;
        if((recv_size=recv((int)t_fd,rline,MAXLINE,0)) <= 0)
        {
                perror("recv error");
                exit(1);
        }
        memcpy(&command_nflag,rline,4);
        memcpy(&command_nsize,rline+4,4);
        memcpy(command,rline+8,command_nsize);
        memcpy(&option_nflag,rline+sizeof(int)*2 + command_nsize,4);
        memcpy(&option_nsize,rline+sizeof(int)*3 + command_nsize,4);
        memcpy(option,rline+sizeof(int)*4 + command_nsize,option_nsize);
        send_size=sizeof(int)*4 + command_nsize + option_nsize;

        memcpy(&ip_nflag,rline,4);
        memcpy(&ip_nsize,rline + send_size ,4);
        memcpy(client_ip,rline + send_size + sizeof(int),ip_nsize);
        printf("destination server_ip: %s\n",client_ip);        

        return(send_size);
}