X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/27a3458f34afd8c533f33d980228acd2f7eef856..b707973a228a7f7d7399b6113b7f78d6248a432d:/mac/otnet.c diff --git a/mac/otnet.c b/mac/otnet.c index b4314785..d5271e70 100644 --- a/mac/otnet.c +++ b/mac/otnet.c @@ -2,9 +2,16 @@ * Macintosh OpenTransport networking abstraction */ +#if TARGET_API_MAC_CARBON +#define OTCARBONAPPLICATION 1 +#endif + +#include /* Needed by OpenTransportInternet.h */ #include #include +#include + #define DEFINE_PLUG_METHOD_MACROS #include "putty.h" #include "network.h" @@ -13,7 +20,7 @@ struct Socket_tag { struct socket_function_table *fn; /* other stuff... */ - char *error; + OSStatus error; EndpointRef ep; Plug plug; void *private_ptr; @@ -30,6 +37,8 @@ struct Socket_tag { int oobinline; int pending_error; /* in case send() returns error */ int listener; + int nodelay, keepalive; + int privport, port; struct Socket_tag *next; struct Socket_tag **prev; }; @@ -37,19 +46,27 @@ struct Socket_tag { typedef struct Socket_tag *Actual_Socket; struct SockAddr_tag { - char *error; - DNSAddress address; + int resolved; + OSStatus error; + InetHostInfo hostinfo; + char hostname[512]; }; /* Globals */ static struct { Actual_Socket socklist; + InetSvcRef inetsvc; } ot; OSErr ot_init(void) { - return InitOpenTransport(); + OSStatus err; + + err = InitOpenTransport(); + if (err != kOTNoError) return err; + ot.inetsvc = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err); + return err; } void ot_cleanup(void) @@ -64,36 +81,47 @@ void ot_cleanup(void) CloseOpenTransport(); } -static char *error_string(int error) +SockAddr ot_namelookup(char const *host, char **canonicalname) { - return "An error..."; -} - -SockAddr ot_namelookup(char *host, char **canonicalname) -{ - SockAddr ret = smalloc(sizeof(struct SockAddr_tag)); - - OTInitDNSAddress(&(ret->address), host); - - /* for now we'll pretend canonicalname is always just host */ - - *canonicalname = smalloc(1+strlen(host)); - strcpy(*canonicalname, host); + SockAddr ret = snew(struct SockAddr_tag); + char *realhost; + + /* Casting away const -- hope OTInetStringToAddress is sensible */ + ret->error = OTInetStringToAddress(ot.inetsvc, (char *)host, + &ret->hostinfo); + ret->resolved = TRUE; + + if (ret->error == kOTNoError) + realhost = ret->hostinfo.name; + else + realhost = ""; + *canonicalname = snewn(1+strlen(realhost), char); + strcpy(*canonicalname, realhost); return ret; } -SockAddr ot_nonamelookup(char *host) +SockAddr ot_nonamelookup(char const *host) { - SockAddr ret = smalloc(sizeof(struct SockAddr_tag)); + SockAddr ret = snew(struct SockAddr_tag); - OTInitDNSAddress(&(ret->address), host); - + ret->resolved = FALSE; + ret->error = kOTNoError; + ret->hostname[0] = '\0'; + strncat(ret->hostname, host, lenof(ret->hostname) - 1); return ret; } void ot_getaddr(SockAddr addr, char *buf, int buflen) { - strncpy(buf, (addr->address).fName, buflen); + char mybuf[16]; + + buf[0] = '\0'; + if (addr->resolved) { + /* XXX only return first address */ + OTInetHostToString(addr->hostinfo.addrs[0], mybuf); + strncat(buf, mybuf, buflen - 1); + } else + strncat(buf, addr->hostname, buflen - 1); } /* I think "local" here really means "loopback" */ @@ -106,19 +134,28 @@ int ot_hostname_is_local(char *name) int ot_address_is_local(SockAddr addr) { + int i; - /* FIXME */ + if (addr->resolved) + for (i = 0; i < kMaxHostAddrs; i++) + if (addr->hostinfo.addrs[i] & 0xff000000 == 0x7f000000) + return TRUE; return FALSE; } int ot_addrtype(SockAddr addr) { - return ADDRTYPE_IPV4; + + if (addr->resolved) + return ADDRTYPE_IPV4; + return ADDRTYPE_NAME; } void ot_addrcopy(SockAddr addr, char *buf) { - + + /* XXX only return first address */ + memcpy(buf, &addr->hostinfo.addrs[0], 4); } void ot_addr_free(SockAddr addr) @@ -150,10 +187,13 @@ static int ot_tcp_write_oob(Socket s, char const *data, int len); static void ot_tcp_set_private_ptr(Socket s, void *ptr); static void *ot_tcp_get_private_ptr(Socket s); static void ot_tcp_set_frozen(Socket s, int is_frozen); -static char *ot_tcp_socket_error(Socket s); +static const char *ot_tcp_socket_error(Socket s); static void ot_recv(Actual_Socket s); +static void ot_listenaccept(Actual_Socket s); +static void ot_setoption(EndpointRef, OTXTILevel, OTXTIName, UInt32); void ot_poll(void); + Socket ot_register(void *sock, Plug plug) { static struct socket_function_table fn_table = { @@ -170,9 +210,9 @@ Socket ot_register(void *sock, Plug plug) Actual_Socket ret; - ret = smalloc(sizeof(struct Socket_tag)); + ret = snew(struct Socket_tag); ret->fn = &fn_table; - ret->error = NULL; + ret->error = kOTNoError; ret->plug = plug; bufchain_init(&ret->output_data); ret->writable = 1; /* to start with */ @@ -199,7 +239,7 @@ Socket ot_register(void *sock, Plug plug) } Socket ot_new(SockAddr addr, int port, int privport, int oobinline, - int nodelay, Plug plug) + int nodelay, int keepalive, Plug plug) { static struct socket_function_table fn_table = { ot_tcp_plug, @@ -216,11 +256,12 @@ Socket ot_new(SockAddr addr, int port, int privport, int oobinline, Actual_Socket ret; EndpointRef ep; OSStatus err; + InetAddress dest; TCall connectCall; - ret = smalloc(sizeof(struct Socket_tag)); + ret = snew(struct Socket_tag); ret->fn = &fn_table; - ret->error = NULL; + ret->error = kOTNoError; ret->plug = plug; bufchain_init(&ret->output_data); ret->connected = 0; /* to start with */ @@ -231,6 +272,8 @@ Socket ot_new(SockAddr addr, int port, int privport, int oobinline, ret->localhost_only = 0; /* unused, but best init anyway */ ret->pending_error = 0; ret->oobinline = oobinline; + ret->nodelay = nodelay; + ret->keepalive = keepalive; ret->oobpending = FALSE; ret->listener = 0; @@ -241,11 +284,19 @@ Socket ot_new(SockAddr addr, int port, int privport, int oobinline, ret->ep = ep; if (err) { - ret->error = error_string(err); + ret->error = err; return (Socket) ret; } - /* TODO: oobinline, nodelay */ + if (ret->oobinline) + ot_setoption(ep, INET_TCP, TCP_OOBINLINE, T_YES); + + if (ret->nodelay) + ot_setoption(ep, INET_TCP, TCP_NODELAY, T_YES); + + if (ret->keepalive) { + ot_setoption(ep, INET_TCP, TCP_KEEPALIVE, T_YES); + } /* * Bind to local address. @@ -256,7 +307,7 @@ Socket ot_new(SockAddr addr, int port, int privport, int oobinline, err = OTBind(ep, NULL, NULL); /* OpenTransport always picks our address */ if (err) { - ret->error = error_string(err); + ret->error = err; return (Socket) ret; } @@ -264,16 +315,17 @@ Socket ot_new(SockAddr addr, int port, int privport, int oobinline, * Connect to remote address. */ - /* FIXME: bolt the port onto the end */ + /* XXX Try non-primary addresses */ + OTInitInetAddress(&dest, port, addr->hostinfo.addrs[0]); - OTMemzero(&connectCall, sizeof(TCall)); - connectCall.addr.buf = (UInt8 *) &(addr->address); - connectCall.addr.len = sizeof(DNSAddress); + memset(&connectCall, 0, sizeof(TCall)); + connectCall.addr.buf = (UInt8 *) &dest; + connectCall.addr.len = sizeof(dest); err = OTConnect(ep, &connectCall, nil); if (err) { - ret->error = error_string(err); + ret->error = err; return (Socket) ret; } else { ret->connected = 1; @@ -283,16 +335,88 @@ Socket ot_new(SockAddr addr, int port, int privport, int oobinline, /* Add this to the list of all sockets */ ret->next = ot.socklist; ret->prev = &ot.socklist; + if (ret->next != NULL) + ret->next->prev = &ret->next; ot.socklist = ret; + /* XXX: don't know whether we can sk_addr_free(addr); */ + return (Socket) ret; } -Socket ot_newlistener(char *foobar, int port, Plug plug, int local_host_only) +Socket ot_newlistener(char *srcaddr, int port, Plug plug, int local_host_only, + int address_family) { - Actual_Socket s; + static struct socket_function_table fn_table = { + ot_tcp_plug, + ot_tcp_close, + ot_tcp_write, + ot_tcp_write_oob, + ot_tcp_flush, + ot_tcp_set_private_ptr, + ot_tcp_get_private_ptr, + ot_tcp_set_frozen, + ot_tcp_socket_error + }; + + Actual_Socket ret; + EndpointRef ep; + OSStatus err; + InetAddress addr; + TBind tbind; + + ret = snew(struct Socket_tag); + ret->fn = &fn_table; + ret->error = kOTNoError; + ret->plug = plug; + bufchain_init(&ret->output_data); + ret->writable = 0; /* to start with */ + ret->sending_oob = 0; + ret->frozen = 0; + ret->frozen_readable = 0; + ret->localhost_only = local_host_only; + ret->pending_error = 0; + ret->oobinline = 0; + ret->oobpending = FALSE; + ret->listener = 1; + + /* Open Endpoint, configure it for TCP over anything, and load the + * tilisten module to serialize multiple simultaneous + * connections. */ + + ep = OTOpenEndpoint(OTCreateConfiguration("tilisten,tcp"), 0, NULL, &err); + + ret->ep = ep; + + if (err) { + ret->error = err; + return (Socket) ret; + } + + ot_setoption(ep, INET_IP, IP_REUSEADDR, T_YES); + + OTInitInetAddress(&addr, port, kOTAnyInetAddress); + /* XXX: pay attention to local_host_only */ + + tbind.addr.buf = (UInt8 *) &addr; + tbind.addr.len = sizeof(addr); + tbind.qlen = 10; + + err = OTBind(ep, &tbind, NULL); /* XXX: check qlen we got */ + + if (err) { + ret->error = err; + return (Socket) ret; + } + + /* Add this to the list of all sockets */ + ret->next = ot.socklist; + ret->prev = &ot.socklist; + if (ret->next != NULL) + ret->next->prev = &ret->next; + ot.socklist = ret; - return (Socket) s; + return (Socket) ret; } static void ot_tcp_close(Socket sock) @@ -374,12 +498,22 @@ static void *ot_tcp_get_private_ptr(Socket sock) */ char *ot_addr_error(SockAddr addr) { - return addr->error; + static char buf[128]; + + if (addr->error == kOTNoError) + return NULL; + sprintf(buf, "error %d", addr->error); + return buf; } -static char *ot_tcp_socket_error(Socket sock) +static const char *ot_tcp_socket_error(Socket sock) { Actual_Socket s = (Actual_Socket) sock; - return s->error; + static char buf[128]; + + if (s->error == kOTNoError) + return NULL; + sprintf(buf, "error %d", s->error); + return buf; } static void ot_tcp_set_frozen(Socket sock, int is_frozen) @@ -410,6 +544,15 @@ void ot_poll(void) case T_EXDATA: /* Expedited Data (urgent?) */ ot_recv(s); break; + case T_LISTEN: /* Connection attempt */ + ot_listenaccept(s); + break; + case T_ORDREL: /* Orderly disconnect */ + plug_closing(s->plug, NULL, 0, 0); + break; + case T_DISCONNECT: /* Abortive disconnect*/ + plug_closing(s->plug, NULL, 0, 0); + break; } } } @@ -417,16 +560,76 @@ void ot_poll(void) void ot_recv(Actual_Socket s) { OTResult o; - char buf[20480]; + char buf[2048]; OTFlags flags; if (s->frozen) return; - while ((o = OTRcv(s->ep, buf, sizeof(buf), &flags)) != kOTNoDataErr) { - plug_receive(s->plug, 0, buf, sizeof(buf)); + o = OTRcv(s->ep, buf, sizeof(buf), &flags); + if (o > 0) + plug_receive(s->plug, 0, buf, o); + if (o < 0 && o != kOTNoDataErr) + plug_closing(s->plug, NULL, 0, 0); /* XXX Error msg */ +} + +void ot_listenaccept(Actual_Socket s) +{ + OTResult o; + OSStatus err; + InetAddress remoteaddr; + TCall tcall; + EndpointRef ep; + + tcall.addr.maxlen = sizeof(InetAddress); + tcall.addr.buf = (unsigned char *)&remoteaddr; + tcall.opt.maxlen = 0; + tcall.opt.buf = NULL; + tcall.udata.maxlen = 0; + tcall.udata.buf = NULL; + + o = OTListen(s->ep, &tcall); + + if (o != kOTNoError) + return; + + /* We've found an incoming connection, accept it */ + + ep = OTOpenEndpoint(OTCreateConfiguration("tcp"), 0, NULL, &err); + o = OTAccept(s->ep, ep, &tcall); + if (plug_accepting(s->plug, ep)) { + OTUnbind(ep); + OTCloseProvider(ep); } } +static void ot_setoption(EndpointRef ep, + OTXTILevel level, + OTXTIName name, + UInt32 value) +{ + TOption option; + TOptMgmt request; + TOptMgmt result; + + if (name == TCP_KEEPALIVE) { + option.len = sizeof(struct t_kpalive); + option.value[1] = T_UNSPEC; + } else + option.len = kOTFourByteOptionSize; + option.level = level; + option.name = name; + option.status = 0; + option.value[0] = value; + + request.opt.buf = (unsigned char *) &option; + request.opt.len = sizeof(option); + request.flags = T_NEGOTIATE; + + result.opt.buf = (unsigned char *) &option; + result.opt.maxlen = sizeof(option); + + OTOptionManagement(ep, &request, &result); +} /* * Local Variables: