--- /dev/null
+/* $Id: opentpt.c,v 1.1.2.1 1999/08/02 08:06:32 ben Exp $ */
+/*
+ * Copyright (c) 1999 Ben Harris
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <MacTypes.h>
+#include <OpenTransport.h>
+#include <OpenTptInternet.h>
+#incldue <Processes.h>
+
+#include <stdlib.h>
+
+#include "putty.h"
+
+/* See the top of macnet.c for some idea of how this is meant to work. */
+
+struct otpt_socket {
+ EndpointRef ep;
+ Session *sess;
+ OTLIFO *sendq;
+ OTLIFO *eventq;
+ long eventhandler;
+};
+
+struct otpt_netevent {
+ OTLink *next;
+ Net_Event_Type type;
+};
+
+static int otpt_probe(void);
+static void otpt_init(void);
+static void *otpt_open(Session *, char const *, int);
+static int otpt_recv(void *, void *, int, int);
+static int otpt_send(void *, void *, int, int);
+static void otpt_close(void *);
+static void otpt_destroy(void *);
+static pascal void otpt_notifier(void *, OTEventCode, OTResult , void *);
+static void otpt_sendevent(struct otpt_socket *, Net_Event_Type);
+static pascal void otpt_rcvevent(void *);
+
+Network_Stack otpt_stack = {
+ otpt_init, otpt_open, otpt_recv, otpt_send, otpt_poll, otpt_close,
+ otpt_destroy, otpt_shutdown
+};
+
+static OTConfiguration *otpt_config = kOTInvalidCOnfigurationPtr;
+
+static int otpt_init(void) {
+ OSErr err;
+
+ err = InitOpenTransport();
+ if (err != noErr)
+ return err;
+ otpt_config = OTCreateConfiguration("tcp");
+ if (otpt_config == kOTInvalidConfigurationPtr ||
+ otpt_config == kOTNoMemoryConfigurationPtr)
+ return 1;
+ return 0;
+}
+
+/*
+ * This should only be called once all the connections have been
+ * closed (we don't bother keeping a table of them).
+ */
+
+void otpt_shutdown(void) {
+
+ CloseOpenTransport();
+}
+
+static void *otpt_open(Session *sess, char const *host, int port) {
+ struct otpt_socket *s = NULL;
+ OSStatus err;
+ TCall remote;
+ DNSAddress *remoteaddr;
+
+ s = smalloc(sizeof(*s));
+ memset(s, 0, sizeof(*s));
+
+ /* Get a TCP endpoint (equiv of socket()) */
+ s->ep = OTOpenEndpoint(OTCloneConfiguration(otpt_config), 0, NULL, &err);
+ if (err != kOTNoError || s->ep == NULL) goto splat;
+
+ /* Attach our notifier function (note that this is _not_ a UPP) */
+ err = OTInstallNotifier(s->ep, otpt_notifier, (void *)s);
+ if (err != kOTNoError) goto splat;
+ s->eventhandler = OTCreateSystemTask(&otpt_rcvevent, (void *)s);
+ if (s->eventhandler = 0) goto splat;
+
+ /* Bind to any local address */
+ err = OTBind(s->ep, NULL, NULL);
+ if (err != kOTNoError) goto splat;
+ memset(&remote, 0, sizeof(remote));
+ remoteaddr = smalloc(sizeof(*remoteaddr) - sizeof(remoteaddr->fName) +
+ strlen(host) + 7); /* allow space for port no. */
+ remote.addr.buf = (UInt8 *)remoteaddr;
+ remote.addr.len = OTInitDNSAddress(remoteaddr, host);
+ remote.addr.len += sprintf(&remoteaddr->fName[strlen(remoteaddr->fName)],
+ ":%d", port);
+ /* Asynchronous blocking mode, so we don't have to wait */
+ err = OTSetAsynchronous(s->ep);
+ if (err != kOTNoError) goto splat;
+ err = OTSetBlocking(s->ep);
+ if (err != kOTNoError) goto splat;
+ err = OTConnect(s->ep, &remote, NULL);
+ if (err != kOTNoDataErr)
+ goto splat;
+ return s;
+
+ splat:
+ otpt_destroy(s);
+ return NULL;
+}
+
+static int otpt_recv(void *sock, void *buf, int buflen, int flags) {
+ struct otpt_socket *s = (struct otpt_socket *)sock;
+ OTResult result;
+ OTFlags flags;
+
+ OTSetNonBlocking(s->ep);
+ OTSetSynchronous(s->ep);
+ result = OTRcv(s->ep, buf, buflen, flags);
+ if (result >= 0)
+ return result;
+ else if (result == kOTNoDataError)
+ return 0;
+ else /* confusion! */
+ return 0;
+}
+
+static void otpt_poll(void) {
+
+}
+
+static int otpt_send(void *sock, void *buf, int buflen, int flags) {
+ struct otpt_socket *s = (struct otpt_socket *)sock;
+
+ /* XXX: using blocking mode is bogus, but it's far easier than not. */
+ OTSetSynchronous(s->ep);
+ OTSetBlocking(s->ep);
+ return OTSnd(s->ep, buf, buflen, flags);
+}
+
+/*
+ * Politely ask the other end to close the connection.
+ */
+
+static void otpt_close(void *sock) {
+ struct otpt_socket *s = (struct otpt_socket *)sock;
+
+ /* XXX: using blocking mode is bogus, but it's far easier than not. */
+ OTSetSynchronous(s->ep);
+ OTSetBlocking(s->ep);
+ OTSndOrderlyDisconnect(s->ep);
+}
+
+/*
+ * This should take a socket in any state and undo it all, freeing any
+ * allocated memory and generally making it safe to forget about it.
+ * It should onlu be called at system task time.
+ */
+
+static void otpt_destroy(void *sock) {
+ struct otpt_socket *s = (struct otpt_socket *)sock;
+ OSStatus err;
+ OTLink *link;
+
+ if (s == NULL)
+ return;
+
+ /* Tear down the connection */
+ /* If we ever start using T_MEMORYRELEASED, we need to be careful here. */
+ err = OTSetSynchronous(s->ep);
+ if (err == kOTNoError)
+ err = OTSetNonBlocking(s->ep);
+ if (err == kOTNoError)
+ err = OTCloseProvider(s->ep);
+
+ /* Stop the event handler running */
+ if (s->eventhandler != 0)
+ OTDestroySystemTask(s->eventhandler);
+
+ /* Flush the event and send queues */
+ while ((link = OTLIFODequeue(s->eventq)) != NULL)
+ OTFreeMem(link);
+ while ((link = OTLIFODequeue(s->sendq)) != NULL)
+ OTFreeMem(link);
+
+ /* Finally, free the socket record itself */
+ sfree(s);
+}
+
+/*
+ * Any asynchronous events OpenTransport wants to tell us about end up
+ * here. This function may be called at deferred task or system task
+ * time, and must be re-entrant.
+ */
+
+static pascal void otpt_notifier(void *contextPtr, OTEventCode code,
+ OTResult result, void *cookie) {
+ struct otpt_socket *s = (struct otpt_socket *)contextPtr;
+ OSStatus status;
+ TDiscon discon;
+
+ switch (code) {
+ case T_CONNECT: /* OTConnect completed */
+ status = OTRcvConnect(s->ep, NULL); /* XXX do we want the new TCall? */
+ if (status == kOTNoDataErr)
+ break;
+ else if (status != kOTNoError) {
+ otpt_sendevent(s, NE_DIED);
+ break;
+ }
+ /* Synchronous non-blocking mode for normal data transfer */
+ OTSetSynchronous(s->ep);
+ OTSetNonBlocking(s->ep);
+ otpt_sendevent(s, NE_OPEN);
+ break;
+ case T_DATA:
+ otpt_sendevent(s, NE_DATA);
+ break;
+ case T_EXDATA:
+ otpt_sendevent(s, NE_URGENT);
+ break;
+ case T_DISCONNECT: /* Disconnection complete or OTConnect rejected */
+ memset(&discon, 0, sizeof(discon));
+ /*
+ * This function returns a positive error code. To obtain the
+ * negative error code, subtract that positive value from
+ * -3199.
+ */
+ status = OTRcvDisconnect(s->ep, &discon);
+ if (cookie == NULL) /* spontaneous disconnect */
+ switch (E2OSStatus(discon.reason)) {
+ case kECONNRESETErr:
+ otpt_sendevent(s, NE_ABORT);
+ break;
+ case kETIMEDOUTErr:
+ otpt_sendevent(s, NE_TIMEOUT);
+ break;
+ default:
+ otpt_sendevent(s, NE_DIED);
+ break;
+ }
+ else /* failed connect */
+ otpt_sendevent(s, NE_NOOPEN);
+ case T_ORDREL:
+ OTRcvOrderlyDisconnect(s->ep);
+ otpt_sendevent(s, NE_CLOSING);
+ }
+}
+
+/*
+ * This function is called at interrupt time (or thereabouts) to
+ * dispatch an event that has to be handled at system task time.
+ * Network backends will expect their msg entries to be called then.
+ */
+
+static void otpt_sendevent(struct otpt_socket *s, Net_Event_Type type) {
+ struct otpt_netevent *ne;
+
+ ne = OTAllocMem(sizeof(*ne));
+ if (ne == NULL)
+ fatalbox("OTAllocMem failed. Aargh!");
+ ne->type = type;
+ OTLIFOEnqueue(&s->eventq, &ne->next);
+ /* Schedule something */
+ OTScheduleSystemTask(s->eventhandler);
+}
+
+/*
+ * Pull one or more network events off a socket's queue and handle
+ * them. Keep gong until we run out (events may be getting enqueued
+ * while we're running). This is mildly evil as it'll prevent any
+ * other task running if we're under heavy load.
+ */
+
+static pascal void otpt_rcvevent(void *arg) {
+ struct otpt_socket *s = (struct otpt_socket *)arg;
+ OTLink *link;
+ struct otpt_netevent *ne;
+
+ /* idiom stolen from "Networking With Open Transport". Blame Apple. */
+
+ while ((link = OTLIFOStealList(s->eventq)) != NULL) {
+ link = OTReverseList(link);
+ while (link != NULL) {
+ ne = (struct otpt_netevent *)link;
+ link = ne->next;
+ switch (ne->type) {
+ default:
+ (s->sess->back->msg)(s->sess, s, ne->type);
+ break;
+ }
+ OTFreeMem(ne);
+ }
+ }
+
+
+/*
+ * Local Variables:
+ * c-file-style: "simon"
+ * End:
+ */
+
+
projects / PuTTY.git / commitdiff