TCP socket Programming instance code for Windows and Linux

The code under Windows is as follows

Server.cpp #include  <iostream> #include  <windows.h> #define  IP  "127.0.0.1" #
define port 8888 #pragma  comment (lib, "Ws2_32.lib") using namespace std;
Char* gettime (); Int main () {    WSADATA wsaData;     WORD Ret;      if  ((Ret = wsastartup (Makeword (2, 2),  &wsadata)  != 0) )     {        cout <<  "WSAStartup (
)  error whit: " << Ret << endl;
        wsacleanup ();
        return -1;
    }//the unified version type.
    SOCKET sockSer, sockCli;
    sockser = socket (af_inet,sock_stream,0);
    SOCKADDR_IN addrSer, addrCli;     addrser.sin_family = af_inet;
    addrser.sin_port = htons (port);     addrser.sin_addr. S_un.
S_ADDR = INET_ADDR (IP);
    int len = sizeof (SOCKADDR);
    bind (sockser,  (sockaddr*) &addrser, len);//bind socket.
    listen (sockser,5)/monitor.
    cout <<  "The server is waiting for a connection ..."  << endl;
    sockcli = accept (sockser,  (sockaddr*) &addrcli, &len);     if  (sockcli == -1)     {         cout <<  "Accept ()  error with:"  << sockcli
 << endl;
        closesocket (SOCKCLI);
        closesocket (Sockser);         wsacleanup ();
    }     char serbuff[255];
    string s;     while  (1)     {       
 recv (Sockcli,serbuff,sizeof (Serbuff), 0);
        send (Sockcli,gettime (), 30, 0);
    }     wsacleanup ();
    closesocket (Sockser);
    closesocket (SOCKCLI);
    return 0; } char* gettime () {    char buff[255];     systemtime sys
;//windows the following system time call.
    getlocaltime (&sys);//Initialize local time.     sprintf (Buff, "%d:%d:%d:%d:%d:%d", Sys.wyear,sys.wmonth,sys.wday,sys.whour,sys.wminute,
Sys.wsecond);
    return buff; }

Client.cpp #include  <iostream> #include  <windows.h> #define  PORT 8888 #define
 IP  "127.0.0.1" using namespace std; #pragma  comment (lib, "Ws2_32.lib") Int main () {    DWORD Ret;   
  WSAData wsaData;     if  ((Ret = wsastartup (Makeword (2, 2),  &wsadata)  !=  0)     {        cout << "WSAStartup
()  Error Wiht :  "<< Ret << endl;
        wsacleanup ();
        return -1;    &NBSP}     socket sockcli = socket (AF_INET,SOCK_STREAM,0)
;
    SOCKADDR_IN addrSer;
    addrSer.sin_family = AF_INET;     addrser.sin_port = htons (port);     addrser.sin_addr. S_un.
S_ADDR = INET_ADDR (IP);
    //does not require binding monitoring.
    int ret = connect (SOCKCLI, (sockaddr*) &addrser,sizeof (SOCKADDR));     if  (ret != 0)     {     
   cout <<  "Client Connection failed ..."  << endl;
        closesocket (SOCKCLI);
        wsacleanup ();
        return -1;    &NBSP}     else     {     
   cout <<  "Customer service side Connection successful ..."  << endl;
   &NBSP}     const char timebuff[] =  "Times:";
    char serbuff[255];     while  (1)     {        send (
Sockcli,timebuff,strlen (Timebuff) +1,0);
        recv (Sockcli,serbuff,sizeof (Serbuff), 0);
        //gets the local time of the server.         cout <<timebuff<<serbuff << 
Endl
        sleep (2000);
    }     return 0; }

The following code for Linux is as follows:

Makefile

