Erlang CNode 代码

好久没写了，一直忙着看文档，今天写个简单的吧

现在所作的项目是建立Erlang的MSC，并与C的OpenBSC连接
由于是C 和 Erlang的连系，所以需要用到C Node
下面的代码是简单的C Node，如果加上OpenBSC，就可以实现ping pong消息的传递

代码很简单，连ip port以及erlang node的名字都是写死了，大伙凑合看吧

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h> 
#include <netinet/in.h>
#include "erl_interface.h"
#include "ei.h"

#include <openbsc/ipaccess.h>

#define BUFSIZE 1000


static const u_int8_t pong[]  = { 0, 1, IPAC_PROTO_IPACCESS, IPAC_MSGT_PONG };
static const u_int8_t ping[] = { 0, 1, IPAC_PROTO_IPACCESS, IPAC_MSGT_PING };

int new_socket;

int prepare_socket(){
    int socket_desc;
    struct sockaddr_in address;

    int bufsize=1024;
    char *buffer=malloc(bufsize);
    int addrlen;

    socket_desc=socket(AF_INET,SOCK_STREAM,0);
    if (socket_desc==-1)
    perror("Create socket");

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(5000);

    bind(socket_desc,(struct sockaddr *)&address,sizeof(address));
    listen(socket_desc,3);

    addrlen = sizeof(struct sockaddr_in);
    new_socket = accept(socket_desc, (struct sockaddr *)&address, &addrlen);
    if (new_socket<0)
    printf("Accept connection");

    printf("recv_from_bsc\n");
    recv(new_socket,buffer,bufsize,0);
    free( buffer );
    return new_socket;
}

int send_ping(){
    int bufsize = 1024;
    char *buff = malloc(bufsize);
    int new_socket;
    new_socket = prepare_socket();
    send( new_socket, pong, sizeof( pong ), 0);
    send( new_socket, ping, sizeof( ping ), 0);
    recv( new_socket, buff, sizeof( buff ), 0);
    //close(new_socket);
    return 0;
}

int send_pong(){
    int new_socket;
    prepare_socket();
    send(new_socket, pong, sizeof( pong ), 0);
    close(new_socket);
    return 0;
}

int main(int argc, char **argv) {
  struct in_addr addr;                     /* 32-bit IP number of host */
  char* ip;
  int port;                                /* Listen port number */
  int listen;                              /* Listen socket */
  int fd;                                  /* fd to Erlang node */
  ErlConnect conn;                         /* Connection data */
  int loop = 1;                            /* Loop flag */
  int got;                                 /* Result of receive */
  unsigned char buf[BUFSIZE];              /* Buffer for incoming message */
  ErlMessage emsg;                         /* Incoming message */
  ETERM *fromp, *tuplep, *fnp, *argp, *resp;
  int res;

  fprintf(stderr, "cn ip_address port\n");

  ip = "127.0.0.1";
  port = 5555;
  /*ip = argv[1];*/
  /*port = atoi(argv[2]);*/
  /*printf("ip %s, port %d\n", ip, port);*/

  /*if(argc != 3) return 1;*/

  erl_init(NULL, 0);

  addr.s_addr = inet_addr(ip);

  if (erl_connect_xinit("wenbin-desktop", "cnode", "cnode@wenbin-desktop.xxxxxxx",
            &addr, "wenbin", 0) == -1)
    erl_err_quit("erl_connect_xinit");

  /* Make a listen socket */
  if ((listen = my_listen(port)) <= 0)
    erl_err_quit("my_listen");
  if (erl_publish(port) == -1)
    erl_err_quit("erl_publish");


  if ((fd = erl_accept(listen, &conn)) == ERL_ERROR)
    erl_err_quit("erl_accept");

  fprintf(stderr, "Connected to %s\n\r", conn.nodename);

  while (loop) {
    got = erl_receive_msg(fd, buf, BUFSIZE, &emsg);

    if (got == ERL_TICK) {
      /* ignore */
    } else if (got == ERL_ERROR) {
      loop = 0;
    } else {
      if (emsg.type == ERL_REG_SEND) {
        // get msg
    fromp = erl_element(2, emsg.msg);
    tuplep = erl_element(3, emsg.msg);

        // get elements in the tuple
    fnp = erl_element(1, tuplep);
    //argp = erl_element(2, tuplep);

    if (strncmp(ERL_ATOM_PTR(fnp), "ping", 4) == 0) {
      res = send_ping();
    } else if (strncmp(ERL_ATOM_PTR(fnp), "pong", 4) == 0) {
      res = send_pong();
    } else if (strncmp(ERL_ATOM_PTR(fnp), "stop", 4) == 0) {
      break;
    }

    resp = erl_format("{cnode, ~i}", res);
    erl_send(fd, fromp, resp);

    erl_free_term(emsg.from); 
    erl_free_term(emsg.msg);
    erl_free_term(fromp); 
    erl_free_term(tuplep);
    erl_free_term(fnp); 
    //erl_free_term(argp);
    erl_free_term(resp);
      }
    }
    printf("Done, waiting for another one.\n");
  }
  printf("Finish.\n");
}

int my_listen(int port) {
  int listen_fd;
  struct sockaddr_in addr;
  int on = 1;
  if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    return (-1);
  setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
  memset((void*) &addr, 0, (size_t) sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_port = htons(port);
  addr.sin_addr.s_addr = htonl(INADDR_ANY);
  if (bind(listen_fd, (struct sockaddr*) &addr, sizeof(addr)) < 0)
    return (-1);
  listen(listen_fd, 5);
  return listen_fd;
}

-module(test_node_ping).

-export([ping/0, pong/0, stop/0]).

stop() ->
    call_cnode( { stop } ).
ping() ->
    call_cnode( { ping } ).

pong() ->
    call_cnode( { pong } ).

call_cnode(Msg) ->
    {any, 'cnode@wenbin-desktop.xxxxxx'} ! {call, self(), Msg},
    if Msg == { stop } ->
        ok;
    true ->
        receive
        {cnode, Result} ->
            Result
        end
    end.