예제 #1
0
void eNotifyCallback(int watchID, int action, const void* rootPath, int rootPathLength, const void* filePath, int filePathLength)
{
 // MAX_FILE_PATHNAME_LENGTH * 2 because we are passing 2 paths
  byte buf[MAX_FILE_PATHNAME_LENGTH*2];
  ETERM *tuplep;

  // Build response
  ETERM *tupleArray[4];
  tupleArray[0] = erl_mk_int(watchID);
  tupleArray[1] = erl_mk_int(action);
  tupleArray[2] = erl_mk_binary(rootPath, rootPathLength);
  tupleArray[3] = erl_mk_binary(filePath, filePathLength);
  tuplep = erl_mk_tuple(tupleArray, 4);

  erl_encode(tuplep, buf);
  write_cmd(buf, erl_term_len(tuplep));

  // free contents from tupleArray
  erl_free_array(tupleArray, 4);
}
예제 #2
0
파일: eterm_test.c 프로젝트: andreas23/otp
static ETERM*
all_types(void)
{
    ETERM* t;
    ETERM* terms[3];
    int i;
    static char a_binary[] = "A binary";

#define CONS_AND_FREE(expr, tail) \
  do { \
    ETERM* term = expr; \
    ETERM* nl = erl_cons(term, tail); \
    erl_free_term(term); \
    erl_free_term(tail); \
    tail = nl; \
  } while (0)

    t = erl_mk_empty_list();

    CONS_AND_FREE(erl_mk_atom("I am an atom"), t);
    CONS_AND_FREE(erl_mk_binary("A binary", sizeof(a_binary)-1), t);
    CONS_AND_FREE(erl_mk_float(3.0), t);
    CONS_AND_FREE(erl_mk_int(0), t);
    CONS_AND_FREE(erl_mk_int(-1), t);
    CONS_AND_FREE(erl_mk_int(1), t);

    CONS_AND_FREE(erl_mk_string("A string"), t);

    terms[0] = erl_mk_atom("element1");
    terms[1] = erl_mk_int(42);
    terms[2] = erl_mk_int(767);
    CONS_AND_FREE(erl_mk_tuple(terms, ASIZE(terms)), t);
    for (i = 0; i < ASIZE(terms); i++) {
	erl_free_term(terms[i]);
    }

    CONS_AND_FREE(erl_mk_pid("kalle@localhost", 3, 2, 1), t);
    CONS_AND_FREE(erl_mk_pid("abcdefghijabcdefghij@localhost", 3, 2, 1), t);
    CONS_AND_FREE(erl_mk_port("kalle@localhost", 4, 1), t);
    CONS_AND_FREE(erl_mk_port("abcdefghijabcdefghij@localhost", 4, 1), t);
    CONS_AND_FREE(erl_mk_ref("kalle@localhost", 6, 1), t);
    CONS_AND_FREE(erl_mk_ref("abcdefghijabcdefghij@localhost", 6, 1), t);
    return t;

#undef CONS_AND_FREE
}
예제 #3
0
void * handle_command(void *buf){
  ETERM *tuplep, *file;
  ETERM *fnp;
  tuplep = erl_decode(buf);
  fnp = erl_element(1, tuplep);
  char * path = "./priv/sample_images/ABST.00000000.tif";
  IplImage *source = cvLoadImage( path, CV_LOAD_IMAGE_GRAYSCALE );
  CvMat* pngImage = img(source);

  //if (strncmp(ERL_ATOM_PTR(fnp), "img", 3) == 0) {
    // no-op for now?
  //}

  file = erl_mk_binary((char *)pngImage->data.ptr, pngImage->cols);
  erl_encode(file, buf);
  write_cmd(buf, erl_term_len(file));

  erl_free_compound(tuplep);
  erl_free_term(fnp);
  erl_free_term(file);
}
예제 #4
0
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;
}
예제 #5
0
파일: main.c 프로젝트: mocchira/resizerl
int main(int argc, char* argv[]) {
  ETERM *tuplep, *fnp, *pathp, *binp, *widthp, *heightp;
  ETERM *res_tuplep;
  ETERM *res_arrp[2];
  ETERM *res_ok_atomp, *res_error_atomp, *res_error_cause_atomp;

  int idx = 1;
  byte *buf = malloc(INIT_BUF_SIZE);
  int buf_len = INIT_BUF_SIZE;
  int res_len;

  erl_init(NULL, 0);

  //Create common atoms(ok, error)
  res_ok_atomp = erl_mk_atom("ok");
  res_error_atomp = erl_mk_atom("error");
  res_error_cause_atomp = erl_mk_atom("resize failed");

  while (read_cmd(&buf, &buf_len) > 0) {
    tuplep = erl_decode(buf);
    fnp     = erl_element(idx++, tuplep);
    pathp   = erl_element(idx++, tuplep);
    binp    = erl_element(idx++, tuplep);
    widthp  = erl_element(idx++, tuplep);
    heightp = erl_element(idx++, tuplep);
    
    if (strncmp(ERL_ATOM_PTR(fnp), "resize", 6) == 0) {
      char* algop = ERL_ATOM_PTR(fnp) + 6;
      resizerl_handler* rhp = (strncmp(algop, "_opencv", 7) == 0) ? resizerl_impls[0] : NULL;
      if (rhp == NULL) {
        exit(1);
      }
      // ERL_INT_VALUE, ERL_BIN_PTR, ERL_BIN_SIZE
      void* dp = NULL;
      rhp->exec(ERL_BIN_PTR(binp),
                ERL_BIN_SIZE(binp),
                ERL_BIN_PTR(pathp),
                ERL_BIN_SIZE(pathp),
                ERL_INT_VALUE(widthp),
                ERL_INT_VALUE(heightp), &dp);
      if (dp == NULL) {
        exit(2);
      }
      unsigned char* dst;
      int dst_size;
      rhp->get_result(dp, &dst, &dst_size);
      res_arrp[0] = res_ok_atomp;
      res_arrp[1] = erl_mk_binary((const char*)dst, dst_size);
      res_tuplep = erl_mk_tuple(res_arrp, 2);
      res_len = erl_term_len(res_tuplep);
      if (res_len > buf_len) {
        byte* new_buf = (byte*)realloc((void*)buf, res_len);
        if (new_buf == NULL) {
          exit(3);
        }
        buf = new_buf;
        buf_len = res_len;
      }
      erl_encode(res_tuplep, buf);
      write_cmd(buf, erl_term_len(res_tuplep));
      erl_free_term(res_arrp[1]);
      erl_free_term(res_tuplep);
      rhp->release(&dp);
    } else {
      res_arrp[0] = res_error_atomp;
      res_arrp[1] = res_error_cause_atomp;
      res_tuplep = erl_mk_tuple(res_arrp, 2);
      if (res_len > buf_len) {
        byte* new_buf = (byte*)realloc((void*)buf, res_len);
        if (new_buf == NULL) {
          exit(4);
        }
        buf = new_buf;
        buf_len = res_len;
      }
      erl_encode(res_tuplep, buf);
      write_cmd(buf, erl_term_len(res_tuplep));
      erl_free_term(res_tuplep);
    }

    erl_free_compound(tuplep);
    erl_free_term(fnp);
    erl_free_term(pathp);
    erl_free_term(binp);
    erl_free_term(widthp);
    erl_free_term(heightp);
    idx = 1;
  }
  // normal
  return 0;

}
예제 #6
0
파일: main.c 프로젝트: adabsurdum/libruftp
/**
  * Read an integer giving the maximum size of a fragment.
  */
