int main(){
double result=0;
int i=0;
int error = 0;
erlang_pid pid;
char host[HOSTNAMESZ];
char server_node[HOSTNAMESZ];
char client_node[HOSTNAMESZ];
CORBA_Environment *env;
/* Initiate names */
#ifdef __WIN32__
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(1, 1);
if ((error = WSAStartup(wVersionRequested, &wsaData))) {
fprintf(stderr,"Can't initialize windows sockets: %d",error);
return 0;
}
#endif
error = gethostname(host,HOSTNAMESZ);
if (error) {
#ifdef __WIN32__
fprintf(stderr,"can't find own hostname (error = %ld) !\n",WSAGetLastError());
#else /* not __WIN32__ */
fprintf(stderr,"can't find own hostname !\n");
#endif
}
sprintf(client_node,"%s@%s",CLNODENAME,host);
sprintf(server_node,"%s@%s",SNODENAME,host);
/* Create and init CORBA_Environment */
env = CORBA_Environment_alloc(INBUFSZ,OUTBUFSZ);
/* Initiating the connection */
erl_init(NULL,0);
erl_connect_init(50,COOKIE,0);
/* Initiating pid*/
strcpy(pid.node,client_node);
pid.num = 99;
pid.serial = 0;
pid.creation = 0;
/* Fixing environment variable */
env->_fd=erl_connect(server_node);
strcpy(env->_regname,SREGNAME);
env->_to_pid = NULL;
env->_from_pid = &pid;
if (env->_fd < 0) {
fprintf(stderr,"Error : Cannot connect to Server\n");
/* Free env & buffers */
CORBA_free(env->_inbuf);
CORBA_free(env->_outbuf);
CORBA_free(env);
exit(1);
}
/* Calling the init function */
rmod_random_init(NULL, 1, 2, 3, env);
switch(env->_major) {
case CORBA_NO_EXCEPTION: /* Success */
printf("Init complete !\n");
break;
case CORBA_SYSTEM_EXCEPTION: /* System exception */
printf("Init call failure, reason : %s\n",(char *) CORBA_exception_value(env));
CORBA_exception_free(env);
client_exit(env);
default: /* Should not come here */
client_exit(env);
}
/* Calling the produce function */
for(i=1; i<=10; i++) {
result = rmod_random_produce(NULL, env);
switch(env->_major) {
case CORBA_NO_EXCEPTION: /* Success */
break;
case CORBA_SYSTEM_EXCEPTION: /* System exception */
printf("Init call failure, reason : %s\n",(char *) CORBA_exception_value(env));
CORBA_exception_free(env);
client_exit(env);
default: /* Should not come here */
client_exit(env);
}
printf("the random number nr%d is %f\n",i,result);
}
/* Closing the connection */
erl_close_connection(env->_fd);
/* Free env & buffers */
CORBA_free(env->_inbuf);
CORBA_free(env->_outbuf);
CORBA_free(env);
return 0;
}
void *cnode_run()
{
int fd; /* fd to Erlang node */
int got; /* Result of receive */
unsigned char buf[BUFSIZE]; /* Buffer for incoming message */
ErlMessage emsg; /* Incoming message */
ETERM *uid, *msg;
erl_init(NULL, 0);
if (erl_connect_init(1, "secretcookie", 0) == -1)
erl_err_quit("erl_connect_init");
if ((fd = erl_connect("httpdmaster@localhost")) < 0)
erl_err_quit("erl_connect");
fprintf(stderr, "Connected to httpdmaster@localhost\n\r");
struct evbuffer *evbuf;
while (1) {
got = erl_receive_msg(fd, buf, BUFSIZE, &emsg);
if (got == ERL_TICK) {
continue;
} else if (got == ERL_ERROR) {
fprintf(stderr, "ERL_ERROR from erl_receive_msg.\n");
break;
} else {
if (emsg.type == ERL_REG_SEND) {
fprintf(stderr, "type of emsg is ERL_REG_SEND\n");
// get uid and body data from eg: {123, <<"Hello">>}
uid = erl_element(1, emsg.msg);
msg = erl_element(2, emsg.msg);
char *token = (char *) ERL_BIN_PTR(uid);
char *body = (char *) ERL_BIN_PTR(msg);
int body_len = ERL_BIN_SIZE(msg);
char *cached = fetch_memcached(token);
int userid = atoi(cached);
fprintf(stderr, "memc: %d\n\r", userid);
if(clients[userid]){
fprintf(stderr, "Sending %d bytes to token %s\n", body_len, token);
evbuf = evbuffer_new();
evbuffer_add(evbuf, (const void*)body, (size_t) body_len);
evhttp_send_reply_chunk(clients[userid], evbuf);
evhttp_send_reply_end(clients[userid]);
evbuffer_free(evbuf);
}else{
fprintf(stderr, "Discarding %d bytes to uid %d - user not connected\n",
body_len, userid);
}
free(cached);
erl_free_term(emsg.msg);
erl_free_term(uid);
erl_free_term(msg);
}
}
fprintf(stderr, ".");
}
pthread_exit(0);
}
int main(int argc, char **argv) {
int name, 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;
name = atoi(argv[1]);
port = atoi(argv[2]);
erl_init(NULL, 0);
if (erl_connect_init(name, "secretcookie", 0) == -1)
erl_err_quit("erl_connect_init");
/* 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) {
fprintf(stderr, "emsg type %d", emsg.type);
fromp = erl_element(2, emsg.msg);
tuplep = erl_element(3, emsg.msg);
fnp = erl_element(1, tuplep);
argp = erl_element(2, tuplep);
if (strncmp(ERL_ATOM_PTR(fnp), "foo", 3) == 0) {
res = foo(ERL_INT_VALUE(argp));
} else if (strncmp(ERL_ATOM_PTR(fnp), "bar", 3) == 0) {
res = bar(ERL_INT_VALUE(argp));
}
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);
}
}
} /* while */
}
int main(void)
#endif
{
ei_x_buff eix;
int index = 0;
ETERM **etermpp = NULL, *etermp = NULL;
char *charp = NULL;
unsigned char uchar, **ucharpp = NULL, *ucharp = NULL;
void *voidp = NULL;
Erl_Heap *erl_heapp = NULL;
int intx = 0;
int *intp = NULL;
unsigned int uintx, *uintp;
unsigned long *ulongp = NULL;
long longx = 0;
double doublex = 0.0;
short shortx = 42;
FILE *filep = NULL;
Erl_IpAddr erl_ipaddr = NULL;
ErlMessage *erlmessagep = NULL;
ErlConnect *erlconnectp = NULL;
struct hostent *hostp = NULL;
struct in_addr *inaddrp = NULL;
/* Converion to erl_interface format is in liberl_interface */
intx = erl_errno;
ei_encode_term(charp, &index, voidp);
ei_x_encode_term(&eix, voidp);
ei_decode_term(charp, &index, voidp);
erl_init(voidp, longx);
erl_connect_init(intx, charp,shortx);
erl_connect_xinit(charp,charp,charp,erl_ipaddr,charp,shortx);
erl_connect(charp);
erl_xconnect(erl_ipaddr,charp);
erl_close_connection(intx);
erl_receive(intx, ucharp, intx);
erl_receive_msg(intx, ucharp, intx, erlmessagep);
erl_xreceive_msg(intx, ucharpp, intp, erlmessagep);
erl_send(intx, etermp, etermp);
erl_reg_send(intx, charp, etermp);
erl_rpc(intx,charp,charp,etermp);
erl_rpc_to(intx,charp,charp,etermp);
erl_rpc_from(intx,intx,erlmessagep);
erl_publish(intx);
erl_accept(intx,erlconnectp);
erl_thiscookie();
erl_thisnodename();
erl_thishostname();
erl_thisalivename();
erl_thiscreation();
erl_unpublish(charp);
erl_err_msg(charp);
erl_err_quit(charp);
erl_err_ret(charp);
erl_err_sys(charp);
erl_cons(etermp,etermp);
erl_copy_term(etermp);
erl_element(intx,etermp);
erl_hd(etermp);
erl_iolist_to_binary(etermp);
erl_iolist_to_string(etermp);
erl_iolist_length(etermp);
erl_length(etermp);
erl_mk_atom(charp);
erl_mk_binary(charp,intx);
erl_mk_empty_list();
erl_mk_estring(charp, intx);
erl_mk_float(doublex);
erl_mk_int(intx);
erl_mk_list(etermpp,intx);
erl_mk_pid(charp,uintx,uintx,uchar);
erl_mk_port(charp,uintx,uchar);
erl_mk_ref(charp,uintx,uchar);
erl_mk_long_ref(charp,uintx,uintx,uintx,uchar);
erl_mk_string(charp);
erl_mk_tuple(etermpp,intx);
erl_mk_uint(uintx);
erl_mk_var(charp);
erl_print_term(filep,etermp);
/* erl_sprint_term(charp,etermp); */
erl_size(etermp);
erl_tl(etermp);
erl_var_content(etermp, charp);
erl_format(charp);
erl_match(etermp, etermp);
erl_global_names(intx, intp);
erl_global_register(intx, charp, etermp);
erl_global_unregister(intx, charp);
erl_global_whereis(intx, charp, charp);
erl_init_malloc(erl_heapp,longx);
erl_alloc_eterm(uchar);
erl_eterm_release();
erl_eterm_statistics(ulongp,ulongp);
erl_free_array(etermpp,intx);
erl_free_term(etermp);
erl_free_compound(etermp);
erl_malloc(longx);
erl_free(voidp);
erl_compare_ext(ucharp, ucharp);
erl_decode(ucharp);
erl_decode_buf(ucharpp);
erl_encode(etermp,ucharp);
erl_encode_buf(etermp,ucharpp);
erl_ext_size(ucharp);
erl_ext_type(ucharp);
erl_peek_ext(ucharp,intx);
erl_term_len(etermp);
erl_gethostbyname(charp);
erl_gethostbyaddr(charp, intx, intx);
erl_gethostbyname_r(charp, hostp, charp, intx, intp);
erl_gethostbyaddr_r(charp, intx, intx, hostp, charp, intx, intp);
erl_init_resolve();
erl_distversion(intx);
erl_epmd_connect(inaddrp);
erl_epmd_port(inaddrp, charp, intp);
charp = ERL_ATOM_PTR(etermp);
intx = ERL_ATOM_SIZE(etermp);
ucharp = ERL_BIN_PTR(etermp);
intx = ERL_BIN_SIZE(etermp);
etermp = ERL_CONS_HEAD(etermp);
etermp = ERL_CONS_TAIL(etermp);
intx = ERL_COUNT(etermp);
doublex= ERL_FLOAT_VALUE(etermp);
uintx = ERL_INT_UVALUE(etermp);
intx = ERL_INT_VALUE(etermp);
intx = ERL_IS_ATOM(etermp);
intx = ERL_IS_BINARY(etermp);
intx = ERL_IS_CONS(etermp);
intx = ERL_IS_EMPTY_LIST(etermp);
intx = ERL_IS_FLOAT(etermp);
intx = ERL_IS_INTEGER(etermp);
intx = ERL_IS_LIST(etermp);
intx = ERL_IS_PID(etermp);
intx = ERL_IS_PORT(etermp);
intx = ERL_IS_REF(etermp);
intx = ERL_IS_TUPLE(etermp);
intx = ERL_IS_UNSIGNED_INTEGER(etermp);
uchar = ERL_PID_CREATION(etermp);
charp = ERL_PID_NODE(etermp);
uintx = ERL_PID_NUMBER(etermp);
uintx = ERL_PID_SERIAL(etermp);
uchar = ERL_PORT_CREATION(etermp);
charp = ERL_PORT_NODE(etermp);
uintx = ERL_PORT_NUMBER(etermp);
uchar = ERL_REF_CREATION(etermp);
intx = ERL_REF_LEN(etermp);
charp = ERL_REF_NODE(etermp);
uintx = ERL_REF_NUMBER(etermp);
uintp = ERL_REF_NUMBERS(etermp);
etermp = ERL_TUPLE_ELEMENT(etermp,intx);
intx = ERL_TUPLE_SIZE(etermp);
return
BUFSIZ +
EAGAIN +
EHOSTUNREACH +
EINVAL +
EIO +
EMSGSIZE +
ENOMEM +
ERL_ATOM +
ERL_BINARY +
ERL_ERROR +
ERL_EXIT +
ERL_FLOAT +
ERL_INTEGER +
ERL_LINK +
ERL_LIST +
ERL_MSG +
ERL_NO_TIMEOUT +
ERL_PID +
ERL_PORT +
ERL_REF +
ERL_REG_SEND +
ERL_SEND +
ERL_SMALL_BIG +
ERL_TICK +
ERL_TIMEOUT +
ERL_TUPLE +
ERL_UNLINK +
ERL_U_INTEGER +
ERL_U_SMALL_BIG +
ERL_VARIABLE +
ETIMEDOUT +
MAXNODELEN +
MAXREGLEN;
}
int main(int argc, char *argv[]) {
int fd; /* fd to Erlang node */
unsigned char buf[BUFSIZE]; /* Buffer for incoming message */
ErlMessage emsg; /* Incoming message */
int c_node; /* C-Node number */
char cookie[EI_MAX_COOKIE_SIZE+1]; /* Shared cookie */
short creation; /* ?? */
char *erlang_node; /* Erlang node to connect to */
char *cookie_opt; /* Where to source our cookie */
char *cookie_data; /* Either the filename or literal cookie */
ETERM *fromp, *msgp, *fnp, *argp, *resp;
int received, loop = 1;
if (argc < 5) {
quit_with_error("invalid_args");
}
c_node = atoi(argv[1]);
cookie_opt = argv[2];
cookie_data = argv[3];
creation = 0;
erlang_node = argv[4];
erl_init(NULL, 0);
get_cookie(cookie_opt, cookie_data, cookie);
if (!erl_connect_init(c_node, cookie, creation)) {
quit_with_error("erl_connect_init");
}
if ((fd = erl_connect(erlang_node)) < 0) {
quit_with_error("erl_connect");
}
while (loop) {
received = erl_receive_msg(fd, buf, BUFSIZE, &emsg);
if (received == ERL_TICK) {
/* ignore */
} else if (received == ERL_ERROR) {
loop = 0;
} else {
if (emsg.type == ERL_REG_SEND) {
fromp = erl_element(2, emsg.msg);
msgp = erl_element(3, emsg.msg);
fnp = erl_element(1, msgp);
argp = erl_element(2, msgp);
if (is_function(fnp, "stop")) {
loop = 0;
resp = erl_format("{c_node, ~i, ok}", c_node);
} else if (is_function(fnp, "new_image_blank")) {
resp = new_image_blank(argp, c_node);
} else if (is_function(fnp, "write_to_png")) {
resp = write_to_png(argp, c_node);
} else if (is_function(fnp, "close_image")) {
resp = close_image(argp, c_node);
} else if (is_function(fnp, "save")) {
resp = save(argp, c_node);
} else if (is_function(fnp, "restore")) {
resp = restore(argp, c_node);
} else if (is_function(fnp, "set_line_width")) {
resp = set_line_width(argp, c_node);
} else if (is_function(fnp, "set_source_rgba")) {
resp = set_source_rgba(argp, c_node);
} else if (is_function(fnp, "set_operator")) {
resp = set_operator(argp, c_node);
} else if (is_function(fnp, "move_to")) {
resp = move_to(argp, c_node);
} else if (is_function(fnp, "line_to")) {
resp = line_to(argp, c_node);
} else if (is_function(fnp, "curve_to")) {
resp = curve_to(argp, c_node);
} else if (is_function(fnp, "rel_move_to")) {
resp = rel_move_to(argp, c_node);
} else if (is_function(fnp, "rel_line_to")) {
resp = rel_line_to(argp, c_node);
} else if (is_function(fnp, "rel_curve_to")) {
resp = rel_curve_to(argp, c_node);
} else if (is_function(fnp, "rectangle")) {
resp = rectangle(argp, c_node);
} else if (is_function(fnp, "arc")) {
resp = arc(argp, c_node);
} else if (is_function(fnp, "arc_negative")) {
resp = arc_negative(argp, c_node);
} else if (is_function(fnp, "close_path")) {
resp = close_path(argp, c_node);
} else if (is_function(fnp, "paint")) {
resp = paint(argp, c_node);
} else if (is_function(fnp, "fill")) {
resp = fill(argp, c_node);
} else if (is_function(fnp, "fill_preserve")) {
resp = fill_preserve(argp, c_node);
} else if (is_function(fnp, "stroke")) {
resp = stroke(argp, c_node);
} else if (is_function(fnp, "stroke_preserve")) {
resp = stroke_preserve(argp, c_node);
} else if (is_function(fnp, "translate")) {
resp = translate(argp, c_node);
} else if (is_function(fnp, "scale")) {
resp = scale(argp, c_node);
} else if (is_function(fnp, "rotate")) {
resp = rotate(argp, c_node);
} else if (is_function(fnp, "select_font")) {
resp = select_font_face(argp, c_node);
} else if (is_function(fnp, "set_font_size")) {
resp = set_font_size(argp, c_node);
} else if (is_function(fnp, "show_text")) {
resp = show_text(argp, c_node);
} else if (is_function(fnp, "text_extents")) {
resp = text_extents(argp, c_node);
} else if (is_function(fnp, "surface_create_from_png")) {
resp = surface_create_from_png(argp, c_node);
} else if (is_function(fnp, "surface_create_from_png_stream")) {
resp = surface_create_from_png_stream(argp, c_node);
} else if (is_function(fnp, "surface_get_width")) {
resp = surface_get_width(argp, c_node);
} else if (is_function(fnp, "surface_get_height")) {
resp = surface_get_height(argp, c_node);
} else if (is_function(fnp, "surface_destroy")) {
resp = surface_destroy(argp, c_node);
} else if (is_function(fnp, "set_source_surface")) {
resp = set_source_surface(argp, c_node);
} else if (is_function(fnp, "write_to_png_stream")) {
resp = write_to_png_stream(argp, c_node);
} else {
resp = erl_format("{c_node, ~i, {error, '~s'}}", c_node, "unknown command");
}
erl_send(fd, fromp, resp);
erl_free_term(emsg.from);
erl_free_term(emsg.msg);
erl_free_term(fromp);
erl_free_term(msgp);
erl_free_term(fnp);
erl_free_term(argp);
erl_free_term(resp);
}
}
}
exit(EXIT_SUCCESS);
}
