broadcast.cpp

UNIX/Linux环境下使用广播方式进行数据收发的代码

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

#include "broadcast.h"
#include "protocol.h"

extern char global_broadcast_address[];

static char local_receive_buffer[BUFFER_SIZE_MESSAGE];

int broadcast_start(int type)
{
  int fd;

  // XXX: step 1, socket
  //int socket(int domain, int type, int protocol);
  if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
  {
    // FIXME: Show error message with message box
    fprintf(stderr, "Create UDP socket failed: %s\n", strerror(errno));
    return -1;
  }

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

  // XXX: step 2, set broadcast option
  int on;

  on = 1;
  //int setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen);
  if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)) < 0)
  {
    // On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.
    fprintf(stderr, "setsockopt(broadcast) failed: %s\n", strerror(errno));
    close(fd);
    return -1;
  }

#ifdef _DEBUG_
  fprintf(stdout, "setsockopt(broadcast) successed\n");
#endif

  if (type == BROADCAST_TYPE_RECEIVER)
  {
    // XXX: bind
    struct sockaddr_in local_address;

    memset(&local_address, 0, sizeof(local_address));
    local_address.sin_family = PF_INET;
    local_address.sin_port = PIGEON_SERVICE_PORT;
    local_address.sin_addr.s_addr = htonl(INADDR_ANY);

    // int bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen);
    if (bind(fd, (struct sockaddr *) &local_address, sizeof(local_address)) < 0)
    {
      fprintf(stderr, "bind() failed on INADDR:%d\n", PIGEON_SERVICE_PORT);
      close(fd);
      return -1;
    }

#ifdef _DEBUG_
    fprintf(stderr, "bind() on INADDR:%d successed.\n", PIGEON_SERVICE_PORT);
#endif
  }

  return fd;
}

void broadcast_stop(int fd)
{
  close(fd);
}

int broadcast_send_data(int fd, char *message, unsigned long length)
{
  struct sockaddr_in remote_address;
  ssize_t n;

  memset(&remote_address, 0, sizeof(remote_address));
  remote_address.sin_family = PF_INET;
  remote_address.sin_port = PIGEON_SERVICE_PORT;
  remote_address.sin_addr.s_addr = inet_addr(global_broadcast_address);

  //ssize_t sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
  if ((n = sendto(fd, message, length, 0, (struct sockaddr *) &remote_address, sizeof(remote_address))) < 0)
  {
    fprintf(stderr, "send broadcast message failed: %s\n", strerror(errno));
    return -1;
  }
  else
  {
    return n;
  }
}

int broadcast_receive_data(int fd)
{
  struct sockaddr_in peer_address;
  socklen_t peer_address_length;
  ssize_t n;

  memset(local_receive_buffer, 0, BUFFER_SIZE_MESSAGE);
  peer_address_length = sizeof(peer_address);

  //ssize_t recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
  if ((n = recvfrom(fd, local_receive_buffer, BUFFER_SIZE_MESSAGE, 0, (struct sockaddr *) &peer_address, &peer_address_length)) < 0)
  {
    fprintf(stderr, "recvfrom() failed: %s\n", strerror(errno));
    return -1;
  }
  else
  {
    fprintf(stdout, "Got message from %s:%d: %s\n", inet_ntoa(peer_address.sin_addr), ntohs(peer_address.sin_port), local_receive_buffer);
    return n;
  }
}