1. communication style   
   2. тип протокола 

   1. SOCK_STREAM
   2. SOCK_DGRAM
   3. SOCK_RAW

    short int sa_family
    char sa_data[14]

  AF_LOCAL
  AF_UNIX
  AF_FILE
  AF_INET
  AF_INET6
  AF_UNSPEC     

 int getsockname (int socket, struct sockaddr *addr, socklen_t *length-ptr)

  Базовая структура - struct sockaddr_in
 Она включает члены :
 sa_family_t sin_family
 struct in_addr sin_addr
 unsigned short int sin_port
  Каждый компьютер имееи host address вида `128.52.46.32' и 
  host name вида `mescaline.gnu.org'
 База данных сервисов хранится обычно в файле  /etc/services и имеет вид :
 systat		11/udp		users
 daytime		13/tcp
 qotd		17/tcp		quote

 
 #include < stdio.h >
 #include < stdlib.h >
 #include < sys/socket.h >
 #include < netinet/in.h >
 int make_socket (uint16_t port)
 {
   int sock;
   struct sockaddr_in name;
   /* Create the socket. */
   sock = socket (PF_INET, SOCK_STREAM, 0);
   if (sock < 0)
    {
      perror ("socket");
      exit (EXIT_FAILURE);
    }
    /* Give the socket a name. */
    name.sin_family = AF_INET;
    name.sin_port = htons (port);
    name.sin_addr.s_addr = htonl (INADDR_ANY);
    if (bind (sock, (struct sockaddr *) &name, sizeof (name)) < 0)
    {
       perror ("bind");
       exit (EXIT_FAILURE);
    }
    return sock;
 }
 

 
 #include < stdio.h >
 #include < stdlib.h >
 #include < sys/socket.h >
 #include < netinet/in.h >
 #include < netdb.h >
 
 void init_sockaddr (struct sockaddr_in *name,const char *hostname,uint16_t port)
   {
     struct hostent *hostinfo;
     name->sin_family = AF_INET;
     name->sin_port = htons (port);
     hostinfo = gethostbyname (hostname);
     if (hostinfo == NULL) 
     {
       fprintf (stderr, "Unknown host %s.\n", hostname);
       exit (EXIT_FAILURE);
     }
     name->sin_addr = *(struct in_addr *) hostinfo->h_addr;
 }
 
  Следующий пример создает клиентский сокет и посылает серверу строку данных :
 
 #include < stdio.h >
 #include < errno.h >
 #include < stdlib.h >
 #include < unistd.h >
 #include < sys/types.h >
 #include < sys/socket.h >
 #include < netinet/in.h >
 #include < netdb.h >
 #define PORT            5555
 #define MESSAGE         "Yow!!! Are we having fun yet?!?"
 #define SERVERHOST      "mescaline.gnu.org"
 void write_to_server (int filedes)
 {
    int nbytes;
    nbytes = write (filedes, MESSAGE, strlen (MESSAGE) + 1);
    if (nbytes < 0)
   {
     perror ("write");
     exit (EXIT_FAILURE);
   }
 }
  int main (void)
  {
    extern void init_sockaddr (struct sockaddr_in *name,
                                 const char *hostname, uint16_t port);
    int sock;
    struct sockaddr_in servername;
    /* Create the socket. */
    sock = socket (PF_INET, SOCK_STREAM, 0);
    if (sock < 0)
     {
       perror ("socket (client)");
       exit (EXIT_FAILURE);
     }
     /* Connect to the server. */
     init_sockaddr (&servername, SERVERHOST, PORT);
     if (0 > connect (sock,(struct sockaddr *) &servername,sizeof (servername)))
     {
       perror ("connect (client)");
       exit (EXIT_FAILURE);
     }
       /* Send data to the server. */
     write_to_server (sock);
     close (sock);
     exit (EXIT_SUCCESS);
     }
 

 
 #include < stdio.h >
 #include < errno.h >
 #include < stdlib.h >
 #include < unistd.h >
 #include < sys/types.h >
 #include < sys/socket.h >
 #include < netinet/in.h >
 #include < netdb.h >
 #define PORT    5555
 #define MAXMSG  512
 
 int read_from_client (int filedes)
 {
   char buffer[MAXMSG];
   int nbytes;
   nbytes = read (filedes, buffer, MAXMSG);
   if (nbytes < 0)
     {
       /* Read error. */
       perror ("read");
       exit (EXIT_FAILURE);
     }
   else if (nbytes == 0)
   /* End-of-file. */
     return -1;
   else
   {
      /* Data read. */
      fprintf (stderr, "Server: got message: `%s'\n", buffer);
      return 0;
    }
   }
  int main (void)
 {
   extern int make_socket (uint16_t port);
   int sock;
   fd_set active_fd_set, read_fd_set;
   int i;
   struct sockaddr_in clientname;
   size_t size;
   /* Create the socket and set it up to accept connections. */
   sock = make_socket (PORT);
   if (listen (sock, 1) < 0)
    {
     perror ("listen");
     exit (EXIT_FAILURE);
    }
    /* Initialize the set of active sockets. */
     FD_ZERO (&active_fd_set);
     FD_SET (sock, &active_fd_set);
     while (1)
       {
         /* Block until input arrives on one or more active sockets. */
         read_fd_set = active_fd_set;
         if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)
         {
           perror ("select");
           exit (EXIT_FAILURE);
         }
       /* Service all the sockets with input pending. */
       for (i = 0; i < FD_SETSIZE; ++i)
         if (FD_ISSET (i, &read_fd_set))
           {
           if (i == sock)
             {
                 /* Connection request on original socket. */
                 int new;
                 size = sizeof (clientname);
                 new = accept (sock,
                 (struct sockaddr *) &clientname, &size);
                 if (new < 0)
                 {
                   perror ("accept");
                   exit (EXIT_FAILURE);
 	        }
                 fprintf (stderr,"Server: connect from host %s, port %hd.\n",
 		inet_ntoa (clientname.sin_addr), ntohs (clientname.sin_port));
                  FD_SET (new, &active_fd_set);
             }
            else
            {
                /* Data arriving on an already-connected socket. */
                if (read_from_client (i) < 0)
                {
                  close (i);
                  FD_CLR (i, &active_fd_set);
                }
             }
    }
  }
 }
 

 intdiscard_until_mark (int socket)
 {
   while (1)
   {
     /* This is not an arbitrary limit; any size will do.  */
     char buffer[1024];
     int atmark, success;
     /* If we have reached the mark, return.  */
     success = ioctl (socket, SIOCATMARK, &atmark);
     if (success < 0)
        perror ("ioctl");
     if (result)
       return;
     /* Otherwise, read a bunch of ordinary data and discard it.
        This is guaranteed not to read past the mark
        if it starts before the mark.  */
     success = read (socket, buffer, sizeof buffer);
     if (success < 0)
       perror ("read");
   }
 }
 

 
 struct buffer
 {
   char *buf;
   int size;
   struct buffer *next;
 };
   /* Read the out-of-band data from SOCKET and return it
      as a `struct buffer', which records the address of the data
      and its size.
      It may be necessary to read some ordinary data
      in order to make room for the out-of-band data.
      If so, the ordinary data are saved as a chain of buffers
      found in the `next' field of the value.  */
 
   struct buffer *
   read_oob (int socket)
   {
    struct buffer *tail = 0;
    struct buffer *list = 0;
    while (1)
    {
     /* This is an arbitrary limit.
        Does anyone know how to do this without a limit?  */
     #define BUF_SZ 1024
     char *buf = (char *) xmalloc (BUF_SZ);
     int success;
     int atmark;
     /* Try again to read the out-of-band data.  */
     success = recv (socket, buf, BUF_SZ, MSG_OOB);
     if (success >= 0)
      {
        /* We got it, so return it.  */
        struct buffer *link  = (struct buffer *) xmalloc (sizeof (struct buffer));
       link->buf = buf;
       link->size = success;
       link->next = list;
       return link;
      }
      /* If we fail, see if we are at the mark.  */
      success = ioctl (socket, SIOCATMARK, &atmark);
      if (success < 0)
            perror ("ioctl");
      if (atmark)
          {
            /* At the mark; skipping past more ordinary data cannot help.
             So just wait a while.  */
            sleep (1);
            continue;
          }
      /* Otherwise, read a bunch of ordinary data and save it.
        This is guaranteed not to read past the mark
        if it starts before the mark.  */
      success = read (socket, buf, BUF_SZ);
      if (success < 0)
        perror ("read");
       /* Save this data in the buffer list.  */
        {
           struct buffer *link = (struct buffer *) xmalloc (sizeof (struct buffer));
           link->buf = buf;
           link->size = success;
           /* Add the new link to the end of the list.  */
           if (tail)
             tail->next = link;
           else
           list = link;
           tail = link;
         }
     }
 }
 

 
 #include < stdio.h >
 #include < errno.h >
 #include < stdlib.h >
 #include < sys/socket.h >
 #include < sys/un.h >
 #define SERVER  "/tmp/serversocket"
 #define MAXMSG  512
 int main (void)
 {
   int sock;
   char message[MAXMSG];
   struct sockaddr_un name;
   size_t size;
   int nbytes;
   /* Remove the filename first, it's ok if the call fails */
   unlink (SERVER);
   /* Make the socket, then loop endlessly. */
   sock = make_named_socket (SERVER);
   while (1)
     {
       /* Wait for a datagram. */
       size = sizeof (name);
       nbytes = recvfrom (sock, message, MAXMSG, 0,(struct sockaddr *) & name, &size);
       if (nbytes < 0)
        {
            perror ("recfrom (server)");
            exit (EXIT_FAILURE);
        }
        /* Give a diagnostic message. */
       fprintf (stderr, "Server: got message: %s\n", message);
       /* Bounce the message back to the sender. */
       nbytes = sendto (sock, message, nbytes, 0,(struct sockaddr *) & name, size);
       if (nbytes < 0)
       {
         perror ("sendto (server)");
         exit (EXIT_FAILURE);
       }
     }
   }
 

Оставьте свой комментарий !
Ваше имя: Комментарий: Оба поля являются обязательными  Автор   Комментарий к данной статье