Beispiel #1
0
static int term_sequence_test(IC_Env *env)
{
    ETERM* et_array[4] = {
	erl_format("[{apa, 1, 23}, \"string\", {1.23, 45}]"),
	erl_format("[{banan, 1, 23}, \"string\", {1.23, 45}]"),
	erl_format("[{apelsin, 1, 23}, \"string\", {1.23, 45}]"),
	erl_format("[{mango, 1, 23}, \"string\", {1.23, 45}]")};
    m_etseq etsi = {4, 4, et_array}, *etso, *etsr;

    fprintf(stdout, "\n======== m_i_term_sequence test ======\n\n");
    etsr = m_i_term_sequence_test(NULL, &etsi, &etso, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_etseq(&etsi, etso) && cmp_etseq(&etsi, etsr));
    if (!cmp_etseq(&etsi, etso)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_etseq(&etsi);
	fprintf(stdout, "got:\n");
	print_etseq(etso);
    }
    if (!cmp_etseq(&etsi, etsr)) {
	fprintf(stdout, " result error, sent:\n");
	print_etseq(&etsi);
	fprintf(stdout, "got:\n");
	print_etseq(etsr);
    }
    free_etseq_buf(&etsi);
    free_etseq_buf(etso);
    free_etseq_buf(etsr);
    CORBA_free(etso);
    CORBA_free(etsr);
    return -1;
}
Beispiel #2
0
ETERM * new_image_blank(ETERM *arg, int c_node) { 
    int stride, cbufsize, status, key_length;
    ETERM *width, *height;
    cairo_context *ctx = NULL;             
    width = erl_element(1, arg);
    height = erl_element(2, arg);
    stride = ERL_INT_VALUE(width) * 4;
    cbufsize = ERL_INT_VALUE(height) * stride;
    ctx = malloc(sizeof(cairo_context));
    if (ctx) {
        ctx->cbuf = (byte *)malloc(cbufsize);
        if (ctx->cbuf) {
            memset(ctx->cbuf, 0, cbufsize);
            ctx->sf = cairo_image_surface_create_for_data(ctx->cbuf, 
                    CAIRO_FORMAT_ARGB32, ERL_INT_VALUE(width), 
                    ERL_INT_VALUE(height), stride);
            ctx->cr = cairo_create(ctx->sf);
            return erl_format("{c_node, ~i, {ok, ~i}}", c_node, ctx);
        } else {
            free(ctx);
            return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
        }
    } else {
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
    erl_free_term(width);
    erl_free_term(height);
}
Beispiel #3
0
void
handle_last(ETERM *msg)
{
  ETERM *ecols, *erows, *resp;

  if (results == NULL) {
    resp = erl_format("{error, result_set_does_not_exist}");
    write_msg(resp);
    erl_free_term(resp);

    return;
  }

  mysql_stmt_data_seek(sth, numrows - 1);
  resultoffset = numrows;

  ecols = make_cols();
  erows = make_rows(1);
  resp = erl_format("{selected, ~w, ~w}", ecols, erows);
  erl_free_term(erows);

  erl_free_term(ecols);
  write_msg(resp);
  erl_free_term(resp);
}
Beispiel #4
0
void
handle_prev(ETERM *msg)
{
  ETERM *ecols, *erows, *resp;

  if (results == NULL) {
    resp = erl_format("{error, result_set_does_not_exist}");
    write_msg(resp);
    erl_free_term(resp);

    return;
  }

  ecols = make_cols();
  if (resultoffset <= 1) {
    resp = erl_format("{selected, ~w, []}", ecols);
  } else {
    resultoffset--;
    mysql_stmt_data_seek(sth, resultoffset - 1);
    erows = make_rows(1);
    resp = erl_format("{selected, ~w, ~w}", ecols, erows);
    erl_free_term(erows);
  }

  erl_free_term(ecols);
  write_msg(resp);
  erl_free_term(resp);
}
Beispiel #5
0
ETERM * rel_curve_to(ETERM* arg, int c_node) {
    ETERM *c1x, *c1y, *c2x, *c2y, *x, *y;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        c1x = erl_element(2, arg);  
        c1y = erl_element(3, arg); 
        c2x = erl_element(4, arg);  
        c2y = erl_element(5, arg);
        x = erl_element(6, arg);  
        y = erl_element(7, arg);
        cairo_rel_curve_to(ctx->cr, val(c1x), 
            val(c1y),
            val(c2x),
            val(c2y),
            val(x),
            val(y));
        erl_free_term(c1x);
        erl_free_term(c1y);
        erl_free_term(c2x);
        erl_free_term(c2y);
        erl_free_term(x);
        erl_free_term(y);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #6
0
static int hello_getattr(const char *path, struct stat *stbuf)
{
	ETERM * response = erl_rpc(FERL_DATA->erlang_fd,"gen_server","call",erl_format("[nefs,{get_attr,~s}]",path));
	ETERM * pattern = erl_format("{directory,Mode,Nlink}");
	ETERM * pattern2 = erl_format("{file,Mode,Nlink,Size}");
        int res = 0;
	memset(stbuf, 0, sizeof(struct stat));

	if(erl_match(pattern, response)) { //directory
		ETERM * Mode = erl_var_content(pattern, "Mode");
		ETERM * Nlink = erl_var_content(pattern, "Nlink");
		if(ERL_IS_INTEGER(Nlink) && ERL_IS_INTEGER(Mode)){
			stbuf->st_mode = S_IFDIR | ERL_INT_VALUE(Mode); //permissions
        	        stbuf->st_nlink = ERL_INT_VALUE(Nlink); // directories have the number of files in them
		}else{
			res = -ENOENT;
		}
	}else if(erl_match(pattern2, response)){ //file
		ETERM * Mode = erl_var_content(pattern2, "Mode");
                ETERM * Nlink = erl_var_content(pattern2, "Nlink");
		ETERM * Size = erl_var_content(pattern2, "Size");
                if(ERL_IS_INTEGER(Nlink) && ERL_IS_INTEGER(Mode) && ERL_IS_INTEGER(Size)){

			stbuf->st_mode = S_IFREG | ERL_INT_VALUE(Mode); //permissions
			stbuf->st_nlink = ERL_INT_VALUE(Nlink); //files only have 1
			stbuf->st_size = ERL_INT_VALUE(Size); // length of the file
                }else{
                        res = -ENOENT;
                }
	}else{
		res = -ENOENT;
	}	

	return res;
}
Beispiel #7
0
static int hello_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
			 off_t offset, struct fuse_file_info *fi)
{
	int res = 0;
	ETERM * response = erl_rpc(FERL_DATA->erlang_fd,"gen_server","call",erl_format("[nefs,{read_dir,~s}]",path));
	ETERM * pattern = erl_format("{ok,Listing}");	
	if(erl_match(pattern, response)) { //directory
		ETERM * Tail = erl_var_content(pattern, "Listing");
		if(ERL_IS_LIST(Tail)){
			while(!ERL_IS_EMPTY_LIST(Tail)){
				ETERM * elem = ERL_CONS_HEAD(Tail);
				// add in the links to the previous folders
				filler(buf, ".", NULL, 0);
        			filler(buf, "..", NULL, 0);
				
				// add in the folders contents
				if(ERL_IS_LIST(elem)){
					filler(buf,(char *)ERL_BIN_PTR(elem),NULL,0);
				}else{
					res = -ENOENT;
					break;
				}
				Tail = ERL_CONS_TAIL(Tail);
			}
		}else{
			res = -ENOENT;
		}
	}else{
                res = -ENOENT;
        }

        return res;
}
Beispiel #8
0
ETERM * stroke_preserve(ETERM* arg, int c_node) {   
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        cairo_stroke_preserve(ctx->cr);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #9
0
ETERM * close_image(ETERM* arg, int c_node) {
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        cairo_destroy(ctx->cr);
        cairo_surface_destroy(ctx->sf); 
        free(ctx->cbuf);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #10
0
ETERM * set_line_width(ETERM* arg, int c_node) {
    ETERM *width;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        width = erl_element(2, arg);   
        cairo_set_line_width(ctx->cr, ERL_INT_VALUE(width));
        erl_free_term(width);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #11
0
ETERM * show_text(ETERM* arg, int c_node) {
    ETERM *text;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        text = erl_element(2, arg);   
        cairo_show_text(ctx->cr, (char *)ERL_ATOM_PTR(text));
        erl_free_term(text);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #12
0
ETERM * set_font_size(ETERM* arg, int c_node) {
    ETERM *size;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
      size = erl_element(2, arg);   
        cairo_set_font_size(ctx->cr, val(size));
        erl_free_term(size);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #13
0
ETERM * rotate(ETERM* arg, int c_node) {
    ETERM *angle;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        angle = erl_element(2, arg);   
        cairo_rotate(ctx->cr, val(angle));
        erl_free_term(angle);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #14
0
ETERM * set_operator(ETERM* arg, int c_node) {
    ETERM *operator;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        operator = erl_element(2, arg);    
        cairo_set_operator(ctx->cr, ERL_INT_VALUE(operator));
        erl_free_term(operator);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #15
0
ETERM * write_to_png(ETERM* arg, int c_node) {
    int status;
    ETERM *file;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) { 
        file = erl_element(2, arg); 
        status = cairo_surface_write_to_png(ctx->sf, (char *)ERL_ATOM_PTR(file));
        erl_free_term(file);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #16
0
ETERM * text_extents(ETERM* arg, int c_node) {
    ETERM *text;
    cairo_text_extents_t extents;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        text = erl_element(2, arg);
        cairo_text_extents (ctx->cr, (char *)ERL_ATOM_PTR(text), &extents);        
        erl_free_term(text);
        return erl_format("{c_node, ~i, {~f, ~f}}", c_node, extents.width, extents.height);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #17
0
ETERM * rel_line_to(ETERM* arg, int c_node) {
    ETERM *x, *y;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        x = erl_element(2, arg);  
        y = erl_element(3, arg); 
        cairo_rel_line_to(ctx->cr, val(x), val(y));
        erl_free_term(x);
        erl_free_term(y);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #18
0
ETERM * translate(ETERM* arg, int c_node) {
    ETERM *tx, *ty;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        tx = erl_element(2, arg);  
        ty = erl_element(3, arg); 
        cairo_translate(ctx->cr, val(tx), val(ty));
        erl_free_term(tx);
        erl_free_term(ty);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
Beispiel #19
0
ETERM * scale(ETERM* arg, int c_node) {
    ETERM *sx, *sy;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        sx = erl_element(2, arg);  
        sy = erl_element(3, arg); 
        cairo_scale(ctx->cr, val(sx), val(sy));
        erl_free_term(sx);
        erl_free_term(sy);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else { 
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
static int
process_hashpw(ETERM *pid, ETERM *data)
{
  int retval = 0;
  ETERM *pattern, *pwd, *slt;
  char *password, *salt;
  char *ret = NULL;
  pattern = erl_format("{Pass, Salt}");
  if (erl_match(pattern, data)) {
    pwd = erl_var_content(pattern, "Pass");
    password = erl_iolist_to_string(pwd);
    slt = erl_var_content(pattern, "Salt");
    salt = erl_iolist_to_string(slt);
    if (NULL == (ret = bcrypt(password, salt)) ||
        0 == strcmp(ret, ":")) {
      retval = process_reply(pid, CMD_HASHPW, "Invalid salt");
    } else {
      retval = process_reply(pid, CMD_HASHPW, ret);
    }
    erl_free_term(pwd);
    erl_free_term(slt);
    erl_free(password);
    erl_free(salt);
  };
  erl_free_term(pattern);
  return retval;
}
Beispiel #21
0
static int typedef_test(IC_Env *env)
{
    m_banan mbi, mbo;		/* erlang_port */
    m_apa mai;			/* ETERM* */
    m_apa mao = NULL;
    long tl;

    strcpy(mbi.node,"node");
    mbi.id = 15;
    mbi.creation = 1;

    fprintf(stdout, "\n======== m_i_typedef test ======\n\n");
    mai = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]");
    tl = m_i_typedef_test(NULL, mai, &mbi, &mao, &mbo, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(erl_match(mai, mao) && cmp_port(&mbi, &mbo) && tl == 4711);
    if (!erl_match(mai, mao)) {
	fprintf(stdout, " out parameter error (term), sent:\n");
	print_term(mai);
	fprintf(stdout, "got:\n");
	print_term(mao);
    }
    if (!cmp_port(&mbi, &mbo)) {
	fprintf(stdout, " out parameter error (port), sent:\n");
	print_port(&mbi);
	fprintf(stdout, "got:\n");
	print_port(&mbo);
    }
    if (tl != 4711) {
	fprintf(stdout, " result error, sent: 4711, got %ld\n", tl);
    }
    erl_free_term(mai);
    erl_free_term(mao);
    return -1;
} 
Beispiel #22
0
static int term_test(IC_Env *env)
{
    ETERM *ti, *to, *tr;

    ti = erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]");

    fprintf(stdout, "\n======== m_i_term test ======\n\n");
    tr = m_i_term_test(NULL, ti, &to, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(erl_match(ti, to) && erl_match(ti, tr));
    if (!erl_match(ti, to)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_term(ti);
	fprintf(stdout, "got:\n");
	print_term(to);
    }
    if (!erl_match(ti, tr)) {
	fprintf(stdout, " result error, sent:\n");
	print_term(ti);
	fprintf(stdout, "got:\n");
	print_term(tr);
    }
    erl_free_term(ti);
    erl_free_term(to);
    erl_free_term(tr);
    return -1;
}
Beispiel #23
0
erlang_pid *erl_whereis(int fd, const char *name)
{
  ETERM *reply;
  ETERM *n;
  /* FIXME problem for threaded ? */
  static erlang_pid pid;
  
  n = erl_format("[~a]",name);
  reply = erl_rpc(fd,"erlang","whereis",n);
  erl_free_term(n);

  if (reply && (ERL_IS_PID(reply))) {
    char *node;
    node =  ERL_PID_NODE(reply);
    strcpy(pid.node,node);
    pid.num = ERL_PID_NUMBER(reply);
    pid.serial = ERL_PID_SERIAL(reply);
    pid.creation = ERL_PID_CREATION(reply);
    erl_free_term(reply);
    return &pid;
  }

  if (reply) erl_free_term(reply);
  return NULL;
}
Beispiel #24
0
void vaskerl_loop (int fd)
{
    unsigned char buf[MAX_BUF];

    while (1)
    {
        ErlMessage emsg;
        int got = erl_receive_msg(fd, buf, MAX_BUF, &emsg);

        if (got == ERL_TICK)
            continue;
        else if (got == ERL_ERROR)
        {
            fprintf(stderr, "erl_error\n");
            break;
        }

        if (emsg.type == ERL_REG_SEND)
        {
            printf("Got something...\n");

            ETERM *resp = erl_format("{cnode, \"hello\"}");
            erl_send(fd, emsg.from, resp);
            erl_free_term(resp);

            erl_free_term(emsg.from);
            erl_free_term(emsg.msg);
        }
    }
}
Beispiel #25
0
static int hello_read(const char *path, char *buf, size_t size, off_t offset,
		      struct fuse_file_info *fi)
{
	int ret_bytes = 0;
        ETERM * response = erl_rpc(FERL_DATA->erlang_fd,"file","pread",erl_format("[~s,{bof,~i},~i]",offset,size));
        ETERM * pattern = erl_format("{ok,Data}");
	if(erl_match(pattern, response)) {
                ETERM * Data = erl_var_content(pattern, "Data");
                if(ERL_IS_BINARY(Data)){
			ret_bytes = ERL_BIN_SIZE(Data);
			char * data = ERL_BIN_PTR(Data);
			memcpy(buf,data,size); //copy the data over into the buffer
                }
        }
        return ret_bytes;
}
Beispiel #26
0
static int term_struct_test(IC_Env *env)
{
    m_et eti = { erl_format("[{hej, 1, 23}, \"string\", {1.23, 45}]"), 
		 121212 };
    m_et eto, etr;

    fprintf(stdout, "\n======== m_i_term_struct test ======\n\n");
    etr = m_i_term_struct_test(NULL, &eti, &eto, env);
    CHECK_EXCEPTION(env);
    RETURN_IF_OK(cmp_et(&eti, &eto) && cmp_et(&eti, &etr));
    if (!cmp_et(&eti, &eto)) {
	fprintf(stdout, " out parameter error, sent:\n");
	print_et(&eti);
	fprintf(stdout, "got:\n");
	print_et(&eto);
    }
    if (!cmp_et(&eti, &etr)) {
	fprintf(stdout, " result error, sent:\n");
	print_et(&eti);
	fprintf(stdout, "got:\n");
	print_et(&etr);
    }
    free_et(&eti);
    free_et(&eto);
    free_et(&etr);
    return -1;
}
static int
process_encode_salt(ETERM *pid, ETERM *data)
{
  int retval = 0;
  ETERM *pattern, *cslt, *lr;
  byte *csalt = NULL;
  long log_rounds = -1;
  int csaltlen = -1;
  char ret[64];
  pattern = erl_format("{Csalt, LogRounds}");
  if (erl_match(pattern, data)) {
    cslt = erl_var_content(pattern, "Csalt");
    csaltlen = ERL_BIN_SIZE(cslt);
    csalt = ERL_BIN_PTR(cslt);
    lr = erl_var_content(pattern, "LogRounds");
    log_rounds = ERL_INT_UVALUE(lr);
    if (16 != csaltlen) {
      retval = process_reply(pid, CMD_SALT, "Invalid salt length");
    } else if (log_rounds < 4 || log_rounds > 31) {
      retval = process_reply(pid, CMD_SALT, "Invalid number of rounds");
    } else {
      encode_salt(ret, (u_int8_t*)csalt, csaltlen, log_rounds);
      retval = process_reply(pid, CMD_SALT, ret);
    }
    erl_free_term(cslt);
    erl_free_term(lr);
  };
  erl_free_term(pattern);
  return retval;
}
Beispiel #28
0
ETERM * set_source_surface(ETERM* arg, int c_node) {
    ETERM *surface, *x, *y;
    cairo_context *ctx = get_cairo_context(arg);
    if (ctx) {
        surface = erl_element(2, arg); 
        x = erl_element(3, arg);
        y = erl_element(4, arg);
        cairo_set_source_surface(ctx->cr, ptr(surface), val(x), val(y));
        erl_free_term(surface);
        erl_free_term(x);
        erl_free_term(y);
        return erl_format("{c_node, ~i, ok}", c_node);
    } else {
        return erl_format("{c_node, ~i, {error, '~s'}}", c_node, ERR_CONTEXT);
    }
}
static int
process_command(unsigned char *buf)
{
  int retval = 0;
  ETERM *pattern, *tuple, *cmd, *port, *data;
  pattern = erl_format("{Cmd, Port, Data}");
  tuple = erl_decode(buf);
  if (erl_match(pattern, tuple)) {
    cmd = erl_var_content(pattern, "Cmd");
    port = erl_var_content(pattern, "Port");
    data = erl_var_content(pattern, "Data");
    switch (ERL_INT_VALUE(cmd)) {
    case CMD_SALT:
      retval = process_encode_salt(port, data);
      break;
    case CMD_HASHPW:
      retval = process_hashpw(port, data);
      break;
    };
    erl_free_term(cmd);
    erl_free_term(port);
    erl_free_term(data);
  }
  erl_free_term(pattern);
  erl_free_term(tuple);
  return retval;
}
Beispiel #30
0
ETERM *
make_row()
{
  ETERM **rowtup, *rc;
  unsigned int i;

  rowtup = (ETERM **)safe_malloc(numfields * sizeof(ETERM *));
  for (i = 0; i < numfields; i++) {
    if (*r_bind[i].is_null)
      rowtup[i] = erl_mk_atom("null");
    else
      rowtup[i] = erl_mk_estring(r_bind[i].buffer, *r_bind[i].length);
  }

  rc = erl_mk_tuple(rowtup, numfields);
  if (rc == NULL) {
    ETERM *resp;

    resp = erl_format("{error, {erl_mk_tuple, ~i}}", numfields);
    write_msg(resp);
    erl_free_term(resp);
    exit(3);
  }

  for (i = 0; i < numfields; i++)
    erl_free_term(rowtup[i]);
  free(rowtup);

  return rc;
}