CLI=CLI
ser=ser
dir=.
cc=g++
ser_obj=$ (dir)/ser.o
cli_obj=$ (dir)/cli.o ser_src=$
(dir)/ser.cpp cli_src=$
(dir)/cli.cpp
all:$ (CLI) $ (SER)
. Phony:all
$ (SER): $ (ser_obj)
@$ (cc)-O $@ $^
$ (CLI): $ (cli_obj)
@$ (cc)-O $@ $^
$ (ser_obj): $ (SER_SRC)
@$ (cc)-C $<
$ (cli_obj): $ (CLI_SRC)
@$ (cc)-C $<
. Phony:clean clean
:
@rm $ (DIR)/*.O $ (SER) $ (CLI)

Ser.cpp

#include  <iostream> #include  <sys/socket.h> #include  <arpa/inet.h> #include  <string.h> #include  <netinet/in.h> #define  port 8888 #define  IP  "
127.0.0.1 "using namespace std; Int main () {    int sockSer,sockCli;     sockaddr_in 
ADDRSER,ADDRCLI;
    sockser =  socket (af_inet,sock_stream,0);
    addrSer.sin_family = AF_INET;
    addrser.sin_port = htons (port);
    ADDRSER.SIN_ADDR.S_ADDR = INET_ADDR (IP);
    socklen_t len = sizeof (SOCKADDR);
    bind (Sockser, (sockaddr*) &addrser,len);
    listen (sockser,5);
    cout<< "I am waiting ..." <<endl;     sockcli = accept (Sockser, Sockaddr*) &addrcli,&len);     if (sockcli==-1)     {    close (sockSer);  
   close (SOCKCLI);
    return -1;
    }     char clibuff[255];     while (1)     {        recv (
Sockcli,clibuff,sizeof (Clibuff), 0);
        cout<<clibuff<<endl;         if (strncmp ("Quit", clibuff,4) ==0)          {        cout<< "I am quit too!"
<<endl;
        break;        &NBSP}         send (SockCli, Clibuff,strlen (Clibuff) +1,0);       }   &nBsp; close (SOCKCLI);
    close (Sockser);
    return 0; }

//cli.cpp

#include  <iostream> #include  <string.h> #include  <sys/socket.h> #include  
<netinet/in.h> #include  <arpa/inet.h> using namespace std; #define  PORT 8888 #define  IP  "127.0.0.1" Int main () {    int 
Sockcli = socket (af_inet,sock_stream,0);
    sockaddr_in addrSer;
    addrSer.sin_family = AF_INET;
    addrser.sin_port = htons (port);
    ADDRSER.SIN_ADDR.S_ADDR = INET_ADDR (IP);
    socklen_t len = sizeof (SOCKADDR);
    int ret = connect (SOCKCLI, (sockaddr*) &addrser,len);     if (ret!=0)     {    cout<< "Connect ()
 erorr with : "<<ret<<endl;
    close (SOCKCLI);     return -1;
    }     char serbuff[255];     while (1)     {       cin>>
Serbuff;
       send (Sockcli,serbuff,strlen (Serbuff) +1,0);        if (strncmp ("Quit", serbuff,4) ==0)          {        break;        
&NBSP}        memset (Serbuff, ' a ', sizeof (Serbuff));    
   &NBSP}     close (SOCKCLI);
    return 0; }

Linux-based TCP network programming

A. Linux under the TCP programming framework

The process of programming a TCP network consists of two modes of server and client. Server mode creates a service program that waits for the client user's connection, receives the user's connection request, and processes it according to the user's request; The client mode connects to the destination server's address and port, sends the request to the server, and processes the server's response.

1. Server-side programs include

Ø set up socket (socket ())

Ø Sockets and Port bindings (BIND ())

Ø set the server's listening connection (listen ())

Ø Receive Client connection (accept ())

Ø Receive and send data (send (), recv ())

Ø closing sockets (Close ())

2. Notes

In the 1> socket initialization process, the options for sockets are determined based on the user's need for sockets. The socket () function is set according to the user-defined network type, protocol type and specific protocol label parameters. The system generates a socket file descriptor for users to use, depending on the needs of the user.

2> sockets are bound to an address structure during the binding process of a socket to a port. After binding, parameters such as IP address and port address and protocol type that the socket represents are manipulated according to the binding value.

3> because a server needs to meet multiple client connection requests, and the server can handle only a limited number of client connection requests at a time, the server needs to set the length of the server-side queued queues.

4> after the client sends a connection request, the server needs to receive the client's connection before other processing can take place.

5> you can read data from a socket file descriptor or send data to a file descriptor after the server receives a client request. After receiving the data, the server processes the data according to the defined rules and sends the results to the client.

6> when the server is finished processing data, to end the communication process with the client, you need to turn off the socket connection

2. Client programs include

Ø set up socket (socket ())

Ø Connecting server (Connect ())

Ø Read and write network data (send (), recv ())

Ø closing sockets (Close ())

3. Server-side and client program differences

The difference between a client program and a server-side program is that the client can connect to the server side instead of the address binding after the socket is established.

There are listen () and accept () two functions on the server side, and the client does not need these two functions.

Two. Linux based TCP socket function

1. Socket

1> function Prototype:

int socket (int domain,int type,int protocol)

2> function Function:

The function socket () is used to create a socket descriptor.

3> Parameters:

Ødomain: Specifies the protocol family to use for creating sockets, in header files

Defined in. Sometimes the pf_inet is used in the program, and the Af_inet and pf_inet values are the same in the header file.

The common protocol families are as follows:

Af_unix: Creates a socket that communicates only within the machine.

Af_inet: Using the IPV4TCP/IP protocol

AF_INET6: Using the IPV6 TCP/IP protocol

Description

Af_unix can only be used for single UNIX system interprocess communication, while Af_inet is for interne and thus allows communication between remote hosts. It is generally assigned to af_inet.

Øtype: Specifies the type of socket communication, corresponding to the following parameters

Sock_stream: Creating a TCP stream socket

Sock_dgram: Creating a UDP datagram socket

Sock_raw: Create original socket

Øprotocol: Specifies a specific type of protocol

The parameter protocol is typically set to 0, which indicates the protocol used to determine the socket type specified by the protocol family and parameter type specified in parameter domain. When you are a raw socket, the system cannot uniquely determine the protocol, and you need to use this parameter to specify the protocol used.

4> return value: Returns a newly created socket after successful execution, and returns one-1 if an error occurs, and the error code is stored in errno.

5> Example: Call the socket function to create a UDP socket

int sock_fd;
SOCK_FD = socket (af_inet,sock_dgram,0);
if (sock_fd< 0) {
perror ("socket");
Exit (1);
}

2. Bind

1> function Prototype:

int bind (int sockfd,struct sockaddr *my_addr,socklen_t addrlen)

2> function function

The function bind () binds a socket file descriptor to the address and port.

3> Parameters:

ØSOCKFD:SOCKFD is the file descriptor that invokes the return of the socket function;

Øaddrlen is the length of the SOCKADDR structure.

ØMY_ADDR: is a pointer to the SOCKADDR structure that holds the address of the local socket (that is, the port and IP address) information. However, due to system compatibility problems, this structure is not used in general, and another structure (STRUCTSOCKADDR_IN) is used instead

4> Socket Address Structure:

(1) struct sockaddr:

The structure struct SOCKADDR defines a generic socket address that is

Defined in Sys/socket.h.

struct sockaddr{

unsigned short sa_family;/* address type, af_xxx*/

