PQI Air Card から UDP で Yo と答えさせてデバイス検出する試み

/* yo_service.c
 * under MIT license
 * 
 * Copyright (c) 2014 @cat_in_136
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

/** Have SIGTERM been received? */
static int isTermReceived = 0;

/** Open a UDP connection.
 *
 * @param[in] b_addr bind address, may be INADDR_ANY.
 * @param[in] port Port number.
 * @return a file descriptor for the socket on success, -1 on error.
 */
static int open_udp_conn(in_addr_t b_addr, u_short port)
{
  int sock;
  int ret;
  struct sockaddr_in addr;

  sock = socket(AF_INET, SOCK_DGRAM, 0);
  if (sock == -1) {
    perror("Socket open error.");
    return sock;
  }

  memset(&addr, 0, sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_port = htons(port);
  addr.sin_addr.s_addr = b_addr;
  ret = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
  if (ret == -1) {
    perror("bind error.");
    close(sock);
    return -1;
  }

  return sock;
}

/** Listen a UDP packet and send a packet of the response.
 *
 * @param[in] sock the socket.
 * @param[in] msg the response message.
 * @param[in] msg_len length of the response message.
 */
static void handle_udp_conn(int sock, const char *msg, size_t msg_len)
{
  static const char * CRLF = "\r\n";
  char buf[1024];
  ssize_t s;
  struct sockaddr src_addr;
  socklen_t addrlen;

  // receive a packet
  memset(buf, 0, sizeof(buf));
  s = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &src_addr, &addrlen);
  if (s == 0) {
    perror("empty message received");
    return;
  }

  //puts(buf);
  
  // build response message
  if ((s + strlen(CRLF) + msg_len) < sizeof(buf)) {
    memcpy(&buf[s], CRLF, strlen(CRLF));
    s += strlen(CRLF);

    memcpy(&buf[s], msg, msg_len);
    s += msg_len;

    sendto(sock, buf, s, 0, (struct sockaddr *) &src_addr, addrlen);
  }
}

/** Close the UDP connection.
 *
 * @param[in] sock the socket.
 * @return 0 on success, -1 on error.
 */
static int close_udp_conn(int sock)
{
  close(sock);

  return 0;
}

static void signal_handler(int signo)
{
  if (signo == SIGTERM) {
    isTermReceived = 1;
  }
}

int main(int argc, char *argv[]) {
  int ret;
  int sock;
  in_addr_t b_addr;
  u_short port;
  char *response_msg;
  size_t response_msg_len;

  if(signal(SIGTERM, signal_handler) == SIG_ERR) {
    perror("SIGTERM handler error");
    //return EXIT_FAILURE;
  }

  if (argc != 4) {
    printf("Usage: %s bind_address port response_msg\n", argv[0]);
    printf("Example:\n");
    printf("  %s 0.0.0.0 22222\n", argv[0]);
    return EXIT_FAILURE;
  }

  ret = inet_aton(argv[1], (struct in_addr *) &b_addr);
  if (ret == 0) {
    perror("Invalid IP address");
    return EXIT_FAILURE;
  }
  port = atoi(argv[2]);
  if (port == 0) {
    perror("Invalid IP port");
    return EXIT_FAILURE;
  }
  response_msg = argv[3];
  response_msg_len = strlen(argv[3]);

  sock = open_udp_conn(b_addr, port);
  if (sock == -1) {
    perror("Failed to open socket");
    return EXIT_FAILURE;
  }

  while (isTermReceived == 0) {
    handle_udp_conn(sock, response_msg, response_msg_len);
  }

  ret = close_udp_conn(sock);
  if (ret == -1) {
    perror("Failed to close socket");
    return EXIT_FAILURE;
  }

  return EXIT_SUCCESS;
}

/* vim:set tabstop=2 expandtab shiftwidth=2 softtabstop=0: */

#!/bin/sh

sleep 5

ln -s /mnt/sd/path/to/yo_service /bin/yo_service
chmod +x /bin/yo_service
sync; sync; sync

yo_service 0.0.0.0 10091 "Yo from PQI_AIR_CARD" &

#!/usr/bin/ruby
require "socket"

udp = nil
begin
  udp = UDPSocket.open
  udp.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1)

  udp.bind("0.0.0.0", 20091)

  udp.send("Yo from laptop", 0, "255.255.255.255", 10091)

  res, res_addr = udp.recvfrom(2048)
  p res
  p res_addr
ensure
  udp.close unless udp.nil?
end