BSD Socket in iPhone Development

IPhone DevelopmentMediumBSD SocketEasy Learning is the content to be introduced in this article, mainly to learnIphone DevelopmentThread learning. In progressIphone DevelopmentCommunication programs must be usedSocketCommunication, except for the CFSocketIn addition to class interfaces, we can alsoBSD SocketThis article briefly introduces how to develop communication programs.BSD SocketI think it is a good entry-level article, so I will share it on the blog:

When you enter the mysterious world of UNIX, you will immediately find more and more things hard to understand. For most people, BSD (Berkeley Software Distribution, Berkeley Software suite is a Unix derivative system developed and released by UC Berkeley between 1977 and 1995) socket is one of them. This is a very short tutorial to explain what they are, how they work, and give some simple code to explain how to use them.

Analogy (what is socket ?)

Socket is a BSD Method for inter-program communication (IPC, Internet Process Connection. This means that the socket is used to allow a process to communicate with other processes, just as we communicate with others by phone.

It is quite appropriate to use telephone to describe socket in the future.

Install your new phone number (how to listen ?)

To receive a call from someone else, first install a call. Similarly, you must first establish a socket to listen on the line. This process involves several steps. First, you need to create a new socket, just like installing a phone number first. The socket () command is used to complete this task.

Because sockets has several types, you need to specify the type you want to establish. You need to select the socket address format. Just as the telephone has two forms of audio and pulse, socket has two most important options: AF_UNIX and IAF_INET. AF_UNIX recognizes sockets like UNIX pathnames. This form is useful for IPC on the same machine. AF_INET uses the address format of four decimal numbers separated by dots like 192.9.200.10. In addition to the machine address, you can also use the port number to allow multiple AF_INET sockets on each machine. Here we will focus on the AF_INET method, because it is very useful and widely used.

The other parameter you must provide is the socket type. Two important types are SOCK_STREAM and SOCK_DGRAM. SOCK_STREAM indicates that the data passes through socket like a forward stream. SOCK_DGRAM indicates that the data is in the form of a datagram rams. We will explain SOCK_STREAM sockets, which is common and easy to use.

After a socket is created, we need to provide the socket listening address. Just like you need a phone number to pick up your phone. Bind () function to handle this problem.

SOCK_STREAM sockets forms a queue for connection requests. If you are busy processing a connection, other connection requests will wait until the connection is processed. The listen () function is used to set a maximum of five requests that are not rejected ). Generally, you are advised not to use the listen () function.

The following code describes how to use the socket (), bind (), and listen () functions to establish a connection and accept data.

 
 

  
  