char sa_data[14];/*14 byte protocol address */
  }

A. Sin_family: Represents the address type, and for network programming using the TCP/IP protocol, this value can only be af_inet.

B. Sa_data: Store the specific protocol address.

(2) sockaddr_in

Each protocol family has its own protocol address format, and the TCP/IP protocol group address format is a struct struct sockaddr_in, which is defined in the Netinet/in.h header file.

structsockaddr_in{

unsigned short sin_family;/* address type * *

unsigned short sin_port;/* port number/

struct IN_ADD R SIN_ADDR;/*IP Address */

unsigned char sin_zero[8];/* padding byte, general assignment to 0*/

}

A. Sin_family: Represents the address type, and for network programming using the TCP/IP protocol, this value can only be af_inet.

B. Sin_port: is the port number

C. SIN_ADDR: Used to store 32-bit IP addresses.

D. Array Sin_zero is a filled field with a general assignment of 0.

E. struct IN_ADDR is defined as follows:

structin_addr{
unsigned long s_addr;
}

The length of the structure body sockaddr is 16 bytes, and the sockaddr_in length of the structure is 16 bytes. You can set the parameter my_addr sin_addr to Inaddr_any instead of a certain IP address to bind to any network interface. For a computer with only one IP address, inaddr_any corresponds to its IP address; for multihomed hosts (with multiple network adapters), Inaddr_any indicates that the server program will process connection requests from the corresponding ports on all network interfaces

