git.distorted.org.uk Git - u/mdw/putty/blob - mac/otnet.c

   1 /*
   2  * Macintosh OpenTransport networking abstraction
   3  */
   4
   5 #if TARGET_API_MAC_CARBON
   6 #define OTCARBONAPPLICATION 1
   7 #endif
   8
   9 #include <Files.h> /* Needed by OpenTransportInternet.h */
  10 #include <OpenTransport.h>
  11 #include <OpenTptInternet.h>
  12
  13 #include <string.h>
  14
  15 #define DEFINE_PLUG_METHOD_MACROS
  16 #include "putty.h"
  17 #include "network.h"
  18 #include "mac.h"
  19
  20 struct Socket_tag {
  21     struct socket_function_table *fn;
  22     /* other stuff... */
  23     OSStatus error;
  24     EndpointRef ep;
  25     Plug plug;
  26     void *private_ptr;
  27     bufchain output_data;
  28     int connected;
  29     int writable;
  30     int frozen; /* this causes readability notifications to be ignored */
  31     int frozen_readable; /* this means we missed at least one readability
  32                           * notification while we were frozen */
  33     int localhost_only;                /* for listening sockets */
  34     char oobdata[1];
  35     int sending_oob;
  36     int oobpending;        /* is there OOB data available to read?*/
  37     int oobinline;
  38     int pending_error;                 /* in case send() returns error */
  39     int listener;
  40     struct Socket_tag *next;
  41     struct Socket_tag **prev;
  42 };
  43
  44 typedef struct Socket_tag *Actual_Socket;
  45
  46 struct SockAddr_tag {
  47     int resolved;
  48     OSStatus error;
  49     InetHostInfo hostinfo;
  50     char hostname[512];
  51 };
  52
  53 /* Globals */
  54
  55 static struct {
  56     Actual_Socket socklist;
  57     InetSvcRef inetsvc;
  58 } ot;
  59
  60 OSErr ot_init(void)
  61 {
  62     OSStatus err;
  63
  64     err = InitOpenTransport();
  65     if (err != kOTNoError) return err;
  66     ot.inetsvc = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
  67     return err;
  68 }
  69
  70 void ot_cleanup(void)
  71 {
  72     Actual_Socket s;
  73
  74     for (s = ot.socklist; s !=NULL; s = s->next) {
  75         OTUnbind(s->ep);
  76         OTCloseProvider(s->ep);
  77     }
  78
  79     CloseOpenTransport();
  80 }
  81
  82 SockAddr ot_namelookup(char const *host, char **canonicalname)
  83 {
  84     SockAddr ret = snew(struct SockAddr_tag);
  85     char *realhost;
  86
  87     /* Casting away const -- hope OTInetStringToAddress is sensible */
  88     ret->error = OTInetStringToAddress(ot.inetsvc, (char *)host,
  89                                        &ret->hostinfo);
  90     ret->resolved = TRUE;
  91
  92     if (ret->error == kOTNoError)
  93         realhost = ret->hostinfo.name;
  94     else
  95         realhost = "";
  96     *canonicalname = snewn(1+strlen(realhost), char);
  97     strcpy(*canonicalname, realhost);
  98     return ret;
  99 }
 100
 101 SockAddr ot_nonamelookup(char const *host)
 102 {
 103     SockAddr ret = snew(struct SockAddr_tag);
 104
 105     ret->resolved = FALSE;
 106     ret->error = kOTNoError;
 107     ret->hostname[0] = '\0';
 108     strncat(ret->hostname, host, lenof(ret->hostname) - 1);
 109     return ret;
 110 }
 111
 112 void ot_getaddr(SockAddr addr, char *buf, int buflen)
 113 {
 114     char mybuf[16];
 115
 116     buf[0] = '\0';
 117     if (addr->resolved) {
 118         /* XXX only return first address */
 119         OTInetHostToString(addr->hostinfo.addrs[0], mybuf);
 120         strncat(buf, mybuf, buflen - 1);
 121     } else
 122         strncat(buf, addr->hostname, buflen - 1);
 123 }
 124
 125 /* I think "local" here really means "loopback" */
 126
 127 int ot_hostname_is_local(char *name)
 128 {
 129
 130     return !strcmp(name, "localhost");
 131 }
 132
 133 int ot_address_is_local(SockAddr addr)
 134 {
 135     int i;
 136
 137     if (addr->resolved)
 138         for (i = 0; i < kMaxHostAddrs; i++)
 139             if (addr->hostinfo.addrs[i] & 0xff000000 == 0x7f000000)
 140                 return TRUE;
 141     return FALSE;
 142 }
 143
 144 int ot_addrtype(SockAddr addr)
 145 {
 146
 147     if (addr->resolved)
 148         return ADDRTYPE_IPV4;
 149     return ADDRTYPE_NAME;
 150 }
 151
 152 void ot_addrcopy(SockAddr addr, char *buf)
 153 {
 154
 155     /* XXX only return first address */
 156     memcpy(buf, &addr->hostinfo.addrs[0], 4);
 157 }
 158
 159 void ot_addr_free(SockAddr addr)
 160 {
 161     sfree(addr);
 162 }
 163
 164
 165 static Plug ot_tcp_plug(Socket sock, Plug p)
 166 {
 167     Actual_Socket s = (Actual_Socket) sock;
 168     Plug ret = s->plug;
 169     if (p)
 170         s->plug = p;
 171     return ret;
 172 }
 173
 174 static void ot_tcp_flush(Socket s)
 175 {
 176     /*
 177      * We send data to the socket as soon as we can anyway,
 178      * so we don't need to do anything here.  :-)
 179      */
 180 }
 181
 182 static void ot_tcp_close(Socket s);
 183 static int ot_tcp_write(Socket s, char const *data, int len);
 184 static int ot_tcp_write_oob(Socket s, char const *data, int len);
 185 static void ot_tcp_set_private_ptr(Socket s, void *ptr);
 186 static void *ot_tcp_get_private_ptr(Socket s);
 187 static void ot_tcp_set_frozen(Socket s, int is_frozen);
 188 static const char *ot_tcp_socket_error(Socket s);
 189 static void ot_recv(Actual_Socket s);
 190 void ot_poll(void);
 191
 192 Socket ot_register(void *sock, Plug plug)
 193 {
 194     static struct socket_function_table fn_table = {
 195         ot_tcp_plug,
 196         ot_tcp_close,
 197         ot_tcp_write,
 198         ot_tcp_write_oob,
 199         ot_tcp_flush,
 200         ot_tcp_set_private_ptr,
 201         ot_tcp_get_private_ptr,
 202         ot_tcp_set_frozen,
 203         ot_tcp_socket_error
 204     };
 205
 206     Actual_Socket ret;
 207
 208     ret = snew(struct Socket_tag);
 209     ret->fn = &fn_table;
 210     ret->error = kOTNoError;
 211     ret->plug = plug;
 212     bufchain_init(&ret->output_data);
 213     ret->writable = 1;                 /* to start with */
 214     ret->sending_oob = 0;
 215     ret->frozen = 1;
 216     ret->frozen_readable = 0;
 217     ret->localhost_only = 0;           /* unused, but best init anyway */
 218     ret->pending_error = 0;
 219     ret->oobpending = FALSE;
 220     ret->listener = 0;
 221
 222     ret->ep = (EndpointRef)sock;
 223
 224     /* some sort of error checking */
 225
 226     ret->oobinline = 0;
 227
 228     /* Add this to the list of all sockets */
 229     ret->next = ot.socklist;
 230     ret->prev = &ot.socklist;
 231     ot.socklist = ret;
 232
 233     return (Socket) ret;
 234 }
 235
 236 Socket ot_new(SockAddr addr, int port, int privport, int oobinline,
 237               int nodelay, Plug plug)
 238 {
 239     static struct socket_function_table fn_table = {
 240         ot_tcp_plug,
 241         ot_tcp_close,
 242         ot_tcp_write,
 243         ot_tcp_write_oob,
 244         ot_tcp_flush,
 245         ot_tcp_set_private_ptr,
 246         ot_tcp_get_private_ptr,
 247         ot_tcp_set_frozen,
 248         ot_tcp_socket_error
 249     };
 250
 251     Actual_Socket ret;
 252     EndpointRef ep;
 253     OSStatus err;
 254     InetAddress dest;
 255     TCall connectCall;
 256
 257     ret = snew(struct Socket_tag);
 258     ret->fn = &fn_table;
 259     ret->error = kOTNoError;
 260     ret->plug = plug;
 261     bufchain_init(&ret->output_data);
 262     ret->connected = 0;                /* to start with */
 263     ret->writable = 0;                 /* to start with */
 264     ret->sending_oob = 0;
 265     ret->frozen = 0;
 266     ret->frozen_readable = 0;
 267     ret->localhost_only = 0;           /* unused, but best init anyway */
 268     ret->pending_error = 0;
 269     ret->oobinline = oobinline;
 270     ret->oobpending = FALSE;
 271     ret->listener = 0;
 272
 273     /* Open Endpoint, configure it for TCP over anything */
 274
 275     ep = OTOpenEndpoint(OTCreateConfiguration("tcp"), 0, NULL, &err);
 276
 277     ret->ep = ep;
 278
 279     if (err) {
 280         ret->error = err;
 281         return (Socket) ret;
 282     }
 283
 284     /* TODO: oobinline, nodelay */
 285
 286     /*
 287      * Bind to local address.
 288      */
 289
 290     /* FIXME: pay attention to privport */
 291
 292     err = OTBind(ep, NULL, NULL); /* OpenTransport always picks our address */
 293
 294     if (err) {
 295         ret->error = err;
 296         return (Socket) ret;
 297     }
 298
 299     /*
 300      * Connect to remote address.
 301      */
 302
 303     /* XXX Try non-primary addresses */
 304     OTInitInetAddress(&dest, port, addr->hostinfo.addrs[0]);
 305
 306     memset(&connectCall, 0, sizeof(TCall));
 307     connectCall.addr.buf = (UInt8 *) &dest;
 308     connectCall.addr.len = sizeof(dest);
 309
 310     err = OTConnect(ep, &connectCall, nil);
 311
 312     if (err) {
 313         ret->error = err;
 314         return (Socket) ret;
 315     } else {
 316         ret->connected = 1;
 317         ret->writable = 1;
 318     }
 319
 320     /* Add this to the list of all sockets */
 321     ret->next = ot.socklist;
 322     ret->prev = &ot.socklist;
 323     if (ret->next != NULL)
 324         ret->next->prev = &ret->next;
 325     ot.socklist = ret;
 326
 327     return (Socket) ret;
 328 }
 329
 330 Socket ot_newlistener(char *foobar, int port, Plug plug, int local_host_only)
 331 {
 332     Actual_Socket s;
 333
 334     return (Socket) s;
 335 }
 336
 337 static void ot_tcp_close(Socket sock)
 338 {
 339     Actual_Socket s = (Actual_Socket) sock;
 340
 341     OTCloseProvider(s->ep);
 342
 343     /* Unhitch from list of sockets */
 344     *s->prev = s->next;
 345     if (s->next != NULL)
 346         s->next->prev = s->prev;
 347
 348     sfree(s);
 349 }
 350
 351 static void try_send(Actual_Socket s)
 352 {
 353     while (bufchain_size(&s->output_data) > 0) {
 354         int nsent;
 355         void *data;
 356         int len;
 357
 358         /* Don't care about oob right now */
 359
 360         bufchain_prefix(&s->output_data, &data, &len);
 361
 362         nsent = OTSnd(s->ep, data, len, 0);
 363         noise_ultralight(nsent);
 364
 365         if (nsent <= 0) {
 366             /* something bad happened, hey ho */
 367         } else {
 368             /* still don't care about oob */
 369             bufchain_consume(&s->output_data, nsent);
 370         }
 371     }
 372 }
 373
 374 static int ot_tcp_write(Socket sock, char const *buf, int len)
 375 {
 376     Actual_Socket s = (Actual_Socket) sock;
 377
 378     bufchain_add(&s->output_data, buf, len);
 379
 380     if (s->writable)
 381         try_send(s);
 382     return bufchain_size(&s->output_data);
 383 }
 384
 385 static int ot_tcp_write_oob(Socket sock, char const *buf, int len)
 386 {
 387     /* Don't care about oob */
 388     return 0;
 389 }
 390
 391
 392 /*
 393  * Each socket abstraction contains a `void *' private field in
 394  * which the client can keep state.
 395  */
 396 static void ot_tcp_set_private_ptr(Socket sock, void *ptr)
 397 {
 398     Actual_Socket s = (Actual_Socket) sock;
 399     s->private_ptr = ptr;
 400 }
 401
 402 static void *ot_tcp_get_private_ptr(Socket sock)
 403 {
 404     Actual_Socket s = (Actual_Socket) sock;
 405     return s->private_ptr;
 406 }
 407
 408
 409 /*
 410  * Special error values are returned from ot_namelookup and ot_new
 411  * if there's a problem. These functions extract an error message,
 412  * or return NULL if there's no problem.
 413  */
 414 char *ot_addr_error(SockAddr addr)
 415 {
 416     static char buf[128];
 417
 418     if (addr->error == kOTNoError)
 419         return NULL;
 420     sprintf(buf, "error %d", addr->error);
 421     return buf;
 422 }
 423 static const char *ot_tcp_socket_error(Socket sock)
 424 {
 425     Actual_Socket s = (Actual_Socket) sock;
 426     static char buf[128];
 427
 428     if (s->error == kOTNoError)
 429         return NULL;
 430     sprintf(buf, "error %d", s->error);
 431     return buf;
 432 }
 433
 434 static void ot_tcp_set_frozen(Socket sock, int is_frozen)
 435 {
 436     Actual_Socket s = (Actual_Socket) sock;
 437
 438     if (s->frozen == is_frozen)
 439         return;
 440     s->frozen = is_frozen;
 441 }
 442
 443 /*
 444  * Poll all our sockets from an event loop
 445  */
 446
 447 void ot_poll(void)
 448 {
 449     Actual_Socket s;
 450     OTResult o;
 451
 452     for (s = ot.socklist; s != NULL; s = s->next) {
 453         o = OTLook(s->ep);
 454
 455         switch(o) {
 456           case T_DATA: /* Normal Data */
 457             ot_recv(s);
 458             break;
 459           case T_EXDATA: /* Expedited Data (urgent?) */
 460             ot_recv(s);
 461             break;
 462         }
 463     }
 464 }
 465
 466 void ot_recv(Actual_Socket s)
 467 {
 468     OTResult o;
 469     char buf[20480];
 470     OTFlags flags;
 471
 472     if (s->frozen) return;
 473
 474     do {
 475         o = OTRcv(s->ep, buf, sizeof(buf), &flags);
 476         if (o > 0)
 477             plug_receive(s->plug, 0, buf, o);
 478         if (o < 0 && o != kOTNoDataErr)
 479             plug_closing(s->plug, NULL, 0, 0); /* XXX Error msg */
 480     } while (o > 0);
 481 }
 482
 483
 484 /*
 485  * Local Variables:
 486  * c-file-style: "simon"
 487  * End:
 488  */