int establish(unsigned short portnum)  
  
  
{ char   myname[MAXHOSTNAME+1];  
  
  
  int    s;  
  
  
  struct sockaddr_in sa;  
  
  
  struct hostent *hp;  
  
  
  memset(&sa, 0, sizeof(struct sockaddr_in));  
  
  
  gethostname(myname, MAXHOSTNAME);            
  
  
  hp= gethostbyname(myname);                    
  
  
  if (hp == NULL)                              
  
  
    return(-1);  
  
  
  sa.sin_family= hp->h_addrtype;                
  
  
  sa.sin_port= htons(portnum);                  
  
  
  if ((s= socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  
  
    return(-1);  
  
  
  if (bind(s,&sa,sizeof(struct sockaddr_in)) < 0) {  
  
  
    close(s);  
  
  
    return(-1);                                
  
  
  }  
  
  
  listen(s, 3);                                
  
  
  return(s);  
  
  
} 
 
 

After the socket is created, you have to wait for the socket to be called. The accept () function is used for this purpose. Calling accept () is the same as initiating a call after the phone rings. Accept () returns a new socket to the caller.

The following code demonstrates how to use it.

 
 

  
  
int get_connection(int s)  
  
  
{ int t;                    
  
  
  if ((t = accept(s,NULL,NULL)) < 0)    
  
  
    return(-1);  
  
  
  return(t);  
  
  
} 
 
 

Different from the phone number, you can accept the call when you process the previous connection. Therefore, fork is generally used to process each connection. The following code demonstrates how to use establish () and get_connection () to process multiple connections.

 
 

  
  
#include          
  
  
#include   
  
  
#include   
  
  
#include   
  
  
#include   
  
  
#include   
  
  
#include   
  
  
#include   
  
  
#include   
  
  
#define PORTNUM 50000  
  
  
void fireman(void);  
  
  
void do_something(int);  
  
  
main()  
  
  
{ int s, t;  
  
  
  if ((s= establish(PORTNUM)) < 0) {    
  
  
    perror("establish");  
  
  
    exit(1);  
  
  
  }  
  
  
  signal(SIGCHLD, fireman);            
  
  
  for (;;) {                            
  
  
    if ((t= get_connection(s)) < 0) {  
  
  
      if (errno == EINTR)              
  
  
        continue;                      
  
  
      perror("accept");                
  
  
      exit(1);  
  
  
    }  
  
  
    switch(fork()) {                    
  
  
    case -1 :                          
  
  
      perror("fork");  
  
  
      close(s);  
  
  
      close(t);  
  
  
      exit(1);  
  
  
    case 0 :                            
  
  
      close(s);  
  
  
      do_something(t);  
  
  
      exit(0);  
  
  
    default :                          
  
  
      close(t);                        
  
  
      continue;  
  
  
    }  
  
  
  }  
  
  
}  
  
  
void fireman(void)  
  
  
{  
  
  
  while (waitpid(-1, NULL, WNOHANG) > 0)  
  
  
    ;  
  
  
}  
  
  
void do_something(int s)  
  
  
{  
  
  
} 
 
 

Dialing (how to call socket)

Now you should know how to establishSocketTo accept the call. So how to call it? Like a phone number, you must have a phone number first. Use the socket () function to do this, just like creating a socket for listening.

InSocketYou can use the connect () function to connect to the listening socket. Below is a piece of code.

 
 

  
  
int call_socket(char *hostname, unsigned short portnum)  
  
  
{ struct sockaddr_in sa;  
  
  
  struct hostent     *hp;  
  
  
  int a, s;  
  
  
 
  
  
  if ((hp= gethostbyname(hostname)) == NULL) {  
  
  
    errno= ECONNREFUSED;                        
  
  
    return(-1);                                  
  
  
  }  
  
  
 
  
  
  memset(&sa,0,sizeof(sa));  
  
  
  memcpy((char *)&sa.sin_addr,hp->h_addr,hp->h_length);  
  
  
  sa.sin_family= hp->h_addrtype;  
  
  
  sa.sin_port= htons((u_short)portnum);  
  
  
 
  
  
  if ((s= socket(hp->h_addrtype,SOCK_STREAM,0)) < 0)    
  
  
    return(-1);  
  
  
  if (connect(s,&sa,sizeof sa) < 0) {                    
  
  
    close(s);  
  
  
    return(-1);  
  
  
  }  
  
  
  return(s);  
  
  
} 
 
 

This function returns a socket that can flow through data.

Conversation (how to talk through sockets)

Now you have established a connection between the two parties that want to transmit the data. Read () and write () functions. In addition to the difference between socket reading and writing and file reading and writing, it is the same as processing common files. The difference is that you generally cannot get the data you want. So you need to keep repeating to the arrival of the data you need. A simple example: Read data to the cache.

 
 

  
  
int read_data(int s,      
  
  
              char *buf,  
  
  
              int n        
  
  
             )  
  
  
{ int bcount;  
  
  
  int br;      
  
  
  bcount= 0;  
  
  
  br= 0;  
  
  
  while (bcount < n) {              
  
  
    if ((br= read(s,buf,n-bcount)) > 0) {  
  
  
      bcount += br;                  
  
  
      buf += br;                    
  
  
    }  
  
  
    else if (br < 0)                
  
  
      return(-1);  
  
  
  }  
  
  
  return(bcount);  
  
  
} 
 
 

You can write data for the same function.

Suspend (end)

Like when you talk to someone by phone, you need to close the connection between sockets. Generally, the close () function is used to close socket connections on each side. If one side is disabled while the other side is writing data to it, an error code is returned.

The language of the world language is very important)

Now you can contact the machine, but be careful with what you said. Many machines have their own dialects, such as ASCII and EBCDIC. The more common problem is the byte order. Unless you have always transmitted text, you must pay attention to this problem. Fortunately, people have found a solution.

Long ago, people argued which order was more "correct ". Now it is necessary to have corresponding functions for conversion. There are htons (), ntohs (), htonl (), and ntohl (). Before transmitting an integer data, convert it.

 
 

  
  
i= htonl(i);  
  
  
write_data(s, &i, sizeof(i)); 
 
 

After reading the data, change it back.

 
 

  
  
read_data(s, &i, sizeof(i));  
  
  
i= ntohl(i); 
 
 

If you keep sticking to this habit, you will have fewer chances of making mistakes than others.

The future is under your control (next step ?)

With what we have discussed, you can write your own communication program. Like all new things, it is best to see what others have done. There are many things about BSD socket for reference.

Please note that there is no error check in the example, which is very important in the "real" program. You should pay full attention to this.

Summary: AboutIPhone DevelopmentMediumBSD SocketI hope this article will help you with the ease of learning!