int main( int argc, char *argv[] ) {

	int fail = 0;

	erl_init(NULL,0);
#ifdef _DEBUG
	openlog( "erlang-port", 0, LOG_USER );
	syslog( LOG_INFO, "%s is alive\n", argv[0] );
#endif
	while( ! fail ) {

		ETERM *fragsize_term = NULL;
		byte buf[100 /*WIRE_SIZEOF_INT*/];
		if( read_lpm( buf, sizeof(buf) ) <= 0 ) {
#ifdef _DEBUG
			syslog( LOG_ERR, "failed reading fragment size:\n" );
#endif
			break;
		}

		fragsize_term = erl_decode( buf );

		if( fragsize_term ) {

			ETERM **array;
			unsigned int count;
			unsigned int SIZEOF_FRAGMENT
				= ERL_INT_UVALUE(fragsize_term);
			erl_free_term( fragsize_term );

			if( SIZEOF_FRAGMENT == 0 /* the explicit signal to shutdown */ )
				break;

#ifdef _DEBUG
			syslog( LOG_INFO, "received sizeof fragment: %d\n", SIZEOF_FRAGMENT );
#endif

			count = min_packet_count( SIZEOF_IMAGE, SIZEOF_FRAGMENT );
			array = calloc( count, sizeof(ETERM*) );
			if( array ) {
				ETERM *frags;
				for(int i = 0; i < count; i++ ) {
					const size_t S
						= i+1 < count
						? SIZEOF_FRAGMENT
						: (SIZEOF_IMAGE % SIZEOF_FRAGMENT);
					array[i] = erl_mk_binary(
						TEST_IMAGE + i*SIZEOF_FRAGMENT, S );
					if( array[i] == NULL ) {
						count = i; // ...for erl_free_array below.
						fail = 1;
						break;
					}
				}
				if( fail )
					goto cleanup;
				frags = erl_mk_list( array, count );
				if( frags ) {
					const int nbyte = erl_term_len( frags );
					byte *buf = calloc( nbyte, sizeof(byte) );
					if( buf ) {
						if( erl_encode( frags, buf ) == nbyte ) {
							if( write_lpm( buf, nbyte ) != nbyte )
								fail = 1;
						} else
							fail = 1;
						free( buf );
					} else
						fail = 1;
				} else
					fail = 1;
cleanup:
				erl_free_array( array, count );
				free( array );
			}
		} else
			break;
	}
#ifdef _DEBUG
	closelog();
#endif
	return 0;
}