Ejemplo n.º 1
0
Val   _lib7_Sock_frominetaddr   (Task* task,  Val arg)   {
    //=======================
    //
    // Mythryl type:   Internet_Address -> (Internet_Address, Int)
    //
    // Given a INET-domain socket address, return the INET address and port number.
    //
    // This fn gets bound as   from_inet_addr   in:
    //
    //     src/lib/std/src/socket/internet-socket.pkg

										ENTER_MYTHRYL_CALLABLE_C_FN("_lib7_Sock_frominetaddr");

    struct sockaddr_in*	addr
        =
        GET_VECTOR_DATACHUNK_AS( struct sockaddr_in*, arg );			// Last use of 'arg'.

    ASSERT( addr->sin_family == AF_INET );

    Val data   =  make_biwordslots_vector_sized_in_bytes__may_heapclean( task, &(addr->sin_addr), sizeof(struct in_addr), NULL );
    Val inAddr =  make_vector_header( task,  UNT8_RO_VECTOR_TAGWORD, data,  sizeof(struct in_addr) );

    return  make_two_slot_record(task, inAddr, TAGGED_INT_FROM_C_INT(ntohs(addr->sin_port)) );
}
Ejemplo n.º 2
0
Val   _lib7_P_ProcEnv_getpgrp   (Task* task,  Val arg)   {
    //=======================
    //
    // Mythryl type:   Void -> Int
    //
    // Return process group.
    //
    // This fn gets bound as   get_process_group   in:
    //
    //     src/lib/std/src/psx/posix-id.pkg

									    ENTER_MYTHRYL_CALLABLE_C_FN(__func__);

    RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL );
	//
	int pgrp = getpgrp();
	//
    RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );

    Val result = TAGGED_INT_FROM_C_INT( pgrp );

									    EXIT_MYTHRYL_CALLABLE_C_FN(__func__);
    return result;
}
Ejemplo n.º 3
0
Val   _lib7_P_ProcEnv_setgid   (Task* task,  Val arg)   {
    //======================
    //
    // Mythryl type:  Unt -> Void
    //
    // Set group id.
    //
    // This fn gets bound as   set_group_id   in:
    //
    //     src/lib/std/src/psx/posix-id.pkg

									    ENTER_MYTHRYL_CALLABLE_C_FN(__func__);

    RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, &arg );
	//
	int status =  setgid( WORD_LIB7toC( arg ));
	//
    RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );

    Val result =  RETURN_VOID_EXCEPT_RAISE_SYSERR_ON_NEGATIVE_STATUS__MAY_HEAPCLEAN(task, status, NULL);

									    EXIT_MYTHRYL_CALLABLE_C_FN(__func__);
    return result;
}
Ejemplo n.º 4
0
Val   _lib7_netdb_get_host_by_address   (Task* task,  Val arg)   {
    //===============================
    //
    // Mythryl type:   Internet_Address -> Null_Or(  (String, List(String), Raw_Address_Family, List(Internet_Address))  )
    //
    // This fn gets bound as   get_host_by_addr'   in:
    //
    //     src/lib/std/src/socket/dns-host-lookup.pkg

															ENTER_MYTHRYL_CALLABLE_C_FN("_lib7_netdb_get_host_by_address");

    ASSERT (sizeof(struct in_addr) == GET_VECTOR_LENGTH( arg ));

    struct in_addr*  heap_arg =  (struct in_addr*) HEAP_STRING_AS_C_STRING( arg );					// Last use of 'arg'.
    struct in_addr      c_arg = *heap_arg;

    RELEASE_MYTHRYL_HEAP( task->pthread, "_lib7_netdb_get_host_by_address", NULL );
	//
	struct hostent* result = gethostbyaddr (&c_arg, sizeof(struct in_addr), AF_INET);
	//
    RECOVER_MYTHRYL_HEAP( task->pthread, "_lib7_netdb_get_host_by_address" );

    return  _util_NetDB_mkhostent ( task, result );									// _util_NetDB_mkhostent	def in    src/c/lib/socket/util-mkhostent.c
}
Ejemplo n.º 5
0
Val   _lib7_Sock_recvbuffrom   (Task* task,  Val arg)   {
    //======================
    //
    // Mythryl type:   (Socket, rw_vector_of_one_byte_unts::Rw_Vector, Int, Int, Bool, Bool) -> (Int, Addr)
    //
    // The arguments are:
    //     socket,
    //     data buffer,
    //     start position,
    //     number of bytes,
    //     OOB flag
    //     peek flag.
    //
    // The result is:
    //     number of bytes read
    //     source address.
    //
    // This fn gets bound as   recv_from_a   in:
    //
    //     src/lib/std/src/socket/socket-guts.pkg

										ENTER_MYTHRYL_CALLABLE_C_FN(__func__);

    char       address_buf[  MAX_SOCK_ADDR_BYTESIZE ];
    socklen_t  address_len = MAX_SOCK_ADDR_BYTESIZE;

    int	  socket  = GET_TUPLE_SLOT_AS_INT( arg, 0);
//  Val   buf     = GET_TUPLE_SLOT_AS_VAL( arg, 1);				// Mythryl buffer to read bytes into.	// We'll fetch this after the call, since it may move around during the call.
    int   offset  = GET_TUPLE_SLOT_AS_INT( arg, 2);				// Offset within buf to read bytes into.
    int	  nbytes  = GET_TUPLE_SLOT_AS_INT( arg, 3);				// Number of bytes to read.

    int	  flag = 0;

    int	   n;

    if (GET_TUPLE_SLOT_AS_VAL(arg, 4) == HEAP_TRUE) flag |= MSG_OOB;
    if (GET_TUPLE_SLOT_AS_VAL(arg, 5) == HEAP_TRUE) flag |= MSG_PEEK;

    // We cannot reference anything on the Mythryl heap
    // between RELEASE_MYTHRYL_HEAP and RECOVER_MYTHRYL_HEAP
    // because garbage collection might be moving
    // it around, so allocate a C-side read buffer:
    //
    Mythryl_Heap_Value_Buffer  readbuf_buf;
    //
    {   char* c_readbuf =  buffer_mythryl_heap_nonvalue( &readbuf_buf, nbytes );

	RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, &arg );		// 'arg' is still live here!
	    //
	    do {
		//
		n = recvfrom( socket,
			      c_readbuf,
			      nbytes,
			      flag,
			      (struct sockaddr *)address_buf,
			      &address_len
			    );
	    } while (n < 0 && errno == EINTR);					// Restart if interrupted by a SIGALRM or SIGCHLD or whatever.
	    //
	RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );

	if (n < 0) {
	    unbuffer_mythryl_heap_value( &readbuf_buf );
	    return RAISE_SYSERR__MAY_HEAPCLEAN(task, status, NULL);
	}

	Val   buf      =  GET_TUPLE_SLOT_AS_VAL( arg, 1);			// Mythryl buffer to read bytes into.
	char* bufstart =  HEAP_STRING_AS_C_STRING(buf) + offset;

	memcpy( bufstart, c_readbuf, n);

	unbuffer_mythryl_heap_value( &readbuf_buf );
    }

    Val	data    =  make_biwordslots_vector_sized_in_bytes__may_heapclean(   task, address_buf,                   address_len, NULL );
    Val address =  make_vector_header(					    task,  UNT8_RO_VECTOR_TAGWORD, data, address_len);

    Val result  =  make_two_slot_record(task,  TAGGED_INT_FROM_C_INT(n), address);

										EXIT_MYTHRYL_CALLABLE_C_FN(__func__);
    return result;
}
Ejemplo n.º 6
0
Val   _lib7_P_FileSys_utime   (Task* task,  Val arg)   {
    //=====================
    //
    // Mythryl type: (String, one_word_int::Int, one_word_int::Int) -> Void
    //                name    actime      modtime
    //
    // Sets file access and modification times.
    // If actime = -1, then set both to current time.
    //
    // This fn gets bound as   utime'   in:
    //
    //     src/lib/std/src/psx/posix-file.pkg
    //     src/lib/std/src/psx/posix-file-system-64.pkg

									    ENTER_MYTHRYL_CALLABLE_C_FN(__func__);

    int status;

    Val	    path    =  GET_TUPLE_SLOT_AS_VAL( arg, 0);
    time_t  actime  =  TUPLE_GET_INT1(        arg, 1);
    time_t  modtime =  TUPLE_GET_INT1(        arg, 2);

    char* heap_path =  HEAP_STRING_AS_C_STRING( path );

    // We cannot reference anything on the Mythryl
    // heap between RELEASE_MYTHRYL_HEAP and RECOVER_MYTHRYL_HEAP
    // because garbage collection might be moving
    // it around, so copy heap_path into C storage: 
    //
    Mythryl_Heap_Value_Buffer  path_buf;
    //
    {	char* c_path
	    = 
	    buffer_mythryl_heap_value( &path_buf, (void*) heap_path, strlen( heap_path ) +1 );		// '+1' for terminal NUL on string.


	if (actime == -1) {

	    RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL );
		//
		status = utime( c_path, NULL );
		//
	    RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );

	} else {

	    struct utimbuf tb;

	    tb.actime = actime;
	    tb.modtime = modtime;

	    RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL );
		//
		status = utime( c_path, &tb );
		//
	    RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );
	}

	unbuffer_mythryl_heap_value( &path_buf );
    }

    Val result = RETURN_VOID_EXCEPT_RAISE_SYSERR_ON_NEGATIVE_STATUS__MAY_HEAPCLEAN(task, status, NULL);

									    EXIT_MYTHRYL_CALLABLE_C_FN(__func__);
    return result;
}
Val   get_or_set_socket_linger_option   (Task* task,  Val arg)   {
    //===============================
    //
    // Mythryl type: (Socket_Fd, Null_Or(Null_Or(Int))) -> Null_Or(Int)
    //
    // Set/get the SO_LINGER option as follows:
    //   NULL		=> get current setting
    //   THE(NULL)	=> disable linger
    //   THE(THE t)	=> enable linger with timeout t.
    //
    // This function gets bound as   ctl_linger   in:
    //
    //     src/lib/std/src/socket/socket-guts.pkg
    //

													ENTER_MYTHRYL_CALLABLE_C_FN(__func__);

    int  socket = GET_TUPLE_SLOT_AS_INT( arg, 0 );
    Val	    ctl = GET_TUPLE_SLOT_AS_VAL( arg, 1 );							// Last use of 'arg'.

    struct linger   optVal;
    int		    status;

    if (ctl == OPTION_NULL) {
        //
	socklen_t  optSz =  sizeof( struct linger );

	RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL );
	    //
	    status =  getsockopt( socket, SOL_SOCKET, SO_LINGER, (sockoptval_t)&optVal, &optSz );
	    //
	RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );

	ASSERT( status < 0  ||  optSz == sizeof( struct linger ));
	//
    } else {
	//
	ctl = OPTION_GET(ctl);

	if (ctl == OPTION_NULL) {
	    optVal.l_onoff = 0;	    // Argument is THE(NULL); disable linger.
	} else {
	    optVal.l_onoff = 1;	    // argument is THE t; enable linger.
	    optVal.l_linger = TAGGED_INT_TO_C_INT(OPTION_GET(ctl));
	}

	RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL );
	    //
	    status = setsockopt (socket, SOL_SOCKET, SO_LINGER, (sockoptval_t)&optVal, sizeof(struct linger));
	    //
	RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );
    }

    if (status < 0)  		return RAISE_SYSERR__MAY_HEAPCLEAN(task, status, NULL);
    if (optVal.l_onoff == 0)    return OPTION_NULL;

    Val result =   OPTION_THE(  task,  TAGGED_INT_FROM_C_INT( optVal.l_linger )  );

									    EXIT_MYTHRYL_CALLABLE_C_FN(__func__);
    return result;
}
Ejemplo n.º 8
0
Val   _lib7_P_FileSys_readlink   (Task* task,  Val arg)   {
    //========================
    //
    // Mythryl type:  String -> String
    //
    // Read the value of a symbolic link.
    //
    // The following implementation assumes that the system readlink
    // fills the given buffer as much as possible, without nul-termination,
    // and returns the number of bytes copied. If the buffer is not large
    // enough, the return value will be at least the buffer size. In that
    // case, we find out how big the link really is, allocate a buffer to
    // hold it, and redo the readlink.
    //
    // Note that the above semantics are not those of POSIX, which requires
    // null-termination on success, and only fills the buffer up to at most 
    // the penultimate byte even on failure.
    //
    // Should this be written to avoid the extra copy, using heap memory?
    //
    // This fn gets bound as   readlink   in:
    //
    //     src/lib/std/src/posix-1003.1b/posix-file.pkg
    //     src/lib/std/src/posix-1003.1b/posix-file-system-64.pkg

									    ENTER_MYTHRYL_CALLABLE_C_FN("_lib7_P_FileSys_readlink");

    struct stat  sbuf;
    int          len;
    int          result;

    char* heap_path = HEAP_STRING_AS_C_STRING( arg );

    char  buf[MAXPATHLEN];

    // We cannot reference anything on the Mythryl
    // heap between RELEASE_MYTHRYL_HEAP and RECOVER_MYTHRYL_HEAP
    // because garbage collection might be moving
    // it around, so copy heap_path into C storage: 
    //
    Mythryl_Heap_Value_Buffer  path_buf;
    //
    {   char* c_path
	    = 
	    buffer_mythryl_heap_value( &path_buf, (void*) heap_path, strlen( heap_path ) +1 );		// '+1' for terminal NUL on string.

	RELEASE_MYTHRYL_HEAP( task->pthread, "_lib7_P_FileSys_readlink", NULL );
	    //
	    len = readlink(c_path, buf, MAXPATHLEN);
	    //
	RECOVER_MYTHRYL_HEAP( task->pthread, "_lib7_P_FileSys_readlink" );

	unbuffer_mythryl_heap_value( &path_buf );
    }

    if (len < 0)   return RAISE_SYSERR__MAY_HEAPCLEAN(task, len, NULL);

    if (len < MAXPATHLEN) {
        //
	buf[len] = '\0';
	return make_ascii_string_from_c_string__may_heapclean (task, buf, NULL);
    }


    // Buffer not big enough.

    // Determine how big the link text is and allocate a buffer.

    {   char* c_path
	    = 
	    buffer_mythryl_heap_value( &path_buf, (void*) heap_path, strlen( heap_path ) +1 );		// '+1' for terminal NUL on string.

	RELEASE_MYTHRYL_HEAP( task->pthread, "_lib7_P_FileSys_readlink", NULL );
	    //
	    result = lstat (c_path, &sbuf);
	    //
	RECOVER_MYTHRYL_HEAP( task->pthread, "_lib7_P_FileSys_readlink" );

	unbuffer_mythryl_heap_value( &path_buf );
    }

    if (result < 0)   return RAISE_SYSERR__MAY_HEAPCLEAN(task, result, NULL);

    int nlen = sbuf.st_size + 1;

    char* nbuf = MALLOC(nlen);

    if (nbuf == 0)   return RAISE_ERROR__MAY_HEAPCLEAN(task, "out of malloc memory", NULL);

    // Try the readlink again. Give up on error or if len is still bigger
    // than the buffer size.
    //
    {   char* c_path
	    = 
	    buffer_mythryl_heap_value( &path_buf, (void*) heap_path, strlen( heap_path ) +1 );		// '+1' for terminal NUL on string.

	RELEASE_MYTHRYL_HEAP( task->pthread, "_lib7_P_FileSys_readlink", NULL );
	    //
	    len = readlink(c_path, buf, len);
	    //
	RECOVER_MYTHRYL_HEAP( task->pthread, "_lib7_P_FileSys_readlink" );

	unbuffer_mythryl_heap_value( &path_buf );
    }

    if (len < 0)		return RAISE_SYSERR__MAY_HEAPCLEAN(task, len, NULL);
    if (len >= nlen)		return RAISE_ERROR__MAY_HEAPCLEAN(task, "readlink failure", NULL);

    nbuf[len] = '\0';
    Val chunk = make_ascii_string_from_c_string__may_heapclean (task, nbuf, NULL);
    FREE (nbuf);
    //
    return chunk;

}
Ejemplo n.º 9
0
Val   _lib7_Sock_sendbuf   (Task* task,  Val arg)   {
    //==================
    //
    // Mythryl type:
    //     ( Int,	    # socket fd
    //       Wy8Vector,     # byte vector
    //       Int,           # start offset
    //       Int,           # vector length (end offset)
    //       Bool,          # don't-route flag
    //       Bool           # default-oob flag
    //     )
    //     ->
    //     Int
    //
    // Send data from the buffer; bytes is either a rw_vector_of_one_byte_unts.Rw_Vector, or
    // a vector_of_one_byte_unts.vector.  The arguments are: socket, data buffer, start
    // position, number of bytes, OOB flag, and don't_route flag.
    //
    // This fn gets bound as   send_v, send_a   in:
    //
    //     src/lib/std/src/socket/socket-guts.pkg
    ENTER_MYTHRYL_CALLABLE_C_FN(__func__);
    int   socket    = GET_TUPLE_SLOT_AS_INT( arg, 0);
    Val   buf       = GET_TUPLE_SLOT_AS_VAL( arg, 1);
    int   offset    = GET_TUPLE_SLOT_AS_INT( arg, 2);
    int   nbytes    = GET_TUPLE_SLOT_AS_INT( arg, 3);
    Val   oob       = GET_TUPLE_SLOT_AS_VAL( arg, 4);
    Val   dontroute = GET_TUPLE_SLOT_AS_VAL( arg, 5);									// Last use of 'arg'.

    char* heap_data = HEAP_STRING_AS_C_STRING(buf) + offset;

    // Compute flags parameter:
    //
    int                         flgs  = 0;
    if (oob       == HEAP_TRUE) flgs |= MSG_OOB;
    if (dontroute == HEAP_TRUE) flgs |= MSG_DONTROUTE;

//															log_if( "sendbuf.c/top: socket d=%d nbytes d=%d OOB=%s DONTROUTE=%s\n",
//																socket, nbytes, (oob == HEAP_TRUE) ? "TRUE" : "FALSE", (dontroute == HEAP_TRUE) ? "TRUE" : "FALSE"
//															);
//															hexdump_if( "sendbuf.c/top: Data to send: ", (unsigned char*)heap_data, nbytes );

    errno = 0;

    int n;

    // We cannot reference anything on the Mythryl heap
    // between RELEASE_MYTHRYL_HEAP and RECOVER_MYTHRYL_HEAP
    // because garbage collection might be moving
    // it around, so copy 'heap_data' into C storage:
    //
    Mythryl_Heap_Value_Buffer  data_buf;
    //
    {   char* c_data =  buffer_mythryl_heap_value( &data_buf, (void*) heap_data, nbytes );

        RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL );
        //
        do {
            //
            n = send (socket, c_data, nbytes, flgs);
            //
        } while (n < 0 && errno == EINTR);										// Restart if interrupted by a SIGALRM or SIGCHLD or whatever.
        //
        RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );
