suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rktio: repairs

Browse Source 
Compiles ons MacOS, but doesn't quite link.
This commit is contained in:
Matthew Flatt 2017-06-15 20:26:41 -06:00
parent 93834adc99
commit f0a644990c
18 changed files with 457 additions and 451 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
racket/src/racket/include/schthread.h
View File

@ -307,7 +307,7 @@ typedef struct Thread_Local_Variables {
int special_is_ok_;
int scheme_force_port_closed_;
int fd_reserved_;
int the_fd_;
struct rktio_fd_t *the_fd_;
int scheme_num_read_syntax_objects_;
struct Scheme_Load_Delay *clear_bytes_chain_;
const char *failure_msg_for_read_;

19
racket/src/racket/src/Makefile.in
View File

@ -381,10 +381,10 @@ list.@LTO@: $(COMMON_HEADERS) \
marshal.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h
module.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/schfd.h
$(srcdir)/stypes.h
mzrt.@LTO@: $(COMMON_HEADERS)
network.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_network.inc
network.@LTO@: $(COMMON_HEADERS) $(RKTIO_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/mzmark_network.inc
numarith.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/nummacs.h
number.@LTO@: $(COMMON_HEADERS) \
@ -397,17 +397,16 @@ numstr.@LTO@: $(COMMON_HEADERS) \
optimize.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/mzmark_optimize.inc
place.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_place.inc
$(srcdir)/stypes.h $(srcdir)/mzmark_place.inc
port.@LTO@: $(COMMON_HEADERS) $(RKTIO_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_port.inc \
$(srcdir)/inotify.inc
$(srcdir)/stypes.h $(srcdir)/mzmark_port.inc
portfun.@LTO@: $(COMMON_HEADERS) $(srcdir)/schvers.h \
$(srcdir)/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_portfun.inc
$(srcdir)/stypes.h $(srcdir)/mzmark_portfun.inc
print.@LTO@: $(COMMON_HEADERS) $(srcdir)/stypes.h $(srcdir)/schcpt.h \
$(srcdir)/schvers.h $(SCONFIG) $(srcdir)/mzmark_print.inc \
$(srcdir)/print_vector.inc
thread.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_thread.inc
thread.@LTO@: $(COMMON_HEADERS) $(RKTIO_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/mzmark_thread.inc
rational.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h
read.@LTO@: $(COMMON_HEADERS) \
@ -428,7 +427,7 @@ string.@LTO@: $(COMMON_HEADERS) $(RKTIO_HEADERS) \
struct.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/mzmark_struct.inc
syntax.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(srcdir)/schfd.h $(srcdir)/mzmark_syntax.inc
$(srcdir)/stypes.h $(srcdir)/mzmark_syntax.inc
symbol.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h
sema.@LTO@: $(COMMON_HEADERS) \

374
racket/src/racket/src/network.c
View File

@ -29,9 +29,6 @@
#include "schrktio.h"
#include <ctype.h>
#ifndef NO_TCP_SUPPORT
#ifdef USE_TCP
#define TCP_BUFFER_SIZE 4096
typedef struct {
@ -179,7 +176,11 @@ void scheme_init_network(Scheme_Env *env)
scheme_finish_primitive_module(netenv);
}
static int check_fd_sema(rktio_fd_t s, int mode, Scheme_Schedule_Info *sinfo, Scheme_Object *orig)
static int check_fd_sema(rktio_fd_t *s, int mode, Scheme_Schedule_Info *sinfo, Scheme_Object *orig)
/* Tries to convert a file descriptor to a semaphore, and redirects
the sync to the semaphore if that works, which avoids a poll spin
on the file descriptor. The result is 0 if the shortcut determines
that the file descriptor is not ready. */
{
Scheme_Object *sema;
@ -215,7 +216,6 @@ static int check_fd_sema(rktio_fd_t s, int mode, Scheme_Schedule_Info *sinfo, Sc
static int tcp_check_accept(Scheme_Object *_listener, Scheme_Schedule_Info *sinfo)
{
listener_t *listener = (listener_t *)_listener;
int sr, i;
if (!sinfo || !sinfo->is_poll) {
/* If listeners supported semaphores, we could have a check here
@ -229,14 +229,8 @@ static int tcp_check_accept(Scheme_Object *_listener, Scheme_Schedule_Info *sinf
if (rktio_poll_accept_ready(scheme_rktio, listener->lnr))
return 1;
if (sinfo && !sinfo->no_redirect) {
Scheme_Object *evt;
evt = listener_to_evt(listener);
if (evt)
scheme_set_sync_target(sinfo, evt, _listener, NULL, 0, 1, NULL);
} else {
/* CREATE_LISTEN_SEMA: This is where we'd create a semaphore for the listener, if that were possible */
}
/* CREATE_LISTEN_SEMA: This is where we'd create a semaphore for the
listener, if that were possible */
return 0;
}
@ -291,7 +285,7 @@ static int tcp_check_write(Scheme_Object *port, Scheme_Schedule_Info *sinfo)
static void tcp_write_needs_wakeup(Scheme_Object *port, void *fds)
{
rktio_fd_t s = ((Scheme_Tcp *)((Scheme_Output_Port *)port)->port_data)->tcp;
rktio_fd_t *s = ((Scheme_Tcp *)((Scheme_Output_Port *)port)->port_data)->tcp;
rktio_poll_add(scheme_rktio, s, fds, RKTIO_POLL_WRITE);
}
@ -353,7 +347,6 @@ static intptr_t tcp_get_string(Scheme_Input_Port *port,
int nonblock,
Scheme_Object *unless)
{
int errid;
int read_amt;
Scheme_Tcp *data;
Scheme_Object *sema;
@ -395,7 +388,7 @@ static intptr_t tcp_get_string(Scheme_Input_Port *port,
{
int rn;
rn = rktio_read(scheme_rktio, data->tcp, data->b.buffer, read_amt, 0);
rn = rktio_read(scheme_rktio, data->tcp, data->b.buffer, read_amt);
data->b.bufmax = rn; /* could be count, error, or EOF */
}
@ -408,7 +401,7 @@ static intptr_t tcp_get_string(Scheme_Input_Port *port,
return 0;
/* block until data is (probably) available */
sema = scheme_rktio_fd_to_semaphore(data->tcp, MZFD_CREATE_READ, 1);
sema = scheme_rktio_fd_to_semaphore(data->tcp, MZFD_CREATE_READ);
if (sema)
scheme_wait_sema(sema, nonblock ? -1 : 0);
else
@ -428,8 +421,7 @@ static intptr_t tcp_get_string(Scheme_Input_Port *port,
data->b.bufmax = 0;
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"tcp-read: error reading\n"
" system error: %R",
errid);
" system error: %R");
return 0;
} else if (data->b.bufmax == RKTIO_READ_ERROR) {
data->b.bufmax = 0;
@ -468,9 +460,9 @@ static void tcp_close_input(Scheme_Input_Port *port)
if (--data->b.refcount)
return;
(void)scheme_rktio_fd_to_semaphore(data->tcp, MZFD_REMOVE, 1);
(void)scheme_rktio_fd_to_semaphore(data->tcp, MZFD_REMOVE);
rktio_close(data->tcp);
rktio_close(scheme_rktio, data->tcp);
}
static int
@ -499,7 +491,7 @@ static intptr_t tcp_do_write_string(Scheme_Output_Port *port,
can be flushed immediately, never ever blocking. */
Scheme_Tcp *data;
int errid, would_block = 0;
int would_block = 0;
intptr_t sent;
data = (Scheme_Tcp *)port->port_data;
@ -525,7 +517,7 @@ static intptr_t tcp_do_write_string(Scheme_Output_Port *port,
/* Block for writing: */
{
Scheme_Object *sema;
sema = scheme_rktio_fd_to_semaphore(data->tcp, MZFD_CREATE_WRITE, 1);
sema = scheme_rktio_fd_to_semaphore(data->tcp, MZFD_CREATE_WRITE);
if (sema)
scheme_wait_sema(sema, enable_break ? -1 : 0);
else
@ -641,9 +633,9 @@ static void tcp_close_output(Scheme_Output_Port *port)
if (--data->b.refcount)
return;
(void)scheme_rktio_fd_to_semaphore(data->tcp, MZFD_REMOVE, 1);
(void)scheme_rktio_fd_to_semaphore(data->tcp, MZFD_REMOVE);
rktio_close(data->tcp);
rktio_close(scheme_rktio, data->tcp);
}
static int
@ -732,20 +724,23 @@ make_tcp_output_port(void *data, const char *name, Scheme_Object *cust)
/* Various things to free if we ever give up on a connect: */
typedef struct Connect_Progress_Data {
rktio_lookup_t *lookup;
rktio_addrinfo_lookup_t *lookup;
rktio_connect_t *connect;
rktio_addrinfo_t *dest_addr;
rktio_addrinfo_t *src_addr;
rktio_fd_t *trying_s;
rktio_fd_t *s;
} Connect_Progress_Data;
static Connect_Progress_Data *make_conect_progress_data()
static Connect_Progress_Data *make_connect_progress_data()
{
Connect_Progress_Data *pd;
MALLOC_ONE_ATOMIC(Connect_Progress_Data);
pd = MALLOC_ONE_ATOMIC(Connect_Progress_Data);
pd->lookup = NULL;
pd->connect = NULL;
pd->dest_addr = NULL;
pd->src_addr = NULL;
pd->s = NULL;
return pd;
@ -758,7 +753,7 @@ static void connect_cleanup(Connect_Progress_Data *pd)
pd->lookup = NULL;
}
if (pd->connect) {
rktio_connect_stop(rktio, pd->connect);
rktio_connect_stop(scheme_rktio, pd->connect);
pd->connect = NULL;
}
if (pd->dest_addr) {
@ -769,9 +764,13 @@ static void connect_cleanup(Connect_Progress_Data *pd)
rktio_addrinfo_free(scheme_rktio, pd->src_addr);
pd->src_addr = NULL;
}
if (pd->trying_s) {
(void)scheme_rktio_fd_to_semaphore(pd->trying_s, MZFD_REMOVE);
pd->trying_s = NULL;
}
if (pd->s) {
(void)scheme_rktio_fd_to_semaphore(s, MZFD_REMOVE, 1);
rktio_close(s);
(void)scheme_rktio_fd_to_semaphore(pd->s, MZFD_REMOVE);
rktio_close(scheme_rktio, pd->s);
pd->s = NULL;
}
}
@ -784,14 +783,15 @@ static int check_lookup(Connect_Progress_Data *pd, Scheme_Schedule_Info *sinfo)
return 0;
}
static void lookup_needs_wakeup(Connect_Progress_Data *pd, void *fds)
static void lookup_needs_wakeup(Scheme_Object *_pd, void *fds)
{
Connect_Progress_Data *pd = (Connect_Progress_Data *)_pd;
rktio_poll_add_addrinfo_lookup(scheme_rktio, pd->lookup, fds);
}
static void wait_until_lookup(Connect_Progress_Data *pd)
{
while (!rktio_poll_addrinfo_lookup_ready(scheme_rktio, lookup)) {
while (!rktio_poll_addrinfo_lookup_ready(scheme_rktio, pd->lookup)) {
BEGIN_ESCAPEABLE(connect_cleanup, pd);
scheme_block_until((Scheme_Ready_Fun)check_lookup,
lookup_needs_wakeup,
@ -804,7 +804,7 @@ static void wait_until_lookup(Connect_Progress_Data *pd)
static rktio_addrinfo_t *do_resolve_address(const char *who, char *address, int id, int family, int show_id_on_error)
{
Connect_Progress_Data *pd;
rktio_lookup_t *loopkup;
rktio_addrinfo_lookup_t *lookup;
rktio_addrinfo_t *addr;
pd = make_connect_progress_data();
@ -855,7 +855,7 @@ const char *scheme_hostname_error(int err)
/* TCP Racket interface */
/*========================================================================*/
static void connect_failed(Connect_Progress_Data *pd, const char *why, char *address, int id)
static void connect_failed(Connect_Progress_Data *pd, const char *why, const char *address, int id)
{
if (pd) connect_cleanup(pd);
@ -871,37 +871,42 @@ static void connect_failed(Connect_Progress_Data *pd, const char *why, char *add
static int tcp_check_connect(Connect_Progress_Data *pd, Scheme_Schedule_Info *sinfo)
{
rktio_fd_t *s = (rktio_fd_t *)connector_p;
if (!pd->trying_s) {
rktio_fd_t *s;
s = rktio_connect_trying(scheme_rktio, pd->connect);
pd->trying_s = s;
}
if (!sinfo || !sinfo->is_poll) {
if (!check_fd_sema(s, MZFD_CHECK_WRITE, sinfo, NULL))
return 0;
if (pd->trying_s)
if (!check_fd_sema(pd->trying_s, MZFD_CHECK_WRITE, sinfo, NULL))
return 0;
}
if (rktio_poll_connect_ready(scheme->rktio, s))
if (rktio_poll_connect_ready(scheme_rktio, pd->connect))
return 1;
check_fd_sema(s, MZFD_CREATE_WRITE, sinfo, NULL);
if (pd->trying_s)
check_fd_sema(pd->trying_s, MZFD_CREATE_WRITE, sinfo, NULL);
return 0;
}
static void tcp_connect_needs_wakeup(Scheme_Object *connector_p, void *fds)
static void tcp_connect_needs_wakeup(Scheme_Object *_pd, void *fds)
{
rktio_fd_t *s = (rktio_fd_t *)connector_p;
rktio_poll_add_connect(scheme_rktio, s, fds);
Connect_Progress_Data *pd = (Connect_Progress_Data *)_pd;
rktio_poll_add_connect(scheme_rktio, pd->connect, fds);
}
static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
{
Connect_Progress_Data *pd;
char *address = "", *src_address, *errmsg = NULL;
char *address = "", *src_address;
unsigned short id, src_id;
int no_local_spec;
Scheme_Object *bs, *src_bs;
rktio_addrinfo_t *tcp_address_dest, *tcp_address_src;
rktio_lookup_t *lookup;
rktio_addrinfo_t *tcp_connect_dest, *tcp_connect_src;
rktio_addrinfo_lookup_t *lookup;
rktio_connect_t *connect;
rktio_fd_t *s;
@ -948,7 +953,7 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
pd = make_connect_progress_data();
lookup = rktio_start_addrinfo_lookup(scheme_rktio, address, id, RKTIO_FAMILTY_ANY, 0, 1);
lookup = rktio_start_addrinfo_lookup(scheme_rktio, address, id, RKTIO_FAMILY_ANY, 0, 1);
if (!lookup)
connect_failed(pd, "host not found", address, id);
@ -963,7 +968,7 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
pd->dest_addr = tcp_connect_dest;
if (!no_local_spec) {
lookup = rktio_start_addrinfo_lookup(scheme_rktio, src_address, src_id, RKTIO_FAMILTY_ANY, 1, 1);
lookup = rktio_start_addrinfo_lookup(scheme_rktio, src_address, src_id, RKTIO_FAMILY_ANY, 1, 1);
if (!lookup)
connect_failed(pd, "local host not found", src_address, src_id);
@ -971,22 +976,15 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
wait_until_lookup(pd);
pd->lookup = NULL;
tcp_connect_dest = rktio_addrinfo_lookup_get(scheme_rktio, lookup);
if (!tcp_connect_dest)
connect_failed(pd, "local host not found", src_address, src_id);
pd->lookup = lookup;
wait_until_lookup(pd);
pd->lookup = NULL;
tcp_connect_src = rktio_addrinfo_lookup_get(scheme_rktio, lookup);
if (!tcp_connect_src)
connect_failed(pd, "local host not found", src_address, src_id);
}
} else
tcp_connect_src = NULL;
pd->src_addr = tcp_connect_src;
connect = rktio_start_connect(racket_rktio, tcp_connect_dest, tcp_connect_src);
connect = rktio_start_connect(scheme_rktio, tcp_connect_dest, tcp_connect_src);
if (!connect)
connect_failed(pd, NULL, address, id);
@ -1002,7 +1000,10 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
END_ESCAPEABLE();
}
s = rktio_connect_finish(rktio_rktio, connect);
if (pd->trying_s)
(void)scheme_rktio_fd_to_semaphore(pd->trying_s, MZFD_REMOVE);
s = rktio_connect_finish(scheme_rktio, connect);
if (!s && scheme_last_error_is_racket(RKTIO_ERROR_CONNECT_TRYING_NEXT)) {
/* try again */
@ -1013,7 +1014,7 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
pd->connect = NULL;
if (!s)
connect_failed(s, NULL, address, id);
connect_failed(pd, NULL, address, id);
connect_cleanup(pd);
@ -1022,7 +1023,7 @@ static Scheme_Object *tcp_connect(int argc, Scheme_Object *argv[])
Scheme_Tcp *tcp;
if (tcp_connect_src)
rktio_addrinfo_free(tcp_connect_src);
rktio_addrinfo_free(scheme_rktio, tcp_connect_src);
tcp = make_tcp_port_data(s, 2);
@ -1039,7 +1040,7 @@ tcp_connect_break(int argc, Scheme_Object *argv[])
return scheme_call_enable_break(tcp_connect, argc, argv);
}
static void listen_failed(Connect_Progress_Data *pd, const char *why, char *address, int id)
static void listen_failed(Connect_Progress_Data *pd, const char *why, const char *address, int id)
{
if (pd) connect_cleanup(pd);
@ -1060,11 +1061,11 @@ static Scheme_Object *
tcp_listen(int argc, Scheme_Object *argv[])
{
unsigned short id;
int backlog, errid;
int backlog;
int reuse = 0, no_ipv6 = 0;
const char *address;
Connect_Progress_Data *pd;
rktio_lookup_t *lookup;
rktio_addrinfo_lookup_t *lookup;
rktio_addrinfo_t *tcp_src;
rktio_listener_t *lnr;
listener_t *l;
@ -1098,7 +1099,7 @@ tcp_listen(int argc, Scheme_Object *argv[])
} else
address = NULL;
scheme_security_check_network("tcp-listen", address, origid, 0);
scheme_security_check_network("tcp-listen", address, id, 0);
scheme_custodian_check_available(NULL, "tcp-listen", "network");
pd = make_connect_progress_data();
@ -1109,7 +1110,7 @@ tcp_listen(int argc, Scheme_Object *argv[])
if (no_ipv6)
family = rktio_get_ipv4_family(scheme_rktio);
else
family = RKTIO_FAMILTY_ANY;
family = RKTIO_FAMILY_ANY;
lookup = rktio_start_addrinfo_lookup(scheme_rktio, address, id, family, 1, 1);
if (!lookup)
@ -1121,10 +1122,10 @@ tcp_listen(int argc, Scheme_Object *argv[])
tcp_src = rktio_addrinfo_lookup_get(scheme_rktio, lookup);
if (!tcp_src)
connect_failed(pd, "address-resolution error", address, id);
listen_failed(pd, "address-resolution error", address, id);
pd->src_addr = tcp_src;
lnr = rktio_listen(rktio, tcp_src, backlog, reuse);
lnr = rktio_listen(scheme_rktio, tcp_src, backlog, reuse);
pd->src_addr = NULL;
rktio_addrinfo_free(scheme_rktio, tcp_src);
@ -1166,8 +1167,6 @@ tcp_stop(int argc, Scheme_Object *argv[])
if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
scheme_wrong_contract("tcp-close", "tcp-listener?", 0, argc, argv);
TCP_INIT("tcp-close");
was_closed = stop_listener(argv[0]);
if (was_closed) {
@ -1187,8 +1186,6 @@ tcp_accept_ready(int argc, Scheme_Object *argv[])
if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
scheme_wrong_contract("tcp-accept-ready?", "tcp-listener?", 0, argc, argv);
TCP_INIT("tcp-accept-ready?");
if (LISTENER_WAS_CLOSED(argv[0])) {
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"tcp-accept-ready?: listener is closed");
@ -1205,11 +1202,9 @@ do_tcp_accept(int argc, Scheme_Object *argv[], Scheme_Object *cust, char **_fail
/* If _fail_reason is not NULL, never raise an exception. */
{
#ifdef USE_TCP
int was_closed = 0, errid, ready_pos;
int was_closed = 0, ready_pos;
Scheme_Object *listener;
rktio_fd_t *s;
unsigned int l;
GC_CAN_IGNORE char tcp_accept_addr[MZ_SOCK_NAME_MAX_LEN];
if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_listener_type))
scheme_wrong_contract("tcp-accept", "tcp-listener?", 0, argc, argv);
@ -1221,15 +1216,10 @@ do_tcp_accept(int argc, Scheme_Object *argv[], Scheme_Object *cust, char **_fail
if (!was_closed) {
ready_pos = tcp_check_accept(listener, NULL);
if (!ready_pos) {
Scheme_Object *evt;
evt = listener_to_evt((listener_t *)listener);
if (evt)
scheme_sync(1, &evt);
else
scheme_block_until((Scheme_Ready_Fun)tcp_check_accept,
tcp_accept_needs_wakeup,
listener,
0.0);
scheme_block_until((Scheme_Ready_Fun)tcp_check_accept,
tcp_accept_needs_wakeup,
listener,
0.0);
ready_pos = tcp_check_accept(listener, NULL);
}
was_closed = LISTENER_WAS_CLOSED(listener);
@ -1292,13 +1282,9 @@ tcp_accept_break(int argc, Scheme_Object *argv[])
void scheme_register_network_evts()
{
#ifdef USE_TCP
scheme_add_evt(scheme_listener_type, (Scheme_Ready_Fun)tcp_check_accept, tcp_accept_needs_wakeup, NULL, 0);
scheme_add_evt(scheme_tcp_accept_evt_type, (Scheme_Ready_Fun)tcp_check_accept_evt, tcp_accept_evt_needs_wakeup, NULL, 0);
# ifdef UDP_IS_SUPPORTED
scheme_add_evt(scheme_udp_evt_type, (Scheme_Ready_Fun)udp_evt_check_ready, udp_evt_needs_wakeup, NULL, 0);
# endif
#endif
}
static Scheme_Object *tcp_listener_p(int argc, Scheme_Object *argv[])
@ -1322,13 +1308,14 @@ static int extract_svc_value(char *svc_buf)
static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
{
#ifdef USE_TCP
rktio_fd_t *socket = NULL;
rktio_listener_t *lnr = NULL;
Scheme_Tcp *tcp = NULL;
int closed = 0, require_peer = 0;
Scheme_Object *result[4];
int with_ports = 0;
intptr_t l;
char **local_names, **peer_names;
if (SCHEME_OUTPUT_PORTP(argv[0])) {
Scheme_Output_Port *op;
@ -1355,14 +1342,12 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
require_peer = 1;
} else {
if (SCHEME_LISTEN_PORTP(argv[0])) {
listener = 1;
if (LISTENER_WAS_CLOSED(argv[0])) {
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"tcp-addresses: listener is closed");
} else
lnr = ((listener_t *)argv[0])->lnr;
} else if (SCHEME_UDP_PORTP(argv[0])) {
udp = 1;
socket = ((Scheme_UDP *)argv[0])->s;
if (!socket)
scheme_raise_exn(MZEXN_FAIL_NETWORK,
@ -1373,9 +1358,9 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
}
if (socket)
local_names = rktio_socket_address(socket);
local_names = rktio_socket_address(scheme_rktio, socket);
else
local_names = rktio_listener_address(lnr);
local_names = rktio_listener_address(scheme_rktio, lnr);
if (!local_names)
scheme_raise_exn(MZEXN_FAIL_NETWORK,
@ -1383,7 +1368,7 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
" system error: %R");
if (socket)
peer_names = rktio_socket_address(socket);
peer_names = rktio_socket_address(scheme_rktio, socket);
else
peer_names = NULL;
@ -1406,9 +1391,9 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
result[with_ports ? 2 : 1] = scheme_make_utf8_string("0.0.0.0");
result[3] = scheme_make_integer(0);
} else {
result[with_ports ? 2 : 1] = scheme_make_utf8_string(host_buf);
result[with_ports ? 2 : 1] = scheme_make_utf8_string(peer_names[0]);
if (with_ports) {
l = extract_svc_value(svc_buf);
l = extract_svc_value(peer_names[1]);
result[3] = scheme_make_integer(l);
}
}
@ -1419,7 +1404,7 @@ static Scheme_Object *tcp_addresses(int argc, Scheme_Object *argv[])
if (peer_names) {
free(peer_names[0]);
free(peer_names[1]);
free(perr_names);
free(peer_names);
}
return scheme_values(with_ports ? 4 : 2, result);
@ -1559,7 +1544,7 @@ int scheme_get_port_socket(Scheme_Object *p, intptr_t *_s)
if (s_ok) {
intptr_t sv;
sv = rktio_fd_system_fd(s);
sv = rktio_fd_system_fd(scheme_rktio, s);
*_s = sv;
return 1;
} else
@ -1573,7 +1558,7 @@ void scheme_socket_to_ports(intptr_t s, const char *name, int takeover,
Scheme_Object *v;
rktio_fd_t *rfd;
rfd = rktio_open(s, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_SOCKET | RKTIO_OPEN_OWN);
rfd = rktio_system_fd(scheme_rktio, s, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_SOCKET | RKTIO_OPEN_OWN);
tcp = make_tcp_port_data(rfd, takeover ? 2 : 3);
@ -1586,74 +1571,59 @@ void scheme_socket_to_ports(intptr_t s, const char *name, int takeover,
void scheme_socket_to_input_port(intptr_t s, Scheme_Object *name, int takeover,
Scheme_Object **_inp)
{
#ifdef USE_TCP
Scheme_Tcp *tcp;
Scheme_Object *v;
rktio_fd_t *fd;
tcp = make_tcp_port_data(s, takeover ? 1 : 2);
fd = rktio_system_fd(scheme_rktio, s, (RKTIO_OPEN_READ | RKTIO_OPEN_SOCKET
| RKTIO_OPEN_INIT
| (takeover ? RKTIO_OPEN_OWN : 0)));
tcp = make_tcp_port_data(fd, takeover ? 1 : 2);
v = make_tcp_input_port_symbol_name(tcp, name, NULL);
*_inp = v;
if (takeover) {
REGISTER_SOCKET(s);
}
#else
*_inp = NULL;
#endif
}
void scheme_socket_to_output_port(intptr_t s, Scheme_Object *name, int takeover,
Scheme_Object **_outp)
{
#ifdef USE_TCP
Scheme_Tcp *tcp;
Scheme_Object *v;
tcp = make_tcp_port_data(s, takeover ? 1 : 2);
rktio_fd_t *fd;
fd = rktio_system_fd(scheme_rktio, s, (RKTIO_OPEN_WRITE | RKTIO_OPEN_SOCKET
| RKTIO_OPEN_INIT
| (takeover ? RKTIO_OPEN_OWN : 0)));
tcp = make_tcp_port_data(fd, takeover ? 1 : 2);
v = make_tcp_output_port_symbol_name(tcp, name, NULL);
*_outp = v;
if (takeover) {
REGISTER_SOCKET(s);
}
#else
*_outp = NULL;
#endif
}
intptr_t scheme_dup_socket(intptr_t fd) {
#ifdef USE_TCP
# ifdef USE_WINSOCK_TCP
intptr_t nsocket;
intptr_t rc;
WSAPROTOCOL_INFO protocolInfo;
rc = WSADuplicateSocket(fd, GetCurrentProcessId(), &protocolInfo);
if (rc)
return rc;
nsocket = WSASocket(FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, &protocolInfo, 0, WSA_FLAG_OVERLAPPED);
REGISTER_SOCKET(nsocket);
return nsocket;
# else
intptr_t nfd;
do {
nfd = dup(fd);
} while (nfd == -1 && errno == EINTR);
return nfd;
# endif
#else
return -1;
#endif
rktio_fd_t *rfd, *rfd2;
intptr_t s;
rfd = rktio_system_fd(scheme_rktio, fd, (RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_SOCKET));
rfd2 = rktio_dup(scheme_rktio, rfd);
s = rktio_fd_system_fd(scheme_rktio, rfd2);
rktio_forget(scheme_rktio, rfd);
rktio_forget(scheme_rktio, rfd2);
return s;
}
void scheme_close_socket_fd(intptr_t fd)
{
#ifdef USE_TCP
UNREGISTER_SOCKET(fd);
closesocket(fd);
(void)scheme_fd_to_semaphore(fd, MZFD_REMOVE, 1);
#endif
rktio_fd_t *rfd;
rfd = rktio_system_fd(scheme_rktio, fd, RKTIO_OPEN_SOCKET | RKTIO_OPEN_OWN);
(void)scheme_rktio_fd_to_semaphore(rfd, MZFD_REMOVE);
rktio_close(scheme_rktio, rfd);
}
/*========================================================================*/
@ -1671,8 +1641,14 @@ typedef struct Scheme_UDP_Evt {
rktio_addrinfo_t *dest_addr;
} Scheme_UDP_Evt;
static void free_dest_addr(void *udp_evt, void *ignored)
{
Scheme_UDP_Evt *evt = (Scheme_UDP_Evt *)udp_evt;
rktio_addrinfo_free(scheme_rktio, evt->dest_addr);
}
static int udp_default_family() {
return rktio_get_ipv4_family();
return rktio_get_ipv4_family(scheme_rktio);
}
static int udp_close_it(Scheme_Object *_udp)
@ -1680,8 +1656,8 @@ static int udp_close_it(Scheme_Object *_udp)
Scheme_UDP *udp = (Scheme_UDP *)_udp;
if (udp->s) {
(void)scheme_fd_to_semaphore(udp->s, MZFD_REMOVE, 1);
rktio_close(udp->s);
(void)scheme_rktio_fd_to_semaphore(udp->s, MZFD_REMOVE);
rktio_close(scheme_rktio, udp->s);
udp->s = NULL;
scheme_remove_managed(udp->mref, (Scheme_Object *)udp);
@ -1700,8 +1676,6 @@ static Scheme_Object *make_udp(int argc, Scheme_Object *argv[])
unsigned short id;
rktio_addrinfo_t *addr;
TCP_INIT("udp-open-socket");
if ((argc > 0) && !SCHEME_FALSEP(argv[0]) && !SCHEME_CHAR_STRINGP(argv[0]))
scheme_wrong_contract("udp-open-socket", "(or/c string? #f)", 0, argc, argv);
if ((argc > 1) && !SCHEME_FALSEP(argv[1]) && !CHECK_PORT_ID(argv[1]))
@ -1718,7 +1692,7 @@ static Scheme_Object *make_udp(int argc, Scheme_Object *argv[])
else
id = 0;
scheme_security_check_network("udp-open-socket", address, origid, 0);
scheme_security_check_network("udp-open-socket", address, id, 0);
scheme_custodian_check_available(NULL, "udp-open-socket", "network");
if (address || id) {
@ -1727,7 +1701,7 @@ static Scheme_Object *make_udp(int argc, Scheme_Object *argv[])
if (!id)
id = 1025;
addr = do_resolve_address("upd-open-socket", address, id, RKTIO_FAMILTY_ANY, show_id_on_error);
addr = do_resolve_address("upd-open-socket", address, id, RKTIO_FAMILY_ANY, show_id_on_error);
} else
addr = NULL;
@ -1866,7 +1840,7 @@ static Scheme_Object *udp_bind_or_connect(const char *name, int argc, Scheme_Obj
return scheme_void;
}
addr = do_resolve_address(name, address, port, RKTIO_FAMILTY_ANY, 1);
addr = do_resolve_address(name, address, port, RKTIO_FAMILY_ANY, 1);
if (!do_bind) {
/* CONNECT CASE */
@ -1927,7 +1901,7 @@ static int udp_check_send(Scheme_Object *_udp, Scheme_Schedule_Info *sinfo)
{
Scheme_UDP *udp = (Scheme_UDP *)_udp;
if (udp->s == INVALID_SOCKET)
if (!udp->s)
return 1;
if (!sinfo || !sinfo->is_poll) {
@ -1957,9 +1931,9 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
intptr_t x;
while (1) {
if (udp->s!) {
if (!udp->s) {
/* socket was closed, maybe while we slept */
if (free_addr) rktio_addrinfo_free(dest_addr);
if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
if (can_error)
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"%s: udp socket is closed\n"
@ -1970,7 +1944,7 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
if ((!dest_addr && !udp->connected)
|| (dest_addr && udp->connected)) {
/* socket is unconnected, maybe disconnected while we slept */
if (free_addr) rktio_addrinfo_free(dest_addr);
if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
if (can_error)
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"%s: udp socket is%s connected\n"
@ -1983,19 +1957,16 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
udp->bound = 1; /* in case it's not bound already, send[to] binds it */
x = rktio_udp_sendto(scheme_rktio, udp->s, addr,
x = rktio_udp_sendto(scheme_rktio, udp->s, dest_addr,
bstr XFORM_OK_PLUS start, end - start);
if (x == RKTIO_WRITE_ERROR) {
if (ignore_addr_failure && scheme_last_error_is_racket(RKTIO_ERROR_ADDRESS_FAILURE)) {
return NULL;
} else
break;
break;
} else if (!x) {
if (can_block) {
/* Block and eventually try again. */
Scheme_Object *sema;
sema = scheme_fd_to_semaphore(udp->s, MZFD_CREATE_WRITE, 1);
sema = scheme_rktio_fd_to_semaphore(udp->s, MZFD_CREATE_WRITE);
if (sema)
scheme_wait_sema(sema, 0);
else
@ -2003,11 +1974,13 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
udp_send_needs_wakeup,
(Scheme_Object *)udp,
0);
} else
} else {
if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
return scheme_false;
}
} else if (x != (end - start)) {
/* this isn't supposed to happen: */
if (free_addr) rktio_addrinfo_free(dest_addr);
if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
if (can_error)
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"%s: didn't send enough (%d != %d)",
@ -2017,11 +1990,12 @@ static Scheme_Object *do_udp_send_it(const char *name, Scheme_UDP *udp,
} else
break;
}
if (free_addr) rktio_addrinfo_free(scheme_rktio, dest_addr);
if (x != RKTIO_WRITE_ERROR) {
return (can_block ? scheme_void : scheme_true);
} else {
if (free_addr) rktio_addrinfo_free(dest_addr);
if (can_error)
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"%s: send failed\n"
@ -2037,9 +2011,9 @@ static Scheme_Object *udp_send_it(const char *name, int argc, Scheme_Object *arg
Scheme_UDP *udp;
char *address = "";
intptr_t start, end;
int delta, err;
int delta;
unsigned short id;
rktio_addr_info *dest_addr;
rktio_addrinfo_t *dest_addr;
udp = (Scheme_UDP *)argv[0];
@ -2070,14 +2044,13 @@ static Scheme_Object *udp_send_it(const char *name, int argc, Scheme_Object *arg
scheme_security_check_network(name, address, id, 1);
dest_addr = do_resolve_address(name, address, id, RKTIO_FAMILTY_ANY, 1);
dest_addr = do_resolve_address(name, address, id, RKTIO_FAMILY_ANY, 1);
} else {
dest_addr = NULL;
}
if (fill_evt) {
char *s;
fill_evt->str = SCHEME_BYTE_STR_VAL(argv[3+delta]);
fill_evt->offset = start;
fill_evt->len = end - start;
@ -2151,10 +2124,7 @@ static void udp_recv_needs_wakeup(Scheme_Object *_udp, void *fds)
static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t start, intptr_t end,
int can_block, int can_error, Scheme_Object **v)
{
intptr_t x;
int errid = 0;
char src_addr[MZ_SOCK_NAME_MAX_LEN];
unsigned int asize = sizeof(src_addr);
rktio_length_and_addrinfo_t *result;
if (!udp->bound) {
if (can_error)
@ -2167,8 +2137,6 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
}
while (1) {
rktio_length_and_addrinfo_t *result;
if (!udp->s) {
/* socket was closed, maybe while we slept */
if (can_error)
@ -2179,7 +2147,7 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
return -1;
}
result = rktio_udp_recvfrom(scheme_rktio, udp->s, buf, end - start);
result = rktio_udp_recvfrom(scheme_rktio, udp->s, bstr XFORM_OK_PLUS start, end - start);
if (!result) {
if (scheme_last_error_is_racket(RKTIO_ERROR_TRY_AGAIN)
@ -2193,7 +2161,7 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
/* Block and eventually try again. */
{
Scheme_Object *sema;
sema = scheme_fd_to_semaphore(udp->s, MZFD_CREATE_READ, 1);
sema = scheme_rktio_fd_to_semaphore(udp->s, MZFD_CREATE_READ);
if (sema)
scheme_wait_sema(sema, 0);
else
@ -2213,12 +2181,14 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
} else {
/* Data received */
char prev_buf[64];
int id;
v[0] = scheme_make_integer(result->len);
if (udp->previous_from_addr) {
/* See if we can use this cached string */
mzchar *s;
int j;
s = SCHEME_CHAR_STR_VAL(udp->previous_from_addr);
for (j = 0; s[j]; j++) {
prev_buf[j] = (char)s[j];
@ -2239,6 +2209,11 @@ static int do_udp_recv(const char *name, Scheme_UDP *udp, char *bstr, intptr_t s
v[2] = scheme_make_integer(id);
free(result->address[0]);
free(result->address[1]);
free(result->address);
free(result);
return 1;
}
}
@ -2267,8 +2242,8 @@ static Scheme_Object *udp_recv(const char *name, int argc, Scheme_Object *argv[]
fill_evt->len = end - start;
return scheme_void;
} else {
do_udp_recv(name, udp, SCHEME_BYTE_STR_VAL(argv[1]), start, end, can_block, v, 1);
do_udp_recv(name, udp, SCHEME_BYTE_STR_VAL(argv[1]), start, end, can_block, 1, v);
return scheme_values(3,v);
}
}
@ -2355,7 +2330,7 @@ static int udp_evt_check_ready(Scheme_Object *_uw, Scheme_Schedule_Info *sinfo)
r = do_udp_recv("udp-receive!-evt", uw->udp,
uw->str, uw->offset, uw->offset + uw->len,
0, v, !sinfo->false_pos_ok);
0, !sinfo->false_positive_ok, v);
if (r) {
if (r != -1)
scheme_set_sync_target(sinfo, scheme_build_list(3, v), NULL, NULL, 0, 0, NULL);
@ -2371,7 +2346,7 @@ static int udp_evt_check_ready(Scheme_Object *_uw, Scheme_Schedule_Info *sinfo)
r = do_udp_send_it("udp-send-evt", uw->udp,
uw->str, uw->offset, uw->offset + uw->len,
uw->dest_addr, 0,
0, !sinfo->false_pos_ok);
0, !sinfo->false_positive_ok);
if (!r || SCHEME_TRUEP(r)) {
scheme_set_sync_target(sinfo, scheme_void, NULL, NULL, 0, 0, NULL);
return 1;
@ -2399,7 +2374,7 @@ static void udp_check_open(char const *name, int argc, Scheme_Object *argv[])
if (!SCHEME_UDPP(argv[0]))
scheme_wrong_contract(name, "udp?", 0, argc, argv);
if (udp->s == INVALID_SOCKET) {
if (!udp->s) {
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"%s: udp socket was already closed\n"
" socket: %V",
@ -2504,7 +2479,8 @@ static Scheme_Object *
udp_multicast_set_interface(int argc, Scheme_Object *argv[])
{
Scheme_UDP *udp = (Scheme_UDP *)argv[0];
rktio_addr_info_t *addr;
rktio_addrinfo_t *addr;
Scheme_Object *bs;
int r;
if (!SCHEME_UDPP(argv[0]))
@ -2517,10 +2493,15 @@ udp_multicast_set_interface(int argc, Scheme_Object *argv[])
udp_check_open("udp-multicast-set-interface!", argc, argv);
addr = do_resolve_address("udp-multicast-set-interface!", SCHEME_BYTE_STR_VAL(bs), -1, udp_default_family(), 0);
if (SCHEME_CHAR_STRINGP(argv[1])) {
bs = scheme_char_string_to_byte_string(argv[1]);
addr = do_resolve_address("udp-multicast-set-interface!", SCHEME_BYTE_STR_VAL(bs), -1, udp_default_family(), 0);
} else
addr = NULL;
r = rktio_udp_set_multicast_interface(scheme_rktio, scheme_rktio, addr);
rktio_addrinfo_free(addr);
r = rktio_udp_set_multicast_interface(scheme_rktio, udp->s, addr);
if (addr) rktio_addrinfo_free(scheme_rktio, addr);
if (!r)
scheme_raise_exn(MZEXN_FAIL_NETWORK,
@ -2529,7 +2510,6 @@ udp_multicast_set_interface(int argc, Scheme_Object *argv[])
return scheme_void;
}
}
static Scheme_Object *
do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *udp,
@ -2539,6 +2519,8 @@ do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *
Scheme_Object *bs;
rktio_addrinfo_t *multi_addr, *intf_addr;
char *address;
rktio_addrinfo_lookup_t *lookup;
int r;
pd = make_connect_progress_data();
@ -2566,10 +2548,10 @@ do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *
pd->dest_addr = multi_addr;
if (SCHEME_FALSEP(intfaddrname)) {
if (SCHEME_FALSEP(ifaddrname)) {
intf_addr = NULL;
} else {
bs = scheme_char_string_to_byte_string(intfaddrname);
bs = scheme_char_string_to_byte_string(ifaddrname);
address = SCHEME_BYTE_STR_VAL(bs);
lookup = rktio_start_addrinfo_lookup(scheme_rktio, address, -1, udp_default_family(), 0, 0);
@ -2583,7 +2565,7 @@ do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *
intf_addr = NULL;
if (!intf_addr) {
rktio_addrinfo_free(multi_addr);
rktio_addrinfo_free(scheme_rktio, multi_addr);
scheme_raise_exn(MZEXN_FAIL_NETWORK,
"%s: can't resolve interface address\n"
" address: %s\n"
@ -2598,8 +2580,8 @@ do_udp_multicast_join_or_leave_group(char const *name, int optname, Scheme_UDP *
intf_addr,
optname);
rktio_addrinfo_free(multi_addr);
if (intf_addr) rktio_addrinfo_free(intf_addr);
rktio_addrinfo_free(scheme_rktio, multi_addr);
if (intf_addr) rktio_addrinfo_free(scheme_rktio, intf_addr);
if (!r)
@ -2678,5 +2660,3 @@ static void register_traversers(void)
END_XFORM_SKIP;
#endif
#endif /* !NO_TCP_SUPPORT */

281
racket/src/racket/src/port.c
View File

@ -31,6 +31,8 @@
#include "schpriv.h"
#include "schmach.h"
#include "schrktio.h"
#include <errno.h>
#define mzAssert(x) /* if (!(x)) abort() */
@ -51,6 +53,7 @@ typedef struct {
typedef struct Scheme_Subprocess {
Scheme_Object so;
rktio_process_t *proc;
Scheme_Custodian_Reference *mref;
} Scheme_Subprocess;
/******************** refcounts ********************/
@ -108,13 +111,15 @@ static int adj_refcount(int *refcount, int amt)
static int *stdin_refcount, *stdout_refcount, *stderr_refcount;
# define MZPORT_FD_BUFFSIZE 4096
# define MZPORT_FD_DIRECT_THRESHOLD MZPORT_FD_BUFFSIZE
/* The Scheme_FD type is used for both input and output */
typedef struct Scheme_FD {
MZTAG_IF_REQUIRED
rktio_fd_t fd;
rktio_fd_t *fd;
intptr_t bufcount, buffpos;
char flushing, flush;
unsigned char *buffer;
char *buffer;
int *refcount;
Scheme_Object *flush_handle; /* output port: registration with plumber */
@ -139,8 +144,8 @@ int scheme_get_serialized_fd_flags(Scheme_Object* p, Scheme_Serialized_File_FD *
fds = (Scheme_FD *) ((Scheme_Output_Port *)p)->port_data;
so->name = ((Scheme_Output_Port *)p)->name;
}
so->regfile = rktio_fd_is_regular_file(fds->fd);
so->textmode = (fds->textmode ? 1 : 0);
so->regfile = rktio_fd_is_regular_file(scheme_rktio, fds->fd);
so->textmode = rktio_fd_is_text_converted(scheme_rktio, fds->fd);
so->flush_mode = fds->flush;
return 1;
}
@ -186,10 +191,8 @@ THREAD_LOCAL_DECL(static int the_fd);
READ_ONLY static Scheme_Object *fd_input_port_type;
READ_ONLY static Scheme_Object *file_input_port_type;
READ_ONLY Scheme_Object *scheme_string_input_port_type;
#ifdef USE_TCP
READ_ONLY Scheme_Object *scheme_tcp_input_port_type;
READ_ONLY Scheme_Object *scheme_tcp_output_port_type;
#endif
READ_ONLY static Scheme_Object *fd_output_port_type;
READ_ONLY static Scheme_Object *file_output_port_type;
READ_ONLY Scheme_Object *scheme_string_output_port_type;
@ -214,12 +217,10 @@ THREAD_LOCAL_DECL(static int put_external_event_fd);
static void register_port_wait();
#ifdef MZ_FDS
static intptr_t flush_fd(Scheme_Output_Port *op,
const char * volatile bufstr, volatile uintptr_t buflen,
volatile uintptr_t offset, int immediate_only, int enable_break);
static void flush_if_output_fds(Scheme_Object *o, Scheme_Close_Custodian_Client *f, void *data);
#endif
static Scheme_Object *subprocess(int c, Scheme_Object *args[]);
static Scheme_Object *subprocess_status(int c, Scheme_Object *args[]);
@ -232,6 +233,8 @@ static Scheme_Object *current_subproc_cust_mode (int, Scheme_Object *[]);
static Scheme_Object *subproc_group_on (int, Scheme_Object *[]);
static void register_subprocess_wait();
static void unix_turn_off_timer(void);
typedef struct Scheme_Read_Write_Evt {
Scheme_Object so;
Scheme_Object *port;
@ -247,12 +250,7 @@ static int progress_evt_ready(Scheme_Object *rww, Scheme_Schedule_Info *sinfo);
static int closed_evt_ready(Scheme_Object *rww, Scheme_Schedule_Info *sinfo);
static int filesystem_change_evt_ready(Scheme_Object *evt, Scheme_Schedule_Info *sinfo);
#if defined(DOS_FILE_SYSTEM) || defined(HAVE_INOTIFY_SYSCALL)
static void filesystem_change_evt_need_wakeup (Scheme_Object *port, void *fds);
#else
# define filesystem_change_evt_need_wakeup NULL
#endif
static Scheme_Object *
_scheme_make_named_file_input_port(FILE *fp, Scheme_Object *name, int regfile);
@ -344,10 +342,8 @@ scheme_init_port (Scheme_Env *env)
REGISTER_SO(fd_output_port_type);
REGISTER_SO(file_input_port_type);
REGISTER_SO(scheme_string_input_port_type);
#ifdef USE_TCP
REGISTER_SO(scheme_tcp_input_port_type);
REGISTER_SO(scheme_tcp_output_port_type);
#endif
REGISTER_SO(file_output_port_type);
REGISTER_SO(scheme_string_output_port_type);
REGISTER_SO(scheme_user_input_port_type);
@ -357,10 +353,6 @@ scheme_init_port (Scheme_Env *env)
REGISTER_SO(scheme_null_output_port_type);
REGISTER_SO(scheme_redirect_output_port_type);
#if defined(UNIX_PROCESSES) && !defined(MZ_PLACES_WAITPID)
REGISTER_SO(scheme_system_children);
#endif
#ifndef DONT_IGNORE_PIPE_SIGNAL
START_XFORM_SKIP;
MZ_SIGSET(SIGPIPE, SIG_IGN);
@ -387,10 +379,8 @@ scheme_init_port (Scheme_Env *env)
scheme_pipe_read_port_type = scheme_make_port_type("<pipe-input-port>");
scheme_pipe_write_port_type = scheme_make_port_type("<pipe-output-port>");
#ifdef USE_TCP
scheme_tcp_input_port_type = scheme_make_port_type("<tcp-input-port>");
scheme_tcp_output_port_type = scheme_make_port_type("<tcp-output-port>");
#endif
scheme_null_output_port_type = scheme_make_port_type("<null-output-port>");
scheme_redirect_output_port_type = scheme_make_port_type("<redirect-output-port>");
@ -423,7 +413,6 @@ void scheme_init_port_wait()
void scheme_init_port_places(void)
{
#ifdef MZ_FDS
scheme_add_atexit_closer(flush_if_output_fds);
/* Note: other threads might continue to write even after
the flush completes, but that's the threads' problem.
@ -438,7 +427,6 @@ void scheme_init_port_places(void)
stdout_refcount = malloc_refcount(1, 0);
stderr_refcount = malloc_refcount(1, 0);
}
#endif
REGISTER_SO(read_string_byte_buffer);
REGISTER_SO(scheme_orig_stdout_port);
@ -446,26 +434,24 @@ void scheme_init_port_places(void)
REGISTER_SO(scheme_orig_stdin_port);
scheme_orig_stdin_port = (scheme_make_stdin
? scheme_make_stdin()
: make_fd_input_port(rktio_std_fd(RKTIO_STDIN), scheme_intern_symbol("stdin"), 0,
: make_fd_input_port(rktio_std_fd(scheme_rktio, RKTIO_STDIN), scheme_intern_symbol("stdin"),
stdin_refcount, 0));
scheme_orig_stdout_port = (scheme_make_stdout
? scheme_make_stdout()
: make_fd_output_port(rktio_std_fd(RKTIO_STDOUT), scheme_intern_symbol("stdout"), 0, 0,
: make_fd_output_port(rktio_std_fd(scheme_rktio, RKTIO_STDOUT), scheme_intern_symbol("stdout"), 0,
-1, stdout_refcount));
scheme_orig_stderr_port = (scheme_make_stderr
? scheme_make_stderr()
: make_fd_output_port(rktio_std_fd(RKTIO_STDERR), scheme_intern_symbol("stderr"), 0, 0,
: make_fd_output_port(rktio_std_fd(scheme_rktio, RKTIO_STDERR), scheme_intern_symbol("stderr"), 0,
MZ_FLUSH_ALWAYS, stderr_refcount));
#ifdef MZ_FDS
if (!scheme_current_place_id) {
adj_refcount(stdin_refcount, -1);
adj_refcount(stdout_refcount, -1);
adj_refcount(stderr_refcount, -1);
}
#endif
flush_out = SCHEME_TRUEP(scheme_terminal_port_p(1, &scheme_orig_stdout_port));
flush_err = SCHEME_TRUEP(scheme_terminal_port_p(1, &scheme_orig_stderr_port));
@ -517,7 +503,7 @@ void scheme_add_fd_handle(void *h, void *fds, int repost)
void scheme_add_fd_nosleep(void *fds)
{
rktio_poll_set_nosleep(scheme_rktio, fds);
rktio_poll_set_add_nosleep(scheme_rktio, fds);
}
void scheme_add_fd_eventmask(void *fds, int mask)
@ -3288,10 +3274,8 @@ scheme_file_stream_port_p (int argc, Scheme_Object *argv[])
if (SAME_OBJ(ip->sub_type, file_input_port_type))
return scheme_true;
#ifdef MZ_FDS
else if (SAME_OBJ(ip->sub_type, fd_input_port_type))
return scheme_true;
#endif
} else if (SCHEME_OUTPUT_PORTP(p)) {
Scheme_Output_Port *op;
@ -3299,10 +3283,8 @@ scheme_file_stream_port_p (int argc, Scheme_Object *argv[])
if (SAME_OBJ(op->sub_type, file_output_port_type))
return scheme_true;
#ifdef MZ_FDS
else if (SAME_OBJ(op->sub_type, fd_output_port_type))
return scheme_true;
#endif
} else {
scheme_wrong_contract("file-stream-port?", "port?", 0, argc, argv);
}
@ -3352,7 +3334,7 @@ int scheme_get_port_file_descriptor(Scheme_Object *p, intptr_t *_fd)
return 1;
}
int scheme_get_port_rktio_file_descriptor(Scheme_Object *p, rktio_fd_t *_fd)
int scheme_get_port_rktio_file_descriptor(Scheme_Object *p, rktio_fd_t **_fd)
{
if (SCHEME_INPUT_PORTP(p)) {
Scheme_Input_Port *ip;
@ -3430,9 +3412,9 @@ static int is_fd_terminal(intptr_t fd)
rktio_fd_t *rfd;
int is_term;
rfd = rktio_system_fd(fd, RKTIO_OPEN_NOT_REGFILE);
rfd = rktio_system_fd(scheme_rktio, fd, RKTIO_OPEN_NOT_REGFILE);
is_term = rktio_fd_is_terminal(scheme_rktio, rfd);
rktio_fd_forget(rfd);
rktio_forget(scheme_rktio, rfd);
return is_term;
}
@ -3457,12 +3439,10 @@ Scheme_Object *scheme_terminal_port_p(int argc, Scheme_Object *argv[])
fd = MSC_IZE(fileno)((FILE *)((Scheme_Input_File *)ip->port_data)->f);
fd_ok = 1;
}
#ifdef MZ_FDS
else if (SAME_OBJ(ip->sub_type, fd_input_port_type)) {
fd = rktio_fd_to_system_fd(((Scheme_FD *)ip->port_data)->fd);
fd = rktio_fd_system_fd(scheme_rktio, ((Scheme_FD *)ip->port_data)->fd);
fd_ok = 1;
}
#endif
} else if (SCHEME_OUTPUT_PORTP(p)) {
Scheme_Output_Port *op;
@ -3475,12 +3455,10 @@ Scheme_Object *scheme_terminal_port_p(int argc, Scheme_Object *argv[])
fd = MSC_IZE (fileno)((FILE *)((Scheme_Output_File *)op->port_data)->f);
fd_ok = 1;
}
#ifdef MZ_FDS
else if (SAME_OBJ(op->sub_type, fd_output_port_type)) {
fd = rktio_fd_to_system_fd(((Scheme_FD *)op->port_data)->fd);
fd = rktio_fd_system_fd(scheme_rktio, ((Scheme_FD *)op->port_data)->fd);
fd_ok = 1;
}
#endif
}
if (!fd_ok)
@ -3513,7 +3491,7 @@ static void filename_exn(char *name, char *msg, char *filename, int maybe_module
rel = dir ? dir : (drive ? drive : "");
post = dir ? "" : "";
if (maybe_module_errno && (err == maybe_module_errno)) {
if (maybe_module_errno && scheme_last_error_is_racket(maybe_module_errno)) {
mod_path = scheme_get_param(scheme_current_config(), MZCONFIG_CURRENT_MODULE_LOAD_PATH);
if (SCHEME_TRUEP(mod_path)) {
if (SCHEME_STXP(mod_path)) {
@ -3561,7 +3539,7 @@ scheme_do_open_input_file(char *name, int offset, int argc, Scheme_Object *argv[
int internal, int for_module)
{
char *filename;
int regfile, i;
int i;
int m_set = 0, mm_set = 0, text_mode = 0;
rktio_fd_t *fd;
@ -3616,8 +3594,8 @@ scheme_do_open_input_file(char *name, int offset, int argc, Scheme_Object *argv[
if (!internal)
scheme_custodian_check_available(NULL, name, "file-stream");
fd = rktio_open(filename, (RKTIO_OPEN_READ
| (text_mode ? RKTIO_OPEN_TEXT : 0)));
fd = rktio_open(scheme_rktio, filename, (RKTIO_OPEN_READ
| (text_mode ? RKTIO_OPEN_TEXT : 0)));
if (!fd) {
filename_exn(name, "cannot open input file", filename, RKTIO_ERROR_DOES_NOT_EXIST);
@ -3636,6 +3614,7 @@ scheme_do_open_output_file(char *name, int offset, int argc, Scheme_Object *argv
char *filename;
char mode[4];
int typepos;
rktio_fd_t *fd;
mode[0] = 'w';
mode[1] = 'b';
@ -3738,9 +3717,9 @@ scheme_do_open_output_file(char *name, int offset, int argc, Scheme_Object *argv
scheme_custodian_check_available(NULL, name, "file-stream");
fd = rktio_open(filename, (RKTIO_OPEN_WRITE
| (and_read ? RKTIO_OPEN_READ : 0)
| ((mode[1] == 't') ? RKTIO_OPEN_TEXT : 0)));
fd = rktio_open(scheme_rktio, filename, (RKTIO_OPEN_WRITE
| (and_read ? RKTIO_OPEN_READ : 0)
| ((mode[1] == 't') ? RKTIO_OPEN_TEXT : 0)));
if (!fd) {
if (scheme_last_error_is_racket(RKTIO_ERROR_EXISTS)) {
@ -3943,9 +3922,6 @@ do_file_position(const char *who, int argc, Scheme_Object *argv[], int can_false
errno);
}
} else if (fd) {
intptr_t lv;
int errid = 0;
if (!SCHEME_INPUT_PORTP(argv[0])) {
flush_fd(scheme_output_port_record(argv[0]), NULL, 0, 0, 0, 0);
}
@ -3953,7 +3929,7 @@ do_file_position(const char *who, int argc, Scheme_Object *argv[], int can_false
if (!rktio_set_file_position(scheme_rktio, fd, nll,
((whence == SEEK_SET)
? RKTIO_POSITION_FROM_START
: RKTIO_POSITION_FROM__END))) {
: RKTIO_POSITION_FROM_END))) {
scheme_raise_exn(MZEXN_FAIL_FILESYSTEM,
"file-position: position change failed on stream\n"
" system error: %R");
@ -4049,12 +4025,12 @@ do_file_position(const char *who, int argc, Scheme_Object *argv[], int can_false
Scheme_Input_Port *ip;
ip = scheme_input_port_record(argv[0]);
pll -= ((Scheme_FD *)ip->port_data)->bufcount;
if (rktio_fd_is_text_converted(fd)) {
if (rktio_fd_is_text_converted(scheme_rktio, fd)) {
/* Correct for CRLF->LF conversion of buffer content */
int bp, bd;
bd = ((Scheme_FD *)ip->port_data)->buffpos;
for (bp = ((Scheme_FD *)ip->port_data)->bufcount; bp--; ) {
if (ip->bufwidths[bp + bd]) {
if (((Scheme_FD *)ip->port_data)->bufwidths[bp + bd]) {
/* this is a LF converted from CRLF */
pll--;
}
@ -4106,7 +4082,7 @@ Scheme_Object *scheme_file_truncate(int argc, Scheme_Object *argv[])
mzlonglong nll;
Scheme_Output_Port *op;
rktio_fd_t *fd;
int errid;
int free_fd = 0, ok;
if (!SCHEME_OUTPUT_PORTP(argv[0])
|| SCHEME_FALSEP(scheme_file_stream_port_p(1, argv)))
@ -4125,22 +4101,28 @@ Scheme_Object *scheme_file_truncate(int argc, Scheme_Object *argv[])
op = scheme_output_port_record(argv[0]);
if (SAME_OBJ(op->sub_type, file_output_port_type)) {
fd = MSC_IZE (fileno)((FILE *)((Scheme_Output_File *)op->port_data)->f);
intptr_t sfd;
sfd = MSC_IZE (fileno)((FILE *)((Scheme_Output_File *)op->port_data)->f);
fd = rktio_system_fd(scheme_rktio, sfd, RKTIO_OPEN_NOT_REGFILE);
free_fd = 1;
} else if (SAME_OBJ(op->sub_type, fd_output_port_type)) {
fd = ((Scheme_FD *)op->port_data)->fd;
} else
return scheme_void;
errid = -1;
flush_fd(scheme_output_port_record(argv[0]), NULL, 0, 0, 0, 0);
ok = rktio_set_file_size(scheme_rktio, fd, nll);
if (free_fd) rktio_forget(scheme_rktio, fd);
if (!rktio_set_file_size(scheme_rktio, fd, nll)) {
if (!ok) {
scheme_raise_exn(MZEXN_FAIL_FILESYSTEM,
"file-truncate: size change failed\n"
" system error: %R");
}
return NULL;
return scheme_void;
}
intptr_t scheme_set_file_position(Scheme_Object *port, intptr_t pos)
@ -4275,11 +4257,11 @@ Scheme_Object *scheme_file_try_lock(int argc, Scheme_Object **argv)
check_already_closed("port-try-file-lock?", argv[0]);
if (!rfd) {
rfd = scheme_system_fd(scheme_rktio, fd, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE);
r = rktio_file_lock_try(scheme_rktio, rfd, write);
rfd = rktio_system_fd(scheme_rktio, fd, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_NOT_REGFILE);
r = rktio_file_lock_try(scheme_rktio, rfd, writer);
rktio_forget(scheme_rktio, rfd);
} else
r = rktio_file_lock_try(scheme_rktio, rfd, write);
r = rktio_file_lock_try(scheme_rktio, rfd, writer);
if (r == RKTIO_LOCK_ACQUIRED)
return scheme_true;
@ -4307,11 +4289,11 @@ Scheme_Object *scheme_file_unlock(int argc, Scheme_Object **argv)
check_already_closed("port-file-unlock", argv[0]);
if (!rfd) {
rfd = scheme_system_fd(scheme_rktio, fd, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE);
r = rktio_file_unlock(scheme_rktio, rfd, write);
rfd = rktio_system_fd(scheme_rktio, fd, RKTIO_OPEN_READ | RKTIO_OPEN_WRITE | RKTIO_OPEN_NOT_REGFILE);
r = rktio_file_unlock(scheme_rktio, rfd);
rktio_forget(scheme_rktio, rfd);
} else
r = rktio_file_unlock(rktio, fd);
r = rktio_file_unlock(scheme_rktio, rfd);
if (!r) {
scheme_raise_exn(MZEXN_FAIL_FILESYSTEM,
@ -4329,15 +4311,12 @@ Scheme_Object *scheme_file_unlock(int argc, Scheme_Object **argv)
Scheme_Object *scheme_filesystem_change_evt(Scheme_Object *path, int flags, int signal_errs)
{
char *filename;
int ok = 0;
rktio_fs_change_t *rfc;
filename = scheme_expand_string_filename(path,
"filesystem-change-evt",
NULL,
SCHEME_GUARD_FILE_EXISTS);
fd = 0;
rfc = rktio_fs_change(scheme_rktio, filename);
if (!rfc) {
@ -4383,8 +4362,8 @@ void scheme_filesystem_change_evt_cancel(Scheme_Object *evt, void *ignored_data)
static int filesystem_change_evt_ready(Scheme_Object *evt, Scheme_Schedule_Info *sinfo)
{
Scheme_Filesystem_Change_Evt *fc = (Scheme_Filesystem_Change_Evt *)evt;
if (!fc->rfd)
if (!fc->rfc)
return 1;
if (rktio_poll_fs_change_ready(scheme_rktio, fc->rfc))
@ -4393,7 +4372,7 @@ static int filesystem_change_evt_ready(Scheme_Object *evt, Scheme_Schedule_Info
return 0;
}
static void filesystem_change_evt_need_wakeup (Scheme_Object *evt, void *fds)
static void filesystem_change_evt_need_wakeup(Scheme_Object *evt, void *fds)
{
Scheme_Filesystem_Change_Evt *fc = (Scheme_Filesystem_Change_Evt *)evt;
@ -4558,7 +4537,7 @@ fd_byte_ready (Scheme_Input_Port *port)
{
Scheme_FD *fip = (Scheme_FD *)port->port_data;
if (fip->regfile || port->closed)
if (port->closed || rktio_fd_is_regular_file(scheme_rktio, fip->fd))
return 1;
if (fip->bufcount)
@ -4606,7 +4585,7 @@ static intptr_t fd_get_string_slow(Scheme_Input_Port *port,
if (nonblock > 0)
return 0;
sema = scheme_fd_to_semaphore(fip->fd, MZFD_CREATE_READ, 0);
sema = scheme_rktio_fd_to_semaphore(fip->fd, MZFD_CREATE_READ);
if (sema)
scheme_wait_sema(sema, nonblock ? -1 : 0);
@ -4762,9 +4741,9 @@ fd_close_input(Scheme_Input_Port *port)
rc = adj_refcount(fip->refcount, -1);
if (!rc) {
rktio_close(fip->fd);
rktio_close(scheme_rktio, fip->fd);
} else {
rktio_forget(fip->fd);
rktio_forget(scheme_rktio, fip->fd);
}
}
@ -4794,7 +4773,7 @@ make_fd_input_port(rktio_fd_t *fd, Scheme_Object *name, int *refcount, int inter
{
Scheme_Input_Port *ip;
Scheme_FD *fip;
unsigned char *bfr;
char *bfr;
int start_closed = 0;
fip = MALLOC_ONE_RT(Scheme_FD);
@ -4802,7 +4781,7 @@ make_fd_input_port(rktio_fd_t *fd, Scheme_Object *name, int *refcount, int inter
fip->type = scheme_rt_input_fd;
#endif
bfr = (unsigned char *)scheme_malloc_atomic(MZPORT_FD_BUFFSIZE);
bfr = (char *)scheme_malloc_atomic(MZPORT_FD_BUFFSIZE);
fip->buffer = bfr;
if (rktio_fd_is_text_converted(scheme_rktio, fd)) {
char *bws;
@ -4818,7 +4797,7 @@ make_fd_input_port(rktio_fd_t *fd, Scheme_Object *name, int *refcount, int inter
if (!adj_refcount(refcount, 1)) {
/* fd is already closed! */
start_closed = 1;
rktio_fd_forget(fd);
rktio_forget(scheme_rktio, fd);
fip->fd = NULL;
}
}
@ -4859,7 +4838,7 @@ scheme_make_fd_input_port(int fd, Scheme_Object *name, int regfile, int textmode
| (regfile
? RKTIO_OPEN_REGFILE
: RKTIO_OPEN_NOT_REGFILE)
| (textmode ? RKTIO_OPEN_TEXT)));
| (textmode ? RKTIO_OPEN_TEXT : 0)));
return make_fd_input_port(rfd, name, NULL, 0);
}
@ -5000,7 +4979,7 @@ fd_write_ready (Scheme_Object *port)
if (op->closed)
return 1;
if (rktio_poll_write_ready(scheme_rktio, fop->fd);
return rktio_poll_write_ready(scheme_rktio, fop->fd);
}
static void
@ -5009,7 +4988,10 @@ fd_write_need_wakeup(Scheme_Object *port, void *fds)
Scheme_Output_Port *op;
Scheme_FD *fop;
rktio_poll_add(scheme_rktio, fds, fop->fd, RKTIO_POLL_WRITE);
op = scheme_output_port_record(port);
fop = (Scheme_FD *)op->port_data;
rktio_poll_add(scheme_rktio, fop->fd, fds, RKTIO_POLL_WRITE);
}
static void release_flushing_lock(void *_fop)
@ -5060,9 +5042,8 @@ static intptr_t flush_fd(Scheme_Output_Port *op,
while (1) {
intptr_t len;
int errsaved, full_write_buffer;
len = rktio_write(scheme_rktio, fop->fd, bufstr + offset, amt);
len = rktio_write(scheme_rktio, fop->fd, bufstr + offset, buflen - offset);
if (!len) {
/* Need to block; remember that we're holding a lock. */
@ -5073,7 +5054,7 @@ static intptr_t flush_fd(Scheme_Output_Port *op,
return wrote;
}
sema = scheme_fd_to_semaphore(fop->fd, MZFD_CREATE_WRITE, 0);
sema = scheme_rktio_fd_to_semaphore(fop->fd, MZFD_CREATE_WRITE);
BEGIN_ESCAPEABLE(release_flushing_lock, fop);
if (sema)
@ -5088,12 +5069,11 @@ static intptr_t flush_fd(Scheme_Output_Port *op,
if (scheme_force_port_closed) {
/* Don't signal exn or wait. Just give up. */
return wrote;
} else else {
} else {
fop->flushing = 0;
scheme_raise_exn(MZEXN_FAIL_FILESYSTEM,
"error writing to stream port\n"
" system error: %R",
errsaved);
" system error: %R");
return 0; /* doesn't get here */
}
} else if ((len + offset == buflen) || immediate_only) {
@ -5215,7 +5195,7 @@ static int end_fd_flush_done(Scheme_Object *fop)
static void end_fd_flush_needs_wakeup(Scheme_Object *fop, void *fds)
{
rktio_poll_add(scheme_rktio, fds, ((Scheme_FD *)fop)->fd, RKTIO_POLL_FLUSH);
rktio_poll_add(scheme_rktio, ((Scheme_FD *)fop)->fd, fds, RKTIO_POLL_FLUSH);
}
static void
@ -5247,9 +5227,9 @@ fd_close_output(Scheme_Output_Port *port)
rc = adj_refcount(fop->refcount, -1);
if (fop->fd) {
if (!rc)
rktio_close(scheme_rktio, (HANDLE)fop->fd);
rktio_close(scheme_rktio, fop->fd);
else
rktio_fd_forget(scheme_rktio, (HANDLE)fop->fd);
rktio_forget(scheme_rktio, fop->fd);
}
}
@ -5282,7 +5262,7 @@ static Scheme_Object *
make_fd_output_port(rktio_fd_t *fd, Scheme_Object *name, int and_read, int flush_mode, int *refcount)
{
Scheme_FD *fop;
unsigned char *bfr;
char *bfr;
Scheme_Object *the_port, *fh;
int start_closed = 0;
@ -5291,7 +5271,7 @@ make_fd_output_port(rktio_fd_t *fd, Scheme_Object *name, int and_read, int flush
fop->type = scheme_rt_input_fd;
#endif
bfr = (unsigned char *)scheme_malloc_atomic(MZPORT_FD_BUFFSIZE);
bfr = (char *)scheme_malloc_atomic(MZPORT_FD_BUFFSIZE);
fop->buffer = bfr;
fop->fd = fd;
@ -5299,7 +5279,7 @@ make_fd_output_port(rktio_fd_t *fd, Scheme_Object *name, int and_read, int flush
if (flush_mode > -1) {
fop->flush = flush_mode;
} else if (is_fd_terminal(fd)) {
} else if (rktio_fd_is_terminal(scheme_rktio, fd)) {
/* Line-buffering for terminal: */
fop->flush = MZ_FLUSH_BY_LINE;
} else {
@ -5342,7 +5322,7 @@ make_fd_output_port(rktio_fd_t *fd, Scheme_Object *name, int and_read, int flush
rc = malloc_refcount(1, 1);
fop->refcount = rc;
a[1] = the_port;
a[0] = make_fd_input_port(fd, name, regfile, win_textmode, rc, 0);
a[0] = make_fd_input_port(fd, name, rc, 0);
return scheme_values(2, a);
} else
return the_port;
@ -5371,7 +5351,7 @@ scheme_make_fd_output_port(int fd, Scheme_Object *name, int regfile, int textmod
rfd = rktio_system_fd(scheme_rktio,
fd,
(RKTIO_OPEN_WRITE
| (regefile ? RKTIO_OPEN_REGFILE : RKTIO_OPEN_NOT_REGFILE)
| (regfile ? RKTIO_OPEN_REGFILE : RKTIO_OPEN_NOT_REGFILE)
| (read_too ? RKTIO_OPEN_READ : 0)
| (textmode ? RKTIO_OPEN_TEXT : 0)));
@ -5737,7 +5717,7 @@ static void subp_needs_wakeup(Scheme_Object *so, void *fds)
Scheme_Subprocess *sp = (Scheme_Subprocess*)so;
if (sp->proc)
rktio_poll_add_process(rktio_t *rktio, sp->proc, fds);
rktio_poll_add_process(scheme_rktio, sp->proc, fds);
}
static Scheme_Object *subprocess_status(int argc, Scheme_Object **argv)
@ -5760,7 +5740,7 @@ static Scheme_Object *subprocess_status(int argc, Scheme_Object **argv)
free(st);
return scheme_intern_symbol("running");
} else {
int status = st->status;
int status = st->result;
free(st);
child_mref_done(sp);
return scheme_make_integer_value(status);
@ -5791,6 +5771,7 @@ static Scheme_Object *subprocess_wait(int argc, Scheme_Object **argv)
static Scheme_Object *do_subprocess_kill(Scheme_Object *_sp, Scheme_Object *killp, int can_error)
{
Scheme_Subprocess *sp = (Scheme_Subprocess *)_sp;
int ok;
if (!sp->proc)
return scheme_void;
@ -5830,6 +5811,8 @@ static Scheme_Object *subprocess_kill(int argc, Scheme_Object **argv)
static Scheme_Object *subprocess_pid(int argc, Scheme_Object **argv)
{
intptr_t pid;
if (!SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_subprocess_type))
scheme_wrong_contract("subprocess-pid", "subprocess?", 0, argc, argv);
@ -5881,14 +5864,17 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
Scheme_Object *errport;
Scheme_Object *a[4];
Scheme_Subprocess *subproc;
Scheme_Object *cust_mode;
Scheme_Object *cust_mode, *current_dir;
int flags = 0;
rktio_fd_t *stdout_fd = NULL;
rktio_fd_t *stdin_fd = NULL;
rktio_fd_t *stderr_fd = NULL;
int need_forget_out = 0, need_forget_in = 0, need_forget_err = 0;
int need_forget_out = 0, need_forget_in = 0, need_forget_err = 0, new_process_group = 0;
rktio_envvars_t *envvars;
rktio_process_result_t *result;
Scheme_Config *config;
int argc;
char **argv, *command;
/*--------------------------------------------*/
/* Sort out ports (create later if necessary) */
@ -5904,7 +5890,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
if (SAME_OBJ(op->sub_type, file_output_port_type)) {
int tmp;
tmp = MSC_IZE(fileno)(((Scheme_Output_File *)op->port_data)->f);
stdout_fd = rktio_system_fd(tmp, RKTIO_OPEN_WRITE | RKTIO_NOT_REGFILE);
stdout_fd = rktio_system_fd(scheme_rktio, tmp, RKTIO_OPEN_WRITE | RKTIO_OPEN_NOT_REGFILE);
need_forget_out = 1;
} else if (SAME_OBJ(op->sub_type, fd_output_port_type))
stdout_fd = ((Scheme_FD *)op->port_data)->fd;
@ -5922,7 +5908,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
if (SAME_OBJ(ip->sub_type, file_input_port_type)) {
int tmp;
tmp = MSC_IZE(fileno)(((Scheme_Input_File *)ip->port_data)->f);
stdin_fd = rktio_system_fd(tmp, RKTIO_OPEN_READ | RKTIO_NOT_REGFILE);
stdin_fd = rktio_system_fd(scheme_rktio, tmp, RKTIO_OPEN_READ | RKTIO_OPEN_NOT_REGFILE);
need_forget_in = 1;
} else if (SAME_OBJ(ip->sub_type, fd_input_port_type))
stdin_fd = ((Scheme_FD *)ip->port_data)->fd;
@ -5943,7 +5929,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
if (SAME_OBJ(op->sub_type, file_output_port_type)) {
int tmp;
tmp = MSC_IZE(fileno)(((Scheme_Output_File *)op->port_data)->f);
stderr_fd = rktio_system_fd(tmp, RKTIO_OPEN_WRITE | RKTIO_NOT_REGFILE);
stderr_fd = rktio_system_fd(scheme_rktio, tmp, RKTIO_OPEN_WRITE | RKTIO_OPEN_NOT_REGFILE);
need_forget_err = 1;
} else if (SAME_OBJ(op->sub_type, fd_output_port_type))
stderr_fd = ((Scheme_FD *)op->port_data)->fd;
@ -5958,7 +5944,8 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
/* Sort out arguments */
/*--------------------------------------*/
argv = MALLOC_N(char *, c - 3 + 1);
argc = c - 3;
argv = MALLOC_N(char *, argc);
{
char *ef;
ef = scheme_expand_string_filename(args[3],
@ -5994,6 +5981,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
"exact command", 1, args[5],
NULL);
} else {
int i;
for (i = 4; i < c; i++) {
if (((!SCHEME_CHAR_STRINGP(args[i]) && !SCHEME_BYTE_STRINGP(args[i]))
|| scheme_any_string_has_null(args[i]))
@ -6009,7 +5997,6 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
argv[i - 3] = SCHEME_BYTE_STR_VAL(bs);
}
}
argv[c - 3] = NULL;
}
command = argv[0];
@ -6021,9 +6008,11 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
/* Create subprocess */
/*--------------------------------------*/
cust_mode = scheme_get_param(scheme_current_config(), MZCONFIG_SUBPROC_GROUP_ENABLED);
config = scheme_current_config();
cust_mode = scheme_get_param(config, MZCONFIG_SUBPROC_GROUP_ENABLED);
new_process_group = SCHEME_TRUEP(cust_mode);
cust_mode = scheme_get_param(scheme_current_config(), MZCONFIG_SUBPROC_CUSTODIAN_MODE);
cust_mode = scheme_get_param(config, MZCONFIG_SUBPROC_CUSTODIAN_MODE);
if (SCHEME_SYMBOLP(cust_mode)
&& !strcmp(SCHEME_SYM_VAL(cust_mode), "kill")
@ -6032,7 +6021,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
current_dir = scheme_get_param(config, MZCONFIG_CURRENT_DIRECTORY);
envvars = environment_variables_to_envvars(scheme_get_param(config, MZCONFIG_CURRENT_ENV_VARS));
envvars = scheme_environment_variables_to_envvars(scheme_get_param(config, MZCONFIG_CURRENT_ENV_VARS));
result = rktio_process(scheme_rktio,
command, argc, argv,
@ -6042,7 +6031,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
unix_turn_off_timer);
if (envvars)
rktio_envvars_free(envvars);
rktio_envvars_free(scheme_rktio, envvars);
if (!result) {
scheme_raise_exn(MZEXN_FAIL,
@ -6059,7 +6048,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
if (result->stdout_fd)
in = make_fd_input_port(result->stdout_fd, scheme_intern_symbol("subprocess-stdout"), NULL, 0);
if (result->stdin_fd)
out = make_fd_output_port(result_stdin_fd, scheme_intern_symbol("subprocess-stdin"), 0, -1, NULL);
out = make_fd_output_port(result->stdin_fd, scheme_intern_symbol("subprocess-stdin"), 0, -1, NULL);
if (result->stderr_fd)
err = (err ? err : make_fd_input_port(result->stderr_fd, scheme_intern_symbol("subprocess-stderr"), NULL, 0));
@ -6069,7 +6058,7 @@ static Scheme_Object *subprocess(int c, Scheme_Object *args[])
subproc = MALLOC_ONE_TAGGED(Scheme_Subprocess);
subproc->so.type = scheme_subprocess_type;
subproc->proc = result->proc;
subproc->proc = result->process;
scheme_add_finalizer(subproc, close_subprocess_handle, NULL);
if (SCHEME_TRUEP(cust_mode)) {
@ -6215,10 +6204,10 @@ static Scheme_Object *sch_shell_execute(int c, Scheme_Object *argv[])
void scheme_reserve_file_descriptor(void)
{
#ifdef USE_FD_PORTS
#ifndef DOS_FILE_SYSTEM
if (!fd_reserved) {
the_fd = open("/dev/null", O_RDONLY);
if (the_fd != -1)
the_fd = rktio_open(scheme_rktio, "/dev/null", RKTIO_OPEN_READ);
if (the_fd)
fd_reserved = 1;
}
#endif
@ -6226,9 +6215,9 @@ void scheme_reserve_file_descriptor(void)
void scheme_release_file_descriptor(void)
{
#ifdef USE_FD_PORTS
#ifndef DOS_FILE_SYSTEM
if (fd_reserved) {
close(the_fd);
rktio_close(scheme_rktio, the_fd);
fd_reserved = 0;
}
#endif
@ -6238,6 +6227,11 @@ void scheme_release_file_descriptor(void)
/* sleeping */
/*========================================================================*/
static void default_sleep(float v, void *fds)
{
rktio_sleep(scheme_rktio, v, fds, scheme_semaphore_fd_set);
}
void scheme_signal_received_at(void *h)
XFORM_SKIP_PROC
/* Ensure that Racket wakes up if asleep. */
@ -6248,7 +6242,7 @@ void scheme_signal_received_at(void *h)
void *scheme_get_signal_handle()
XFORM_SKIP_PROC
{
return (void *)rktio_signal_received(scheme_rktio);
return (void *)rktio_get_signal_handle(scheme_rktio);
}
void scheme_signal_received(void)
@ -6352,6 +6346,7 @@ static void scheme_stop_itimer_thread()
#ifdef USE_PTHREAD_THREAD_TIMER
#include <pthread.h>
#include <unistd.h>
typedef struct ITimer_Data {
int itimer;
int state;
@ -6493,6 +6488,37 @@ static void kickoff_itimer(intptr_t usec)
setitimer(ITIMER_PROF, &t, &old);
}
static void unix_turn_off_timer(void)
XFORM_SKIP_PROC
{
/* Turn off the timer. */
struct itimerval t, old;
sigset_t sigs;
t.it_value.tv_sec = 0;
t.it_value.tv_usec = 0;
t.it_interval.tv_sec = 0;
t.it_interval.tv_usec = 0;
setitimer(ITIMER_PROF, &t, &old);
/* Clear already-queued PROF signal, if any: */
sigemptyset(&sigs);
while (!sigpending(&sigs)) {
if (sigismember(&sigs, SIGPROF)) {
sigprocmask(SIG_SETMASK, NULL, &sigs);
sigdelset(&sigs, SIGPROF);
sigsuspend(&sigs);
sigemptyset(&sigs);
} else
break;
}
}
#else
static void unix_turn_off_timer(void) { }
#endif
void scheme_kickoff_green_thread_time_slice_timer(intptr_t usec) {
@ -6512,16 +6538,6 @@ void scheme_kill_green_thread_timer()
#elif defined(USE_WIN32_THREAD_TIMER)
scheme_stop_itimer_thread();
#endif
#if defined(FILES_HAVE_FDS)
# ifndef USE_OSKIT_CONSOLE
close(external_event_fd);
close(put_external_event_fd);
# endif
#endif
#ifdef WIN32_FD_HANDLES
CloseHandle((HANDLE)scheme_break_semaphore);
#endif
}
#ifdef OS_X
@ -6613,10 +6629,7 @@ void scheme_end_sleeper_thread()
pt_sema_wait(&done_sema);
/* Clear external event flag */
if (external_event_fd) {
char buf[10];
read(external_event_fd, buf, 10);
}
rktio_flush_signals_received(scheme_rktio);
}
#ifdef MZ_PRECISE_GC
@ -6775,13 +6788,7 @@ static void register_traversers(void)
GC_REG_TRAV(scheme_rt_input_file, mark_input_file);
GC_REG_TRAV(scheme_rt_output_file, mark_output_file);
#ifdef MZ_FDS
GC_REG_TRAV(scheme_rt_input_fd, mark_input_fd);
#endif
#if defined(UNIX_PROCESSES) && !defined(MZ_PLACES_WAITPID)
GC_REG_TRAV(scheme_rt_system_child, mark_system_child);
#endif
GC_REG_TRAV(scheme_subprocess_type, mark_subprocess);
GC_REG_TRAV(scheme_write_evt_type, mark_read_write_evt);

2
racket/src/racket/src/read.c
View File

@ -6154,7 +6154,7 @@ Scheme_Object *scheme_load_delayed_code(int _which, Scheme_Load_Delay *_delay_in
scheme_release_file_descriptor();
a[0] = delay_info->path;
port = scheme_do_open_input_file("on-demand-loader", 0, 1, a, 1, NULL, NULL, 0);
port = scheme_do_open_input_file("on-demand-loader", 0, 1, a, 1, 0);
savebuf = scheme_current_thread->error_buf;
scheme_current_thread->error_buf = &newbuf;

8
racket/src/racket/src/schpriv.h
View File

@ -4354,7 +4354,7 @@ Scheme_Object *scheme_terminal_port_p(int, Scheme_Object *[]);
Scheme_Object *scheme_do_open_input_file(char *name, int offset, int argc, Scheme_Object *argv[],
int internal, int for_module);
Scheme_Object *scheme_do_open_output_file(char *name, int offset, int argc, Scheme_Object *argv[], int and_read,
int internal, char **err, int *eerrno);
int internal);
Scheme_Object *scheme_file_position(int argc, Scheme_Object *argv[]);
Scheme_Object *scheme_file_position_star(int argc, Scheme_Object *argv[]);
Scheme_Object *scheme_file_truncate(int argc, Scheme_Object *argv[]);
@ -4366,7 +4366,8 @@ Scheme_Object *scheme_file_unlock(int argc, Scheme_Object **argv);
void scheme_reserve_file_descriptor(void);
void scheme_release_file_descriptor(void);
int scheme_get_port_rktio_file_descriptor(Scheme_Object *p, struct rktio_fd_t *_fd);
struct rktio_fd_t;
int scheme_get_port_rktio_file_descriptor(Scheme_Object *p, struct rktio_fd_t **_fd);
void scheme_fs_change_properties(int *_supported, int *_scalable, int *_low_latency, int *_file_level);
@ -4433,7 +4434,8 @@ void scheme_release_fd_semaphores(void);
void scheme_check_fd_semaphores(void);
Scheme_Object *scheme_rktio_fd_to_semaphore(struct rktio_fd_t *fd, int mode);
rktio_envvars_t *scheme_environment_variables_to_envvars(Scheme_Object *ev);
struct rktio_envvars_t;
struct rktio_envvars_t *scheme_environment_variables_to_envvars(Scheme_Object *ev);
/*========================================================================*/
/* memory debugging */

1
racket/src/racket/src/string.c
View File

@ -2490,6 +2490,7 @@ rktio_envvars_t *scheme_environment_variables_to_envvars(Scheme_Object *ev)
Scheme_Hash_Tree *ht = SCHEME_ENVVARS_TABLE(ev);
rktio_envvars_t *envvars;
mzlonglong i;
Scheme_Object *key, *val;
if (!ht)
return NULL;

45
racket/src/racket/src/thread.c
View File

@ -3814,9 +3814,11 @@ static Scheme_Object *call_as_nested_thread(int argc, Scheme_Object *argv[])
/* thread scheduling and termination */
/*========================================================================*/
static int check_fd_semaphores();
void scheme_init_fd_semaphores(void)
{
scheme_semaphore_fd_set = rktio_open_ltps(scheme_rktio);
scheme_semaphore_fd_set = rktio_ltps_open(scheme_rktio);
}
void scheme_release_fd_semaphores(void)
@ -3824,7 +3826,7 @@ void scheme_release_fd_semaphores(void)
if (scheme_semaphore_fd_set) {
rktio_ltps_remove_all(scheme_rktio, scheme_semaphore_fd_set);
(void)check_fd_semaphores();
rktio_ltps_close(scheme_semaphore_fd_set);
rktio_ltps_close(scheme_rktio, scheme_semaphore_fd_set);
}
}
@ -3837,32 +3839,32 @@ static void log_fd_semaphore_error()
"error for long-term poll set: %R");
}
}
#endif
Scheme_Object *scheme_fd_to_semaphore(intptr_t fd, int mode, int is_socket)
{
rktio_fd_t *rfd;
Scheme_Object *sema;
if (!scheme_semaphore_fd_mapping)
if (!scheme_semaphore_fd_set)
return NULL;
rfd = rktio_system_fd(fd, (RKTIO_OPEN_READ
| RKTIO_OPEN_WRITE
| (is_socket ? RKTIO_OPEN_SOCKET : 0)));
rfd = rktio_system_fd(scheme_rktio, fd, (RKTIO_OPEN_READ
| RKTIO_OPEN_WRITE
| (is_socket ? RKTIO_OPEN_SOCKET : 0)));
sema = scheme_rktio_fd_to_semaphore(rfd, mode);
rktio_forget(rfd);
rktio_forget(scheme_rktio, rfd);
return sema;
}
Scheme_Object *scheme_rktio_fd_to_semaphore(rktio_fd_t *fd, int mode)
{
rktio_handle_t *h;
rktio_ltps_handle_t *h;
void **ib;
if (!scheme_semaphore_fd_mapping)
if (!scheme_semaphore_fd_set)
return NULL;
switch(mode) {
@ -3883,7 +3885,7 @@ Scheme_Object *scheme_rktio_fd_to_semaphore(rktio_fd_t *fd, int mode)
break;
}
h = rktio_ltps_add(scheme_rktio, scheme_semaphore_fd_mapping, fd, mode);
h = rktio_ltps_add(scheme_rktio, scheme_semaphore_fd_set, fd, mode);
if (!h) {
if (scheme_last_error_is_racket(RKTIO_ERROR_LTPS_REMOVED)
@ -3898,16 +3900,18 @@ Scheme_Object *scheme_rktio_fd_to_semaphore(rktio_fd_t *fd, int mode)
ib = rktio_ltps_handle_get_data(scheme_rktio, h);
if (!ib) {
ib = scheme_malloc_immobile_box(scheme_make_sema(0));
rktio_ltps_handle_set_data(scheme_rktio, ib);
rktio_ltps_handle_set_data(scheme_rktio, h, ib);
}
return *(Scheme_Object **)p;
return *(Scheme_Object **)ib;
}
static int check_fd_semaphores()
{
rktio_ltps_handle_t *h;
int did = 0;
void *p;
Scheme_Object *sema;
if (!scheme_semaphore_fd_set)
return 0;
@ -3915,7 +3919,6 @@ static int check_fd_semaphores()
while (1) {
h = rktio_ltps_get_signaled_handle(scheme_rktio, scheme_semaphore_fd_set);
if (h) {
void *p;
p = rktio_ltps_handle_get_data(scheme_rktio, h);
free(h);
@ -3997,10 +4000,6 @@ static int check_sleep(int need_activity, int sleep_now)
{
Scheme_Thread *p, *p2;
int end_with_act;
#if defined(USING_FDS)
DECL_FDSET(set, 3);
fd_set *set1, *set2;
#endif
void *fds;
if (scheme_no_stack_overflow)
@ -4099,12 +4098,12 @@ static int check_sleep(int need_activity, int sleep_now)
}
if (needs_sleep_cancelled) {
rktio_poll_set_close(scheme_rktio, fds);
rktio_poll_set_forget(scheme_rktio, fds);
return 0;
}
if (post_system_idle()) {
rktio_poll_set_close(scheme_rktio, fds);
rktio_poll_set_forget(scheme_rktio, fds);
return 0;
}
@ -9045,9 +9044,6 @@ static void get_ready_for_GC()
#ifdef WINDOWS_PROCESSES
scheme_suspend_remembered_threads();
#endif
#if defined(UNIX_PROCESSES) && !defined(MZ_PLACES_WAITPID)
scheme_block_child_signals(1);
#endif
{
GC_CAN_IGNORE void *data;
@ -9082,9 +9078,6 @@ static void done_with_GC()
#ifdef WINDOWS_PROCESSES
scheme_resume_remembered_threads();
#endif
#if defined(UNIX_PROCESSES) && !defined(MZ_PLACES_WAITPID)
scheme_block_child_signals(0);
#endif
end_this_gc_time = scheme_get_process_milliseconds();
end_this_gc_real_time = scheme_get_inexact_milliseconds();

64
racket/src/rktio/rktio.h
View File

@ -86,7 +86,7 @@ RKTIO_EXTERN rktio_bool_t rktio_fd_is_text_converted(rktio_t *rktio, rktio_fd_t
RKTIO_EXTERN int rktio_fd_modes(rktio_t *rktio, rktio_fd_t *rfd);
/* Returns all of the recorded mode flags. */
RKTIO_EXTERN rktio_fd_t *rktio_open(rktio_t *rktio, char *src, int modes);
RKTIO_EXTERN rktio_fd_t *rktio_open(rktio_t *rktio, const char *src, int modes);
/* Can report `RKTIO_ERROR_DOES_NOT_EXIST` in place of system error,
and can report `RKTIO_ERROR_UNSUPPORTED_TEXT_MODE` on Windows:=. */
@ -121,7 +121,7 @@ RKTIO_EXTERN intptr_t rktio_read(rktio_t *rktio, rktio_fd_t *fd, char *buffer, i
#define RKTIO_READ_EOF (-1)
#define RKTIO_READ_ERROR (-2)
RKTIO_EXTERN intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *fd, char *buffer, intptr_t len);
RKTIO_EXTERN intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *fd, const char *buffer, intptr_t len);
/* Returns the number of bytes written, possibly 0, in non-blocking
mode. Alternatively, the result can be `RKTIO_WRITE_ERROR` for an
error. Although rktio_write() is intended to write only bytes that
@ -244,6 +244,14 @@ RKTIO_EXTERN void rktio_connect_stop(rktio_t *rktio, rktio_connect_t *conn);
RKTIO_EXTERN rktio_tri_t rktio_poll_connect_ready(rktio_t *rktio, rktio_connect_t *conn);
/* Returns one of `RKTIO_POLL_READY`, etc. */
RKTIO_EXTERN rktio_fd_t *rktio_connect_trying(rktio_t *rktio, rktio_connect_t *conn);
/* Returns a file descriptor that `conn` is currently trying, or
returns NULL without setting any error. The result file descriptor
should not be closed, and may be closed by a `rktio_connect_finish`
or `rktio_connect_stop` call (so if you register it in an long-term
poll set, unregister it before trying to finish or stop the
connection). */
RKTIO_EXTERN int rktio_socket_shutdown(rktio_t *rktio, rktio_fd_t *rfd, int mode);
/* Useful for TCP to report an EOF to the other end. Does not close the socket,
but may make it ineligible for forther use.
@ -262,7 +270,7 @@ RKTIO_EXTERN rktio_ok_t rktio_udp_bind(rktio_t *rktio, rktio_fd_t *rfd, rktio_ad
RKTIO_EXTERN rktio_ok_t rktio_udp_connect(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr);
RKTIO_EXTERN intptr_t rktio_udp_sendto(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr,
char *buffer, intptr_t len);
const char *buffer, intptr_t len);
/* Extends `rktio_write` to accept a destination `addr`, and binds `rfd` if it
is not bound aready. The `addr` can be NULL if the socket is connected. */
@ -293,6 +301,7 @@ RKTIO_EXTERN char **rktio_listener_address(rktio_t *rktio, rktio_listener_t *lnr
RKTIO_EXTERN char *rktio_udp_multicast_interface(rktio_t *rktio, rktio_fd_t *rfd);
RKTIO_EXTERN rktio_ok_t rktio_udp_set_multicast_interface(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr);
/* The `addr` argument can be NULL to auto-select the interface. */
RKTIO_EXTERN rktio_ok_t rktio_udp_change_multicast_group(rktio_t *rktio, rktio_fd_t *rfd,
rktio_addrinfo_t *group_addr,
@ -338,8 +347,8 @@ RKTIO_EXTERN rktio_envvars_t *rktio_envvars_copy(rktio_t *rktio, rktio_envvars_t
RKTIO_EXTERN void rktio_envvars_free(rktio_t *rktio, rktio_envvars_t *envvars);
/* Deallocates an environment-variables record: */
RKTIO_EXTERN char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, char *name);
RKTIO_EXTERN void rktio_envvars_set(rktio_t *rktio, rktio_envvars_t *envvars, char *name, char *value);
RKTIO_EXTERN char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, const char *name);
RKTIO_EXTERN void rktio_envvars_set(rktio_t *rktio, rktio_envvars_t *envvars, const char *name, const char *value);
/* Access/update environment-variables record by name. */
RKTIO_EXTERN intptr_t rktio_envvars_count(rktio_t *rktio, rktio_envvars_t *envvars);
@ -413,7 +422,7 @@ RKTIO_EXTERN int rktio_fs_change_properties(rktio_t *rktio);
typedef struct rktio_fs_change_t rktio_fs_change_t;
RKTIO_EXTERN rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, char *path);
RKTIO_EXTERN rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, const char *path);
RKTIO_EXTERN void rktio_fs_change_forget(rktio_t *rktio, rktio_fs_change_t *fc);
@ -470,7 +479,7 @@ RKTIO_EXTERN void rktio_poll_set_add_eventmask(rktio_t *rktio, rktio_poll_set_t
typedef struct rktio_ltps_t rktio_ltps_t;
typedef struct rktio_ltps_handle_t rktio_ltps_handle_t;
RKTIO_EXTERN rktio_ltps_t *rktio_open_ltps(rktio_t *rktio);
RKTIO_EXTERN rktio_ltps_t *rktio_ltps_open(rktio_t *rktio);
RKTIO_EXTERN int rktio_ltps_close(rktio_t *rktio, rktio_ltps_t *lt);
/* Closing will signal all remianing handles and free all signaled
@ -518,33 +527,33 @@ RKTIO_EXTERN void rktio_sleep(rktio_t *rktio, float nsecs, rktio_poll_set_t *fds
/*************************************************/
/* Files, directories, and links */
RKTIO_EXTERN int rktio_file_exists(rktio_t *rktio, char *filename);
RKTIO_EXTERN int rktio_directory_exists(rktio_t *rktio, char *dirname);
RKTIO_EXTERN int rktio_link_exists(rktio_t *rktio, char *filename);
RKTIO_EXTERN int rktio_is_regular_file(rktio_t *rktio, char *filename);
RKTIO_EXTERN int rktio_file_exists(rktio_t *rktio, const char *filename);
RKTIO_EXTERN int rktio_directory_exists(rktio_t *rktio, const char *dirname);
RKTIO_EXTERN int rktio_link_exists(rktio_t *rktio, const char *filename);
RKTIO_EXTERN int rktio_is_regular_file(rktio_t *rktio, const char *filename);
RKTIO_EXTERN rktio_ok_t rktio_delete_file(rktio_t *rktio, char *fn, int enable_write_on_fail);
RKTIO_EXTERN rktio_ok_t rktio_delete_file(rktio_t *rktio, const char *fn, int enable_write_on_fail);
RKTIO_EXTERN rktio_ok_t rktio_rename_file(rktio_t *rktio, char *dest, char *src, int exists_ok);
RKTIO_EXTERN rktio_ok_t rktio_rename_file(rktio_t *rktio, const char *dest, const char *src, int exists_ok);
/* Can report `RKTIO_ERROR_EXISTS`. */
RKTIO_EXTERN char *rktio_get_current_directory(rktio_t *rktio);
RKTIO_EXTERN rktio_ok_t rktio_set_current_directory(rktio_t *rktio, const char *path);
RKTIO_EXTERN rktio_ok_t rktio_make_directory(rktio_t *rktio, char *filename);
RKTIO_EXTERN rktio_ok_t rktio_make_directory(rktio_t *rktio, const char *filename);
/* Can report `RKTIO_ERROR_EXISTS`. */
RKTIO_EXTERN rktio_ok_t rktio_delete_directory(rktio_t *rktio, char *filename, char *current_directory,
RKTIO_EXTERN rktio_ok_t rktio_delete_directory(rktio_t *rktio, const char *filename, const char *current_directory,
int enable_write_on_fail);
/* The `current_directory` argument is used on Windows to avoid being
in `filename` (instead) as a directory while trying to delete it.
The `enable_write_on_fail` argument also applied to Windows. */
RKTIO_EXTERN char *rktio_readlink(rktio_t *rktio, char *fullfilename);
RKTIO_EXTERN char *rktio_readlink(rktio_t *rktio, const char *fullfilename);
/* Argument should not have a trailing separator. Can report
`RKTIO_ERROR_NOT_A_LINK`. */
RKTIO_EXTERN rktio_ok_t rktio_make_link(rktio_t *rktio, char *src, char *dest,
RKTIO_EXTERN rktio_ok_t rktio_make_link(rktio_t *rktio, const char *src, const char *dest,
int dest_is_directory);
/* The `dest_is_directory` argument is used only
on Windows. Can report `RKTIO_ERROR_EXISTS`. */
@ -554,10 +563,10 @@ RKTIO_EXTERN rktio_ok_t rktio_make_link(rktio_t *rktio, char *src, char *dest,
typedef intptr_t rktio_timestamp_t;
RKTIO_EXTERN rktio_filesize_t *rktio_file_size(rktio_t *rktio, char *filename);
RKTIO_EXTERN rktio_filesize_t *rktio_file_size(rktio_t *rktio, const char *filename);
RKTIO_EXTERN rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, char *file);
RKTIO_EXTERN rktio_ok_t rktio_set_file_modify_seconds(rktio_t *rktio, char *file, rktio_timestamp_t secs);
RKTIO_EXTERN rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, const char *file);
RKTIO_EXTERN rktio_ok_t rktio_set_file_modify_seconds(rktio_t *rktio, const char *file, rktio_timestamp_t secs);
typedef struct {
uintptr_t a, b, c;
@ -565,7 +574,7 @@ typedef struct {
} rktio_identity_t;
RKTIO_EXTERN rktio_identity_t *rktio_fd_identity(rktio_t *rktio, rktio_fd_t *fd);
RKTIO_EXTERN rktio_identity_t *rktio_path_identity(rktio_t *rktio, char *path, int follow_links);
RKTIO_EXTERN rktio_identity_t *rktio_path_identity(rktio_t *rktio, const char *path, int follow_links);
/*************************************************/
/* Permissions */
@ -577,11 +586,11 @@ RKTIO_EXTERN rktio_identity_t *rktio_path_identity(rktio_t *rktio, char *path, i
#define RKTIO_PERMISSION_ERROR (-1)
RKTIO_EXTERN int rktio_get_file_or_directory_permissions(rktio_t *rktio, char *filename, int all_bits);
RKTIO_EXTERN int rktio_get_file_or_directory_permissions(rktio_t *rktio, const char *filename, int all_bits);
/* Result is `RKTIO_PERMISSION_ERROR` for error, otherwise a combination of
bits. If not `all_bits`, then use constants above. */
RKTIO_EXTERN rktio_ok_t rktio_set_file_or_directory_permissions(rktio_t *rktio, char *filename, int new_bits);
RKTIO_EXTERN rktio_ok_t rktio_set_file_or_directory_permissions(rktio_t *rktio, const char *filename, int new_bits);
/* The `new_bits` format corresponds to `all_bits` for getting permissions.
Can report `RKTIO_ERROR_BAD_PERMISSION` for bits that make no sense. */
@ -590,8 +599,8 @@ RKTIO_EXTERN rktio_ok_t rktio_set_file_or_directory_permissions(rktio_t *rktio,
typedef struct rktio_directory_list_t rktio_directory_list_t;
RKTIO_EXTERN rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, char *filename);
/* On Windows, the given `filename` must be normalized and not have
RKTIO_EXTERN rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, const char *dirname);
/* On Windows, the given `dirname` must be normalized and not have
`.` or `..`: */
RKTIO_EXTERN char *rktio_directory_list_step(rktio_t *rktio, rktio_directory_list_t *dl);
@ -612,7 +621,7 @@ RKTIO_EXTERN char **rktio_filesystem_root_list(rktio_t *rktio);
typedef struct rktio_file_copy_t rktio_file_copy_t;
RKTIO_EXTERN rktio_file_copy_t *rktio_copy_file_start(rktio_t *rktio, char *dest, char *src,
RKTIO_EXTERN rktio_file_copy_t *rktio_copy_file_start(rktio_t *rktio, const char *dest, const char *src,
rktio_bool_t exists_ok);
/* Can report `RKTIO_ERROR_EXISTS`. */
@ -638,7 +647,7 @@ enum {
RKTIO_PATH_INIT_FILE
};
RKTIO_EXTERN char *rktio_expand_user_tilde(rktio_t *rktio, char *filename);
RKTIO_EXTERN char *rktio_expand_user_tilde(rktio_t *rktio, const char *filename);
/* Path must start with tilde, otherwise `RKTIO_ERROR_NO_TILDE`.
Other possible errors are `RKTIO_ERROR_ILL_FORMED_USER` and
`RKTIO_ERROR_UNKNOWN_USER`. */
@ -653,6 +662,7 @@ RKTIO_EXTERN void rktio_signal_received_at(rktio_signal_handle_t *h);
RKTIO_EXTERN void rktio_signal_received(rktio_t *rktio);
RKTIO_EXTERN void rktio_wait_until_signal_received(rktio_t *rktio);
RKTIO_EXTERN void rktio_flush_signals_received(rktio_t *rktio);
#ifdef RKTIO_SYSTEM_UNIX
RKTIO_EXTERN int rktio_signal_handle_to_fd();

4
racket/src/rktio/rktio_envvars.c
View File

@ -278,7 +278,7 @@ char *rktio_envvars_value_ref(rktio_t *rktio, rktio_envvars_t *envvars, intptr_t
return MSC_IZE(strdup)(envvars->vals[i]);
}
char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, char *name)
char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, const char *name)
{
intptr_t i;
@ -290,7 +290,7 @@ char *rktio_envvars_get(rktio_t *rktio, rktio_envvars_t *envvars, char *name)
return NULL;
}
void rktio_envvars_set(rktio_t *rktio, rktio_envvars_t *envvars, char *name, char *value)
void rktio_envvars_set(rktio_t *rktio, rktio_envvars_t *envvars, const char *name, const char *value)
{
intptr_t i, j;

2
racket/src/rktio/rktio_fd.c
View File

@ -938,7 +938,7 @@ static void WindowsFDICleanup(Win_FD_Input_Thread *th)
/* writing */
/*========================================================================*/
intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len)
intptr_t rktio_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr_t len)
{
#ifdef RKTIO_SYSTEM_UNIX
int flags, errsaved;

6
racket/src/rktio/rktio_file.c
View File

@ -16,7 +16,7 @@
/* Opening a file */
/*========================================================================*/
static rktio_fd_t *open_read(rktio_t *rktio, char *filename)
static rktio_fd_t *open_read(rktio_t *rktio, const char *filename)
{
#ifdef RKTIO_SYSTEM_UNIX
int fd;
@ -95,7 +95,7 @@ static rktio_fd_t *open_read(rktio_t *rktio, char *filename)
#endif
}
static rktio_fd_t *open_write(rktio_t *rktio, char *filename, int modes)
static rktio_fd_t *open_write(rktio_t *rktio, const char *filename, int modes)
{
#ifdef RKTIO_SYSTEM_UNIX
int fd;
@ -255,7 +255,7 @@ static rktio_fd_t *open_write(rktio_t *rktio, char *filename, int modes)
#endif
}
rktio_fd_t *rktio_open(rktio_t *rktio, char *filename, int modes)
rktio_fd_t *rktio_open(rktio_t *rktio, const char *filename, int modes)
{
if (modes & RKTIO_OPEN_WRITE)
return open_write(rktio, filename, modes);

61
racket/src/rktio/rktio_fs.c
View File

@ -498,7 +498,7 @@ static int UNC_stat(rktio_t *rktio, const char *dirname, int *flags, int *isdir,
}
#endif
int rktio_file_exists(rktio_t *rktio, char *filename)
int rktio_file_exists(rktio_t *rktio, const char *filename)
/* Windows: check for special filenames before calling */
{
# ifdef NO_STAT_PROC
@ -530,7 +530,7 @@ int rktio_file_exists(rktio_t *rktio, char *filename)
# endif
}
int rktio_directory_exists(rktio_t *rktio, char *dirname)
int rktio_directory_exists(rktio_t *rktio, const char *dirname)
{
# ifdef NO_STAT_PROC
return 0;
@ -555,7 +555,7 @@ int rktio_directory_exists(rktio_t *rktio, char *dirname)
# endif
}
int rktio_is_regular_file(rktio_t *rktio, char *filename)
int rktio_is_regular_file(rktio_t *rktio, const char *filename)
/* Windows: check for special filenames before calling */
{
# ifdef NO_STAT_PROC
@ -574,7 +574,7 @@ int rktio_is_regular_file(rktio_t *rktio, char *filename)
# endif
}
int rktio_link_exists(rktio_t *rktio, char *filename)
int rktio_link_exists(rktio_t *rktio, const char *filename)
{
#ifdef RKTIO_SYSTEM_WINDOWS
{
@ -666,7 +666,7 @@ int rktio_set_current_directory(rktio_t *rktio, const char *path)
return !err;
}
static rktio_identity_t *get_identity(rktio_t *rktio, rktio_fd_t *fd, char *path, int follow_links)
static rktio_identity_t *get_identity(rktio_t *rktio, rktio_fd_t *fd, const char *path, int follow_links)
{
uintptr_t devi = 0, inoi = 0, inoi2 = 0;
uintptr_t devi_bits = 0, inoi_bits = 0, inoi2_bits = 0;
@ -761,7 +761,7 @@ rktio_identity_t *rktio_fd_identity(rktio_t *rktio, rktio_fd_t *fd)
return get_identity(rktio, fd, NULL, 0);
}
rktio_identity_t *rktio_path_identity(rktio_t *rktio, char *path, int follow_links)
rktio_identity_t *rktio_path_identity(rktio_t *rktio, const char *path, int follow_links)
{
return get_identity(rktio, NULL, path, follow_links);
}
@ -775,7 +775,7 @@ static int enable_write_permission(rktio_t *rktio, const char *fn)
}
#endif
int rktio_delete_file(rktio_t *rktio, char *fn, int enable_write_on_fail)
int rktio_delete_file(rktio_t *rktio, const char *fn, int enable_write_on_fail)
{
#ifdef RKTIO_SYSTEM_WINDOWS
int errid;
@ -806,7 +806,7 @@ int rktio_delete_file(rktio_t *rktio, char *fn, int enable_write_on_fail)
#endif
}
int rktio_rename_file(rktio_t *rktio, char *dest, char *src, int exists_ok)
int rktio_rename_file(rktio_t *rktio, const char *dest, const char *src, int exists_ok)
{
#ifdef RKTIO_SYSTEM_WINDOWS
int errid;
@ -856,7 +856,7 @@ int rktio_rename_file(rktio_t *rktio, char *dest, char *src, int exists_ok)
#endif
}
char *rktio_readlink(rktio_t *rktio, char *fullfilename)
char *rktio_readlink(rktio_t *rktio, const char *fullfilename)
/* fullfilename must not have a trailing separator */
{
#ifdef RKTIO_SYSTEM_WINDOWS
@ -895,22 +895,21 @@ char *rktio_readlink(rktio_t *rktio, char *fullfilename)
#endif
}
int rktio_make_directory(rktio_t *rktio, char *filename)
int rktio_make_directory(rktio_t *rktio, const char *filename)
{
#ifdef NO_MKDIR
set_racket_error(RKTIO_ERROR_UNSUPPORTED);
return 0;
#else
int len, copied = 0;
int len;
char *copied = NULL;
/* Make sure path doesn't have trailing separator: */
len = strlen(filename);
while (len && IS_A_SEP(filename[len - 1])) {
if (!copied) {
filename = MSC_IZE(strdup)(filename);
copied = 1;
}
filename[--len] = 0;
copied = MSC_IZE(strdup)(filename);
copied[--len] = 0;
filename = copied;
}
while (1) {
@ -919,7 +918,7 @@ int rktio_make_directory(rktio_t *rktio, char *filename)
, 0777
# endif
)) {
if (copied) free(filename);
if (copied) free(copied);
return 1;
} else if (errno != EINTR)
break;
@ -930,12 +929,12 @@ int rktio_make_directory(rktio_t *rktio, char *filename)
else
get_posix_error();
if (copied) free(filename);
if (copied) free(copied);
return 0;
}
int rktio_delete_directory(rktio_t *rktio, char *filename, char *current_directory, int enable_write_on_fail)
int rktio_delete_directory(rktio_t *rktio, const char *filename, const char *current_directory, int enable_write_on_fail)
{
#ifdef RKTIO_SYSTEM_WINDOWS
int tried_cwd = 0, tried_perm = 0;
@ -964,7 +963,7 @@ int rktio_delete_directory(rktio_t *rktio, char *filename, char *current_directo
#endif
}
int rktio_make_link(rktio_t *rktio, char *src, char *dest, int dest_is_directory)
int rktio_make_link(rktio_t *rktio, const char *src, const char *dest, int dest_is_directory)
/* `src` is the file that is written, and `dest` is written to that
file */
{
@ -1002,7 +1001,7 @@ int rktio_make_link(rktio_t *rktio, char *src, char *dest, int dest_is_directory
#endif
}
rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, char *file)
rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, const char *file)
{
#ifdef RKTIO_SYSTEM_WINDOWS
rktio_timestamp_t *secs;
@ -1028,7 +1027,7 @@ rktio_timestamp_t *rktio_get_file_modify_seconds(rktio_t *rktio, char *file)
#endif
}
int rktio_set_file_modify_seconds(rktio_t *rktio, char *file, rktio_timestamp_t secs)
int rktio_set_file_modify_seconds(rktio_t *rktio, const char *file, rktio_timestamp_t secs)
{
while (1) {
struct MSC_IZE(utimbuf) ut;
@ -1091,7 +1090,7 @@ static int user_in_group(rktio_t *rktio, uid_t uid, gid_t gid)
}
#endif
int rktio_get_file_or_directory_permissions(rktio_t *rktio, char *filename, int all_bits)
int rktio_get_file_or_directory_permissions(rktio_t *rktio, const char *filename, int all_bits)
/* -1 result indicates an error */
{
# ifdef NO_STAT_PROC
@ -1226,7 +1225,7 @@ int rktio_get_file_or_directory_permissions(rktio_t *rktio, char *filename, int
# endif
}
int rktio_set_file_or_directory_permissions(rktio_t *rktio, char *filename, int new_bits)
int rktio_set_file_or_directory_permissions(rktio_t *rktio, const char *filename, int new_bits)
{
# ifdef NO_STAT_PROC
set_racket_error(RKTIO_ERROR_UNSUPPORTED);
@ -1268,7 +1267,7 @@ int rktio_set_file_or_directory_permissions(rktio_t *rktio, char *filename, int
# endif
}
rktio_filesize_t *rktio_file_size(rktio_t *rktio, char *filename)
rktio_filesize_t *rktio_file_size(rktio_t *rktio, const char *filename)
{
rktio_filesize_t *sz = NULL;
#ifdef RKTIO_SYSTEM_WINDOWS
@ -1319,7 +1318,7 @@ struct rktio_directory_list_t {
FF_TYPE info;
};
rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, char *filename)
rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, const char *filename)
/* path must be normalized */
{
char *pattern;
@ -1426,7 +1425,7 @@ struct rktio_directory_list_t {
DIR *dir;
};
rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, char *filename)
rktio_directory_list_t *rktio_directory_list_start(rktio_t *rktio, const char *filename)
{
rktio_directory_list_t *dl;
DIR *dir;
@ -1509,7 +1508,7 @@ struct rktio_file_copy_t {
rktio_fd_t *src_fd, *dest_fd;
};
rktio_file_copy_t *rktio_copy_file_start(rktio_t *rktio, char *dest, char *src, int exists_ok)
rktio_file_copy_t *rktio_copy_file_start(rktio_t *rktio, const char *dest, const char *src, int exists_ok)
{
#ifdef RKTIO_SYSTEM_UNIX
{
@ -1694,7 +1693,7 @@ char **rktio_filesystem_root_list(rktio_t *rktio)
/* expand user tilde & system paths */
/*========================================================================*/
char *rktio_expand_user_tilde(rktio_t *rktio, char *filename) {
char *rktio_expand_user_tilde(rktio_t *rktio, const char *filename) {
#ifdef RKTIO_SYSTEM_WINDOWS
set_racket_error(RKTIO_ERROR_UNSUPPORTED);
return NULL;
@ -1760,9 +1759,7 @@ char *rktio_expand_user_tilde(rktio_t *rktio, char *filename) {
free(home);
filename = naya;
return filename;
return naya;
#endif
}

4
racket/src/rktio/rktio_fs_change.c
View File

@ -65,7 +65,7 @@ int rktio_fs_change_properties(rktio_t *rktio)
return flags;
}
rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, char *path)
rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, const char *path)
{
int ok = 0;
#ifndef NO_FILESYSTEM_CHANGE_EVTS
@ -93,7 +93,7 @@ rktio_fs_change_t *rktio_fs_change(rktio_t *rktio, char *path)
else {
rktio_fd_t *rfd;
rfd = rktio_system_fd(rktio, fd, 0);
lt = rktio_open_ltps(rktio);
lt = rktio_ltps_open(rktio);
if (lt)
lth = rktio_ltps_add(rktio, lt, rfd, RKTIO_LTPS_CREATE_VNODE);
if (!lt || !lth) {

2
racket/src/rktio/rktio_ltps.c
View File

@ -94,7 +94,7 @@ void *rktio_ltps_handle_get_data(rktio_t *rktio, rktio_ltps_handle_t *s)
/*========================================================================*/
rktio_ltps_t *rktio_open_ltps(rktio_t *rktio)
rktio_ltps_t *rktio_ltps_open(rktio_t *rktio)
{
rktio_ltps_t *lt;

23
racket/src/rktio/rktio_network.c
View File

@ -915,6 +915,18 @@ void rktio_socket_forget_owned(rktio_t *rktio, rktio_fd_t *rfd)
#endif
}
int rktio_socket_shutdown(rktio_t *rktio, rktio_fd_t *rfd, int mode)
{
rktio_socket_t s = rktio_fd_system_fd(rktio, rfd);
if (!shutdown(s, ((mode == RKTIO_SHUTDOWN_READ) ? SHUT_RD : SHUT_RDWR))) {
get_socket_error();
return 0;
}
return 1;
}
int rktio_socket_poll_write_ready(rktio_t *rktio, rktio_fd_t *rfd)
{
#ifdef RKTIO_SYSTEM_UNIX
@ -1031,7 +1043,7 @@ intptr_t rktio_socket_read(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr
}
}
static intptr_t do_socket_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len,
static intptr_t do_socket_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr_t len,
/* for UDP sendto: */
rktio_addrinfo_t *addr)
{
@ -1087,7 +1099,7 @@ static intptr_t do_socket_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, i
}
}
intptr_t rktio_socket_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len)
intptr_t rktio_socket_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr_t len)
{
return do_socket_write(rktio, rfd, buffer, len, NULL);
}
@ -1244,6 +1256,11 @@ void rktio_connect_stop(rktio_t *rktio, rktio_connect_t *conn)
conn_free(conn);
}
rktio_fd_t *rktio_connect_trying(rktio_t *rktio, rktio_connect_t *conn)
{
return conn->trying_fd;
}
/*========================================================================*/
/* TCP listener and accept */
/*========================================================================*/
@ -1782,7 +1799,7 @@ int rktio_udp_connect(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr)
return 0;
}
intptr_t rktio_udp_sendto(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr, char *buffer, intptr_t len)
intptr_t rktio_udp_sendto(rktio_t *rktio, rktio_fd_t *rfd, rktio_addrinfo_t *addr, const char *buffer, intptr_t len)
{
return do_socket_write(rktio, rfd, buffer, len, addr);
}

8
racket/src/rktio/rktio_poll_set.c
View File

@ -967,7 +967,7 @@ void rktio_signal_received_at(rktio_signal_handle_t *h)
#endif
}
static void clear_signal(rktio_t *rktio)
void rktio_flush_signals_received(rktio_t *rktio)
{
#ifdef RKTIO_SYSTEM_UNIX
/* Clear external event flag */
@ -1008,8 +1008,8 @@ void rktio_wait_until_signal_received(rktio_t *rktio)
#ifdef RKTIO_SYSTEM_WINDOWS
WaitForSingleObject(rktio->break_semaphore, INFINITE);
#endif
clear_signal(rktio);
rktio_flush_signals_received(rktio);
}
/****************** Windows cleanup *****************/
@ -1276,5 +1276,5 @@ void rktio_sleep(rktio_t *rktio, float nsecs, rktio_poll_set_t *fds, rktio_ltps_
#endif
}
clear_signal(rktio);
rktio_flush_signals_received(rktio);
}

2
racket/src/rktio/rktio_private.h
View File

@ -185,7 +185,7 @@ rktio_fd_t *rktio_socket_dup(rktio_t *rktio, rktio_fd_t *rfd);
int rktio_socket_poll_write_ready(rktio_t *rktio, rktio_fd_t *rfd);
int rktio_socket_poll_read_ready(rktio_t *rktio, rktio_fd_t *rfd);
intptr_t rktio_socket_write(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len);
intptr_t rktio_socket_write(rktio_t *rktio, rktio_fd_t *rfd, const char *buffer, intptr_t len);
intptr_t rktio_socket_read(rktio_t *rktio, rktio_fd_t *rfd, char *buffer, intptr_t len);
void rktio_free_ghbn(rktio_t *rktio);