5> return Value:

The function returns 0 when a failure occurs, and 1 when there is an error, and the error code is stored in errno.

6> Example: Call the socket function to create a UDP socket

struct SOCKADDR_IN addr_serv,addr_client;/* Local address information * *
memset (&serv_addr,0,sizeof (structsockaddr_in));
addr_serv.sin_family= af_inet;/* Protocol Family * *
addr_serv.sin_port= htons (serv_port);//Local port number/*
Addr_serv.sin_ Addr.s_addr= htonl (Inaddr_any);
//////////////////////////* Socket binding/if (Bind (SOCK_FD, structsockaddr *) &addr_serv), sizeof (struct sockaddr_in))       
{
perror ("bind");
Exit (1);
}

3. Monitor local port Listen ()

1> function function: function listen () is used to initialize the server to connect the queue, the server processing client connection request is sequential processing, at the same time can only handle a client connection. When multiple client connection requests arrive at the same time, the server is not processed concurrently, but the client connection request that cannot be processed is placed in the wait queue, which is defined by the listen () function.

2> function Prototype:

#includ
int Listen (int sockfd,int backlog);

3> Formal parameters

ØSOCKFD:SOCKFD is the file descriptor returned by calling the socket function

Øbacklog: Specifies the maximum length of the connection queue. If the connection queue has reached its maximum, subsequent connection requests are rejected by the server. Most systems are set to 20 and can be modified to 5 or 10, depending on the system's affordability or application requirements.

4> return value: When the Listen () function runs successfully, the return value is 0, and when the run fails, its return value is-1, and the error code is stored in errno.

Example of the 5>.listen () function:

 #define  SERV_PORT 3000 Int main (int argc,char * Argv[]) {int sock_fd; struct sockaddr_in addr_serv,addr_client;/* Local address information * * sock_fd = 
Socket (af_inet,sock_dgram,0); if (sock_fd< 0) {       perror ("socket");     
   exit (1);
} memset (&serv_addr,0,sizeof (structsockaddr_in)); addr_serv.sin_family= af_inet;/* Protocol Family/Addr_serv.sin_port= htons (serv_port);/* Local Port number */Addr_serv.sin_ Addr.s_addr= htonl (inaddr_any);  /* any local address/* socket binding////if (Bind Sock_fd, (structsockaddr *) &addr_
Serv), sizeof (struct sockaddr_in))  <0) {       perror ("bind");
       exit (1);
}//Set the length of the server listening queue if (Listen (sock_fd,5)  <0) {       perror ("listen");
       exit (1); }

4. Accept (receive a network request)

1> function Function:

When a client's connection request reaches the port on which the server host listens, the client's connection waits in the queue, knowing that the server handles the receive request.

After the function accept () is successfully executed, a new set of interface file descriptors is returned to indicate the client's connection, and the client connection information can be obtained by this new descriptor. As a result, when the server successfully processes the client's request connection, there will be two file descriptors, the old file descriptor representing the client's connection, and the function send () and recv () to send and receive data through the new file descriptor.

2> function Prototype:

#include
#include
int accept (int sock_fd,struct sockaddr*addr,socklen_t *addrlen);

3> Formal parameters

ØSOCK_FD: A listening socket that is created by a function socket, bound to a local port by a function bind, and then transformed by a function listen.

ØADDR: The address and port used to hold the host that initiated the connection request.

Øaddrlen is the size of the structure that the addr points to.

4> return value: The return value of the Accept () function is a newly connected client socket file descriptor that communicates with the client through a new socket file descriptor returned by accept (), rather than by a file descriptor when the socket is established. If an error occurs in the Accept () function, accept () returns-1, and the error value can be obtained by errno.

5> if the socket specified by the parameter sock_fd is set to block (default mode under Linux), and the connection request queue is empty, accept () is blocked until there is a connection request, and if the socket specified by parameter s is set to non-blocking, if the queue is empty, Accept will immediately return -1,errno is set to Eagain.

6> instance:

int client_fd;
int Client_len;
struct sockaddr_in client_addr;
Client_len = sizeof (struct sockaddr_in);
CLIENT_FD = Accept (sock_fd, (struct sockaddr *) &client_addr,&client_len);
if (conn_fd< 0) {
perror ("accept");
Exit (1);
}

5. Connect (Connect target network server)

1> function Function:

After a socket is established, the client can connect directly to the server without the need for address binding. The function to connect to the server is connect (), which connects the server with the specified parameters, such as IP address, port number.

In the case of TCP programming, the Connect () function is used for the server to issue a connection request, and the server's IP address and port number are specified by the parameter serv_addr.

In the case of UDP programming, the Connect function does not establish a true connection, it simply tells the kernel the destination address (specified by the second parameter) that communicates with the socket, and only data sent from that destination address is received by that socket. The advantage of calling the Connect function is that you do not have to specify the destination address each time you send and receive data.

2> function Prototype:

#include
#include
int connect (int sock_fd,struct sockaddr *serv_addr,socklen_taddrlen);

3> Parameters:

ØSOCK_FD: The socket file descriptor that is returned when the socket is established, calling the socket () returned.

ØSERV_ADDR: is a pointer to the data structure sockaddr, which includes the destination IP address and port number of the server to which the client needs to connect.

Øaddrlen: Indicates the size of the second parameter, you can use sizeof (struct sockaddr)

4> after successful execution returns 0, error occurs return-1, error code is stored in errno.

5> instance:

int sock_fd;
struct sockaddr_in serv_addr;
if ( -1 = = (SOCK_FD = = socket (af_inet,sock_stream,0)) {
printf ("Error:unable to Createsocket (%i) ... \ n", errno);
Perror ("sockets");
Exit (1);
}
memset (&serv_addr,0,sizeof (structsockaddr_in));
serv_addr.sin_family= af_inet;
serv_addr.sin_port= htons (dest_port);
Serv_addr.sin_addr.s_addr= inet (dest_ip_address);
if ( -1== connect (sock_fd, struct sockaddr *) &serv_add,sizeof (struct
sockaddr)) {
printf ("Error: Unable to the establishconnection to socket (%i) ... \ n ", errno);
Perror ("socks");
Close (SOCK_FD);
Exit (1);
}

6. Send (sending data)

1> function: The function send is used to send data on a TCP socket, and send can be used only for sockets that are in a connected state.

2> function prototype

#include
#include
ssize_t send (int conn_fd,const void *msg,size_t len, int flags);

3> function Parameters:

ØCONN_FD: A socket descriptor that is returned after the Accept () function is invoked for a socket descriptor that has already been established.

Ømsg: A buffer that holds the data sent.

Ølen: The length of the send buffer

Øflags: For control options, generally set to 0, or take the following values:

²msg_oob: To send Out-of-band data (Out-of-band data) on a specified socket, a socket of that type must support Out-of-band data (such as: Sock_stream).

²msg_dontroute: Sends data through the most direct path, ignoring routing settings for downlevel protocols.

4> return Value:

The execution returns the number of bytes that actually sent the data, and an error returns-1, and the error code is stored in errno.

Execution success simply indicates that the data is written to the socket in a buffer and does not indicate that the data has been successfully sent over the network to the destination.

5> instance:

#define BUFFERSIZE 1500
char send_buf[buffersize];
..... if (send (conn_fd,send_buf,len,0) < 0) {
perror ("send");
Exit (1);
}

7. recv (Receive data)

1> function: recv () is used to receive data on a TCP socket. function recv receives data from the specified socket descriptor and saves it to the specified buf.

2> function prototype

#include
#include
ssize_t recv (int conn_fd,void *buf,size_t len,int flags);

3> function Parameters:

ØCONN_FD: The socket descriptor that is returned after the Accept () function is invoked for a socket descriptor that has already been established.

ØBUF: Receive Buffer

Ølen: The size of the receive buffer

Øflags: For control options, generally set to 0 or take the following values

²msg_oob: Request to receive Out-of-band data

²msg_peek: View data only and not read

²msg_waitall: Returns only when the receive buffer is full.

4> function return value

The function execution successfully returns the number of data bytes received, Error returns 1, and the error code is stored in errno.

5> instance:

#define BUFFERSIZE 1500
char recv_buf[buffersize];
..... if (recv (conn_fd,recv_buf,sizeof (RECV_BUF), 0) < 0) {
perror ("recv");
Exit (1);
}

8. Close

1> function Prototype:

int close (int fd);

2> function Function:

Function Close is used to turn off a socket descriptor.

3> function Parameters:

Ø parameter FD is a socket descriptor.

4> return Value:

Execution successfully returns 0, error returns-1. The error code is stored in errno.

Description: The header file for the close () function is #include.

Three. Linux based TCP socket programming instance

1. The instance program is divided into the server side and the client, the client sends Hello Tigerjibo to the server side, and the total number of strings received is sent to the client after the server receives the string;

2. Server-side programs:

  1  #include <stdio.h>   2  #include <stdlib.h>   3 # include<string.h>   4  #include <errno.h>   5    6     7  #include <sys/types.h>   8  #include <sys/socket.h>   9 # Include<unistd.h>//close ()  10  #include <netinet/in.h>//struct sockaddr_in  11   #include <arpa/inet.h>//inet_ntoa  12  #define   QUEUE_LINE  12  13   #define   SOURCE_PORT 8000  14   15  #define   source_ip_address   "192.168.1.6"  16   17 void process_info (int s)  18 { 19 
        int recv_num;
 20         int send_num;  21         char recv_BUF[50];
 22         char send_buf[50];  23         while (1) { 24     
            printf ("begin recv:\n");  25                 
Recv_num = recv (S,recv_buf,sizeof (RECV_BUF), 0);  26                  if (recv_num <0) { 27             
            perror ("recv");  28                 
        exit (1);  29                  } else { 30                      
    recv_buf[recv_num] =  ';  31                 
        printf ("recv sucessful:%s\n", recv_buf);  32                  }  33                
 sprintf (Send_buf, "recv %d numbers bytes\n", recv_num);  34                 
printf ("begin send\n");  35                 send_num = send (S,send_buf,sizeof (SEND_BUF), 0);  36                  if  (send_num < 0) { 37           
              perror ("sned");  38                 
        exit (1);  39                  } else { 40              
           printf ("send sucess\n");  41                  }  42        &NBSP}  43&nbsp}  44 int main ()  45  { 46         int sock_fd,conn_fd;  47 
        int client_len;
 48         pid_t pid;  49         struct sockaddr_in addr_serv,addr_
Client  50         sock_fd = socket (AF_INET,SOCK_STREAM,0
);  51         if (sock_fd < 0) { 52                  perror ("Socket
");  53                 
Exit (1);  54         } else { 55              
   printf ("sock sucessful\n");  56         }  57          //initializes the server-side address  58         memset (&addr_
Serv,0,sizeof (Addr_serv));
 59         addr_serv.sin_family = AF_INET;  60         addr_serv.sin_port = htons (SOURCE_PORT
);  61         ADDR_SERV.SIN_ADDR.S_ADDR =INET_ADDR (SOURCE
_ip_address);  62         client_len = sizeof (struct 
SOCKADDR_IN);  63         if (Bind (SOCK_FD, struct sockaddr *) &addr_serv,sizeof (Struct sockaddr_in) <0) { 64             
    perror ("bind");  65                 
Exit (1);  66         } else { 67                  printf ("bind sucess\n
");  68         }  69          if  (Listen (sock_fd,queue_line)  < 0) { 70     
            perror ("Listen");  71                 
Exit (1);  72         } else {&Nbsp;73                 
printf ("listen sucessful\n");  74         }  75          while (1) { 76            
      printf ("begin accept:\n");  77                 
 conn_fd = accept (SOCK_FD, (struct sockaddr *) &addr_client,&client_len);  78                   if (conn_fd < 0) { 79           
              perror ("accept");  80                       
  exit (1);  81                   }  82               
   printf ("accept a new client,ip:%s\n", Inet_ntoa (ADDR_CLIENT.SIN_ADDR));  83                 
 pid = fork ();  84                   if (0 == pid) {         //subprocess  85                           close (SOCK_FD);//Shut down the server's listening in the child process  86                          process_info (CONN_FD)//Processing information  87                   } else { 88                           close (CONN_FD);//Shut down the client's connection in the parent process  89                   }  90          }  91   92 }

3. Client program:

  1  #include <stdio.h>   2  #include <string.h>   3 # include<stdlib.h>   4  #include <errno.h>   5    6 # include<sys/types.h>   7  #include <sys/socket.h>   8  #include < Unistd.h>//close ()   9  #include <netinet/in.h>//struct sockaddr_in  10 # Include<arpa/inet.h>//inet_ntoa  11   12  #define  DEST_PORT 8000  13   #define  DEST_IP_ADDRESS  "192.168.1.6"  14   15 /* Client processing process * *  16  Void process_info (int s)  17 { 18        
 int send_num;
 19         int recv_num;
 20         char send_buf[]= "Tigerjibo";  21         char recv_buf[50];  22         while (1) { 23     
            printf ("begin send\n");  24                 
Send_num = send (S,send_buf,sizeof (SEND_BUF), 0);  25                  if  (send_num < 0) { 26           
              perror ("send");  27                 
        exit (1);  28                 } else { 29                          printf ("send 
Sucess:%s\n ", send_buf);  30                  }  31                
 printf ("begin recv:\n");  32                 
Recv_num = recv (S,recv_buf,sizeof (RECV_BUF), 0);  33                  if (recv_num < 0) { 34            
             perror ("recv");  35                     
    exit (1);  36                  } else { 37              
           recv_buf[recv_num]= ' ";  38                 
        printf ("recv sucess:%s\n", recv_buf);  39                   40        &NBSP}  41 }  42 int main (int  argc,char *argv[])  43 { 44         int  sock_fd;
 45         struct sockaddr_in addr_serv;//Server-side address  46   47         sock_fd = socket (AF_INET
, sock_stream,0);  48         if (sock_fd < 0) { 49                  perror ("sock")
;  50                 
Exit (1);  51         } else { 52                  printf ("sock 
Sucessful:\n ");  53         }  54      
   memset (&addr_serv,0,sizeof (Addr_serv));  55         addr_serv.sin_family = af_inet;  56         addr_serv.sin_port =  htons (DEST_
PORT);  57         ADDR_SERV.SIN_ADDR.S_ADDR = INET_ADDR (
dest_ip_address);  58        if ( connect) (SOCK_FD, (struct sockaddr *) &addr_serv,sizeof (STRUCT SOCKADDR))  < 0) { 59      
           perror ("Connect");  60                 
printf ("connect  (%d) \ n", errno);  61                 
Exit (1);  62        } else { 63    &NBsp;            printf ("connect sucessful\n");  64        }  65       
  process_info (SOCK_FD);
 66         close (SOCK_FD);  67 }