//															log_if( "sendbuf.c/bot: n d=%d errno d=%d\n", n, errno );
        unbuffer_mythryl_heap_value( &data_buf );
    }

    Val result =  RETURN_STATUS_EXCEPT_RAISE_SYSERR_ON_NEGATIVE_STATUS__MAY_HEAPCLEAN(task, n, NULL);
    EXIT_MYTHRYL_CALLABLE_C_FN(__func__);
    return result;
}
Ejemplo n.º 10
0
Val   _lib7_P_IO_copy   (Task* task,  Val arg)   {
    //===============
    //
    // Mythryl type:   (String, String) -> Int
    //
    // Copy a file  and return its length.
    //
    // This fn gets bound as   copy   in:
    //
    //     src/lib/std/src/psx/posix-io.pkg
    //     src/lib/std/src/psx/posix-io-64.pkg				# Actually, I haven't gotten around to this yet.

    ENTER_MYTHRYL_CALLABLE_C_FN(__func__);

    Val	existing =  GET_TUPLE_SLOT_AS_VAL(arg, 0);
    Val	new_name =  GET_TUPLE_SLOT_AS_VAL(arg, 1);

    char* heap_existing =  HEAP_STRING_AS_C_STRING( existing );
    char* heap_new_name =  HEAP_STRING_AS_C_STRING( new_name );


    // We cannot reference anything on the Mythryl
    // heap between RELEASE_MYTHRYL_HEAP and RECOVER_MYTHRYL_HEAP
    // because garbage collection might be moving
    // it around, so copy heap_path into C storage:
    //
    Mythryl_Heap_Value_Buffer  existing_buf;
    Mythryl_Heap_Value_Buffer  new_name_buf;

    int ok = TRUE;

    ssize_t total_bytes_written  = 0;

    {   char* c_existing =  buffer_mythryl_heap_value( &existing_buf, (void*) heap_existing, strlen( heap_existing ) +1 );		// '+1' for terminal NUL on string.
        char* c_new_name =  buffer_mythryl_heap_value( &new_name_buf, (void*) heap_new_name, strlen( heap_new_name ) +1 );		// '+1' for terminal NUL on string.

        RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL );
        //
        struct stat statbuf;
        int fd_out;
        int fd_in = open(c_existing, O_RDONLY);								// Open the input file.
        if (fd_in >= 0) {
            if (0 <= fstat(fd_in, &statbuf)) {								// Get the mode of the input file so that we can ...
                fd_out = creat( c_new_name, statbuf.st_mode );						// ... open the output file with same mode as input file.
                if (0 <= fd_out) {
                    char buffer[ 4096 ];
                    ssize_t bytes_read;
                    int ok = TRUE;
                    while (ok) {										// Read up to one buffer[]-load from fd_in.
                        do {
                            bytes_read = read( fd_in, buffer, 4096 );
                        } while (bytes_read <  0 && errno == EINTR);					// Retry if interrupted by SIGALRM or such.
                        if      (bytes_read <  0) {
                            ok = FALSE;
                            break;
                        }
                        if      (bytes_read == 0) {
                            break;
                        }
                        ssize_t buffer_bytes_written  = 0;
                        while (ok  &&  (buffer_bytes_written < bytes_read)) {				// Write buffer[] contents to fd_out. Usually one write() will do it, but this is not guaranteed.
                            ssize_t bytes_to_write = bytes_read - buffer_bytes_written;
                            ssize_t bytes_written;
                            do {
                                bytes_written  = write( fd_out, buffer+buffer_bytes_written, bytes_to_write );
                            } while (bytes_written < 0 && errno == EINTR);					// Retry if interrupted by SIGALRM or such.
                            ok = ok && (bytes_written > 0);
                            buffer_bytes_written += bytes_written;
                            total_bytes_written += bytes_written;
                        }
                    }
                    close(fd_out);
                } else {
                    ok = FALSE;
                }
                close(fd_in);
            } else {
                ok = FALSE;
            }
        } else {
            ok = FALSE;
        }
        //
        RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );

        unbuffer_mythryl_heap_value( &existing_buf );
        unbuffer_mythryl_heap_value( &new_name_buf );
    }

    Val        result;

    if (!ok)   result = RAISE_SYSERR__MAY_HEAPCLEAN(task, -1, NULL);						// XXX SUCKO FIXME I'm being totally sloppy about accurate diagnostics here.  Feel free to submit a patch improving this.
    else       result = TAGGED_INT_FROM_C_INT( total_bytes_written );


    EXIT_MYTHRYL_CALLABLE_C_FN(__func__);
    return result;
}
Ejemplo n.º 11
0
Val   _lib7_Sock_recv   (Task* task,  Val arg)   {
    //===============
    //
    // Mythryl type: (Socket, Int, Bool, Bool) -> vector_of_one_byte_unts::Vector
    //
    // The arguments are: socket, number of bytes, OOB flag and peek flag.
    // The result is the vector of bytes received.
    //
    // This fn gets bound as   recv_v'   in:
    //
    //     src/lib/std/src/socket/socket-guts.pkg

									    ENTER_MYTHRYL_CALLABLE_C_FN(__func__);

    Val vec;
    ssize_t n;

    int	socket = GET_TUPLE_SLOT_AS_INT( arg, 0 );
    int	nbytes = GET_TUPLE_SLOT_AS_INT( arg, 1 );
    Val	oob    = GET_TUPLE_SLOT_AS_VAL( arg, 2 );
    Val	peek   = GET_TUPLE_SLOT_AS_VAL( arg, 3 );

    int		           flag  = 0;
    if (oob  == HEAP_TRUE) flag |= MSG_OOB;
    if (peek == HEAP_TRUE) flag |= MSG_PEEK;

    // We cannot reference anything on the Mythryl
    // heap between RELEASE_MYTHRYL_HEAP and RECOVER_MYTHRYL_HEAP
    // because garbage collection might be moving
    // it around, so allocate a C-world buffer
    // to read the bytes into:
    //
    Mythryl_Heap_Value_Buffer  read_buf;
    //
    {   unsigned char* c_read =  buffer_mythryl_heap_nonvalue( &read_buf, nbytes );
//										log_if("recv.c/before: socket d=%d nbytes d=%d oob=%s peek=%s\n",socket,nbytes,(oob == HEAP_TRUE)?"TRUE":"FALSE",(peek == HEAP_TRUE)?"TRUE":"FALSE");
	errno = 0;

	RELEASE_MYTHRYL_HEAP( task->hostthread, __func__, NULL );
	    //
            do {								// Backed out 2010-02-26 CrT: See discussion at bottom of src/c/lib/socket/connect.c
		//								// Restored   2012-08-07 CrT
		n = recv (socket, c_read, nbytes, flag);
		//
            } while (n < 0 && errno == EINTR);					// Restart if interrupted by a SIGALRM or SIGCHLD or whatever.
	    //
	RECOVER_MYTHRYL_HEAP( task->hostthread, __func__ );

	if (n <= 0) {
	    unbuffer_mythryl_heap_value( &read_buf );
	    if (n <  0)   return RAISE_SYSERR__MAY_HEAPCLEAN(task, status, NULL);
	    if (n == 0)   return ZERO_LENGTH_STRING__GLOBAL;
	}

	// Allocate result vector to hold the bytes read.
	// NB: This might cause a heapcleaning, moving things around:
	//
	vec = allocate_nonempty_wordslots_vector__may_heapclean( task, BYTES_TO_WORDS(n), NULL );

	// Copy bytes read into result vector:
	//
        memcpy( PTR_CAST(char*, vec), c_read, n);
//										log_if(   "recv.c/after: n d=%d errno d=%d (%s)\n", n, errno, errno ? strerror(errno) : "");
//										hexdump_if( "recv.c/after: Received data: ", PTR_CAST(unsigned char*, vec), n );
	unbuffer_mythryl_heap_value( &read_buf );
    }

    Val result = make_vector_header( task,  STRING_TAGWORD, vec, n );

									    EXIT_MYTHRYL_CALLABLE_C_FN(__func__);
    return result;
}
static Val   set__time_profiling_is_running__to   (Task* task,  Val arg)   {
    //       ==================================
    //
    // Mythryl type:   Bool -> Void
    //
    // This dis/ables sending of SIGVTALRM signals to the process,
    // vs  set_time_profiling_rw_vector() above which
    // dis/ables handling of SIGVTALRM signals by the process.
    //
    // This fn gets bound to   set__time_profiling_is_running__to   in:
    //
    //     src/lib/std/src/nj/runtime-profiling-control.pkg

									    ENTER_MYTHRYL_CALLABLE_C_FN("set__time_profiling_is_running__to");

    #ifndef HAS_SETITIMER
	//
	return RAISE_ERROR__MAY_HEAPCLEAN(task, "time profiling not supported", NULL);
	//
    #else
	//     "The system provides each process with three interval timers,
	//      each decrementing in a distinct time domain. When any timer
	//      expires, a signal is sent to the process, and the timer
	//      (potentially) restarts.
	//
	//          ITIMER_REAL	   Decrements in real time, and delivers SIGALRM upon expiration.
	//          ITIMER_VIRTUAL Decrements only when the process is executing, and delivers SIGVTALRM upon expiration.
	//          ITIMER_PROF	   Decrements both when the process executes and when the system is executing on behalf of the process.
	//                         Coupled with ITIMER_VIRTUAL, this timer is usually used to profile the time spent by the application
	//			   in user and kernel space. SIGPROF is delivered upon expiration.
	//
	//            -- http://linux.about.com/library/cmd/blcmdl2_setitimer.htm
	//
	struct itimerval   new_itv;

	if (arg == HEAP_FALSE) {
	    //
	    new_itv.it_interval.tv_sec	=
	    new_itv.it_value.tv_sec	=
	    new_itv.it_interval.tv_usec	=
	    new_itv.it_value.tv_usec	= 0;

	} else if (time_profiling_rw_vector__global == HEAP_VOID) {
	    //
	    return RAISE_ERROR__MAY_HEAPCLEAN(task, "no time_profiling_rw_vector set", NULL);

	} else {
	    //
	    new_itv.it_interval.tv_sec	=
	        new_itv.it_value.tv_sec	= 0;

	    new_itv.it_interval.tv_usec	=
	       new_itv.it_value.tv_usec	= MICROSECONDS_PER_SIGVTALRM;		// From   src/c/h/profiler-call-counts.h
	}

	int status = setitimer (ITIMER_VIRTUAL, &new_itv, NULL);

	RETURN_VOID_EXCEPT_RAISE_SYSERR_ON_NEGATIVE_STATUS__MAY_HEAPCLEAN(task, status, NULL);

    #endif
}