test3.c

学习linux的软件

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/time.h>

////////////////////////////////////////////////////////////////////////////////
// Definitions
////////////////////////////////////////////////////////////////////////////////
#define BUFFER_SIZE	1024

////////////////////////////////////////////////////////////////////////////////
// Prototypes
////////////////////////////////////////////////////////////////////////////////
void network_initialize(void);

inline void network_register_read(int fd);
inline void network_register_write(int fd);
inline void network_register_except(int fd);

inline void network_unregister_read(int fd);
inline void network_unregister_write(int fd);
inline void network_unregister_except(int fd);

void do_busy(void);

int do_read(int fd);
int do_write(int fd);
int do_except(int fd);

////////////////////////////////////////////////////////////////////////////////
// Global variables
////////////////////////////////////////////////////////////////////////////////
fd_set global_read_set;
fd_set global_write_set;
fd_set global_except_set;

int global_max_fd = 0;

////////////////////////////////////////////////////////////////////////////////
// Function implementition
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
  int fd;

  if (argc < 3)
  {
    fprintf(stdout, "Usage: %s <ip> <port>\n", argv[0]);
    return 0;
  }

  network_initialize();

  if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
  {
    fprintf(stderr, "Create new UDP socket failed: %s\n", strerror(errno));
    exit(1);
  }

#ifdef _DEBUG_
  fprintf(stdout, "Create a new UDP socket %d\n", fd);
#endif

  struct sockaddr_in server_address;

  memset(&server_address, 0, sizeof(server_address));

  server_address.sin_family = PF_INET;
  server_address.sin_port = htons(atoi(argv[2]));
  server_address.sin_addr.s_addr = inet_addr(argv[1]);

  //int bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen);
  if (bind(fd, (struct sockaddr *) &server_address, sizeof(server_address)) < 0)
  {
    fprintf(stderr, "Bind failed: %s\n", strerror(errno));
    close(fd);
    exit(1);
  }

#ifdef _DEBUG_
  fprintf(stdout, "Bound on %s:%d\n", argv[1], atoi(argv[2]));
#endif

  network_register_read(fd);

  fd_set rset, wset, eset;
  struct timeval to;

  for (;;)
  {
    rset = global_read_set;
    wset = global_write_set;
    eset = global_except_set;

    to.tv_sec = 10;
    to.tv_usec = 0;

    int n;

    // int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
    n = select(global_max_fd + 1, &rset, &wset, &eset, &to);

#ifdef _DEBUG_
    fprintf(stdout, "%d sockets are ready\n", n);
#endif

    if (n < 0)
    {
      fprintf(stderr, "select() failed: %s\n", strerror(errno));

      switch (errno)
      {
	case EINTR:
	  continue;
	default:
	  break;
      }
    }
    else if (n == 0)
    {
      do_busy();
    }
    else
    {
      int i;

      for (i = 0; i <= global_max_fd; i++)
      {
	if (FD_ISSET(i, &rset))
	{
#ifdef _DEBUG_
	  fprintf(stdout, "Socket %d is ready for reading.\n", i);
#endif
	  do_read(i);
	}

	if (FD_ISSET(i, &wset))
	{
#ifdef _DEBUG_
	  fprintf(stdout, "Socket %d is ready for writting.\n", i);
#endif
	  do_write(i);
	}

	if (FD_ISSET(i, &eset))
	{
#ifdef _DEBUG_
	  fprintf(stdout, "Socket %d is ready for excepting.\n", i);
#endif
	  do_except(i);
	}
      }
    }
  }

  close(fd);

  return 0;
}

void network_initialize(void)
{
  global_max_fd = 0;

  FD_ZERO(&global_read_set);
  FD_ZERO(&global_write_set);
  FD_ZERO(&global_except_set);
}

inline void network_register_read(int fd)
{
  FD_SET(fd, &global_read_set);

  if (fd > global_max_fd)
  {
    global_max_fd = fd;
  }
}

inline void network_unregister_read(int fd)
{
  FD_CLR(fd, &global_read_set);
}

inline void network_register_write(int fd)
{
  FD_SET(fd, &global_write_set);

  if (fd > global_max_fd)
  {
    global_max_fd = fd;
  }
}

inline void network_unregister_write(int fd)
{
  FD_CLR(fd, &global_write_set);
}

inline void network_register_except(int fd)
{
  FD_SET(fd, &global_except_set);

  if (fd > global_max_fd)
  {
    global_max_fd = fd;
  }
}

inline void network_unregister_except(int fd)
{
  FD_CLR(fd, &global_except_set);
}

void do_busy(void)
{
  fprintf(stdout, "Do something when network idle.\n");
}

int do_read(int fd)
{
  char buf[BUFFER_SIZE];
  ssize_t n;

  memset(buf, 0, sizeof(buf));

  struct sockaddr_in peer_address;
  socklen_t peer_address_length;

  peer_address_length = sizeof(peer_address);

  //ssize_t recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
  n = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) &peer_address, &peer_address_length);

#ifdef _DEBUG_
  fprintf(stdout, "Read %d bytes from %s:%d\n", n, inet_ntoa(peer_address.sin_addr), ntohs(peer_address.sin_port));
#endif

  fprintf(stdout, "Message from peer: %s\n", buf);

  return 0;
}

int do_write(int fd)
{
#ifdef _DEBUG_
  fprintf(stdout, "TODO: write some data to remote host.\n");
#endif

#if 0

  //ssize_t sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
  n = sendto(fd, buf, n, 0, (struct sockaddr *) &peer_address, peer_address_length);

#  ifdef _DEBUG_
  fprintf(stdout, "Write %d bytes to %s:%d\n", n, inet_ntoa(peer_address.sin_addr), ntohs(peer_address.sin_port));
#  endif
#endif

  return 0;
}

int do_except(int fd)
{
#ifdef _DEBUG_
  fprintf(stdout, "TODO: Handle exception on %d.\n", fd);
#endif

  return 0;
}