macntcp.c

/* macntcp.c -- macintosh nifty application library async TCP routines
 */
/* (C) Copyright 1995 by Carnegie Mellon University
 * All Rights Reserved.
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose is hereby granted without
 * fee, provided that the above copyright notice appear in all copies
 * and that both that copyright notice and this permission notice
 * appear in supporting documentation, and that the name of Carnegie
 * Mellon University not be used in advertising or publicity
 * pertaining to distribution of the software without specific,
 * written prior permission.  Carnegie Mellon University makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied
 * warranty.
 *
 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */
/* (C) Copyright 1994-1995 by Christopher J. Newman
 * All Rights Reserved.
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Christopher J. Newman not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Christopher J. Newman makes no
 * representations about the suitability of this software for any purpose.  It
 * is provided "as is" without express or implied warranty.
 *
 * CHRISTOPHER J. NEWMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
 * SHALL CHRISTOPHER J. NEWMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 *
 * Author:	Christopher J. Newman
 * Message:	This is a nifty program.
 */

#include <string.h>
#include <MacTCPCommonTypes.h>
#include <TCPPB.h>
#include <AddressXlation.h>
#include <GetMyIPAddr.h>
#include "macnapp.h"

#define DEF_STREAM_SIZE 8192
#define MAX_TCPCON  16
#define RDS			8

/* write buffer for TCP writes
 */
typedef struct tcpwb {
	short rused;			/* number of RDS used (-1 == in TCPsend) */
	short wused;			/* amount of small buffer used */
	rdsEntry rds[RDS+1];	/* array of RDS pointers */
	char fflag[RDS+1];		/* free flags for RDS pointers (1 = call DisposPtr) */
	char *buf;				/* write buffer */
} tcpwb;

/* structure describing a TCP connection
 */
typedef struct tcpinfo {
	short state;			/* current state */
	short rclose;			/* remote host wants to close */
	short lclose;			/* local host wants to close */
	int havedata:1;			/* data is available to read */
	int urgent:1;			/* TCP in urgent mode */
	int push:1;				/* next write should be pushed */
	int pushed:1;			/* last write was pushed */
	int reading:1;			/* reading data */
	int server:1;			/* is a server, rather than client */
	int gethost:1;			/* getting hostname -- not a real connection */
	int dnrdone:1;			/* DNR query is done */
	short wbnum;			/* write buffer for next write */
	unsigned short wbsize;	/* size of write buffer */
	unsigned short reason;	/* reason for TCP termination */
	StreamPtr stream;		/* TCP stream */
	ip_port port;			/* TCP port number to connect to */
	void *context;			/* user context */
	na_tcpreadp *callback;	/* callback function */
	rdsEntry rrds[RDS+1];	/* read RDS structure */
	tcpwb wb[2];			/* write buffers */
	struct hostInfo host;	/* hostname & ip_addr of host */
	TCPiopb pb;				/* parameter block for TCP connect/write/close */
	TCPiopb rpb;			/* parameter block for TCP read */
	char buf[1];			/* stream buffer follows */
} tcpinfo;

/* TCP task state information
 */
struct tcpstate {
	na_win win;
	short tcp_driver;
	na_tcpinitp *tcp_initp;
	tcpinfo *tcpbufs[MAX_TCPCON];
	IOParam *open_pb;
	long waiticks, waitstart;
	short waitpercent;
	long streamsize;
	byte TOS, precedence;
	unsigned short wbsize;
	char localhost[256];
} **tcpstate = NULL;
#define tstate ((struct tcpstate *) win)

/* tcp state bitmasks */
#define TCP_PBINUSE   0x04		/* tcp->pb in use */
#define TCP_DNSINUSE  0x08		/* DNS in use */
#define TCP_NOTREADY  0x10      /* not ready for reading */
/* tcp states */
#define TCP_READY     1									/* inactive */
#define TCP_RESOLVE   (TCP_NOTREADY + TCP_DNSINUSE + 0)	/* resolving hostname */
#define TCP_GETHOST   (TCP_NOTREADY + TCP_DNSINUSE + 1)	/* looking up hostname */
#define TCP_WRITING   (TCP_PBINUSE + 0)					/* writing data */
#define TCP_CONNECT   (TCP_NOTREADY + TCP_PBINUSE + 0)	/* waiting for a connection */
#define TCP_CLOSING   (TCP_NOTREADY + TCP_PBINUSE + 1)	/* waiting for TCPclose */
#define TCP_CLOSED    2									/* closed */

/* free write buffer storage
 */
static void freewb(tcpwb *wb)
{
	short i;
	
	for (i = 0; wb->rds[i].length; ++i) {
		if (wb->fflag[i]) {
			DisposPtr(wb->rds[i].ptr);
			wb->fflag[i] = 0;
		}
	}
	wb->rused = 0;
	wb->wused = 0;
}

/* make sure tcp_driver is open
 */
static short tcp_checkdriver()
{
	short msg = NATCP_nodriver;
	struct tcpstate *ts = *tcpstate;
	IOParam *opb = ts->open_pb;
	
	if (!opb) return (1);
	if (opb->ioResult == 1) return (0);
	if (opb->ioResult == noErr && OpenResolver(nil) == noErr) {
		ts->tcp_driver = opb->ioRefNum;
		msg = NATCP_connect;
	}
	DisposPtr((Ptr) opb);
	ts = *tcpstate;
	ts->open_pb = NULL;
	(*ts->tcp_initp)(msg);
	
	return (1);
}

/* wait for MacTCP to finish whatever it's doing, with user cancel
 */
static short tcp_wait(struct tcpstate *ts, tcpinfo *tcp)
{
	KeyMap mapkeys;
#define keys ((unsigned char *)mapkeys)
	short percent;

	while (!tcp_checkdriver()
		|| (tcp && (tcp->state & TCP_DNSINUSE) && ! (volatile) tcp->dnrdone)
		|| (tcp && (tcp->state & TCP_PBINUSE) && (volatile short) tcp->pb.ioResult == 1)) {
		if (ts) {
			if (!ts->waiticks) return (0);
			percent = ((TickCount() - ts->waitstart) * 100) / ts->waiticks;
			if (percent > 100) percent = 100;
			if (percent != ts->waitpercent) {
				(*ts->tcp_initp)(ts->waitpercent = percent);
			}
			if (percent == 100) return (0);
		}
		SystemTask();
		GetKeys(mapkeys);
		if ((keys[0x37 >> 3] >> (0x37 & 7))
			& (keys[0x2f >> 3] >> (0x2f & 7)) & 1) {
			return (0);
		}
	}
	
	return (1);
}

/* clean up the TCP task
 */
static short tcp_closep(na_win *win)
{
	short i, j;
	tcpinfo *tcp;
	tcpwb *wb;
	TCPiopb pb;
	
	tstate->waitstart = TickCount();
	tstate->waitpercent = 0;
	tcp_wait(tstate, NULL);
	memset((void *) &pb, 0, sizeof (pb));
	for (i = 0; i < MAX_TCPCON; ++i) {
		if ((tcp = tstate->tcpbufs[i]) != NULL) {
			/* wait for MacTCP to finish what it's doing, but permit user cancel */
			if (!tcp->server || tcp->state != TCP_CONNECT) tcp_wait(tstate, tcp);
			if (!tcp->gethost) {
				pb.ioCRefNum = tstate->tcp_driver;
				pb.tcpStream = tcp->stream;
				pb.csCode = TCPRelease;
				PBControl((ParmBlkPtr) &pb, false);
			}
			freewb(tcp->wb);
			freewb(tcp->wb + 1);
			DisposPtr((Ptr) tcp);
			tstate->tcpbufs[i] = NULL;
		}
	}
	tcpstate = NULL;
	if (tstate->tcp_driver) CloseResolver();
	
	return (NA_CLOSED);
}

/* begin writing data
 */
static short beginwrite(tcpinfo *tcp)
{
	tcpwb *wb = tcp->wb + tcp->wbnum;
	
	/* if connection terminated, or we've sent a TCPclose, we can't write */
	if (tcp->rclose == 3 || tcp->lclose > 1) return (0);
	memset((void *) &tcp->pb.csParam, 0, sizeof (tcp->pb.csParam));
	tcp->pb.csCode = TCPSend;
	tcp->pb.csParam.send.ulpTimeoutValue = 60; /* 1 minute to send data */
	tcp->pb.csParam.send.ulpTimeoutAction = 0;
	tcp->pb.csParam.send.validityFlags = 0xC0;
	tcp->pb.csParam.send.wdsPtr = (Ptr) wb->rds;
	tcp->pb.csParam.send.pushFlag = tcp->pushed = tcp->push;
	PBControl((ParmBlkPtr) &tcp->pb, true);
	tcp->push = 0;
	tcp->wbnum = 1 - tcp->wbnum;
	wb->rused = -1;
	
	return (tcp->state = TCP_WRITING);
}

/* do I/O polling
 */
short NATCPtask(na_win *win)
{
	tcpinfo *tcp;
	rdsEntry *rds, *trds;
	short result, newstate;
	short processed = NA_PROCESSED;
	na_tcp i;
	tcpwb *wb;
	int j;
	
	/* finish off driver initialization: */
	if (!tstate->tcp_driver) {
		if (!tcp_checkdriver()) return (NA_NOTPROCESSED);
		if (!tstate->tcp_driver) return (NA_REQCLOSE);
	}
	/* loop through connections */
	for (i = 0; i < MAX_TCPCON; ++i) {
		if ((tcp = tstate->tcpbufs[i]) != NULL) do {
			/* read data if we have it */
			if (!tcp->reading && !tcp->rclose && tcp->havedata && tcp->state != TCP_CONNECT) {
				tcp->rpb.ioCRefNum = tstate->tcp_driver;
				tcp->rpb.tcpStream = tcp->stream;
				tcp->rpb.csCode = TCPNoCopyRcv;
				tcp->rpb.csParam.receive.rdsPtr = (Ptr) tcp->rrds;
				tcp->rpb.csParam.receive.commandTimeoutValue = 5;
				tcp->rpb.csParam.receive.rdsLength = RDS;
				if (tcp->pushed) {
					tcp->rpb.csParam.receive.commandTimeoutValue = 1;
					tcp->rpb.csParam.receive.rdsLength = 1;
				}
				tcp->havedata = 0;
				PBControl((ParmBlkPtr) &tcp->rpb, tcp->pushed ? false : true);
				tcp->reading = 1;
				tcp->pushed = 0;
			}
			if (tcp->reading) {
				if ((result = tcp->rpb.ioResult) == 1) {
					processed = NA_NOTPROCESSED;
				} else {
					tcp->reading = 0;
					if (result != noErr) {
						if (result != commandTimeout) {
							(*tcp->callback)(tcp->context, i, NATCP_noread, result, NULL);
						}
					} else {
						result = NATCP_data | NATCP_more;
						if (tcp->rpb.csParam.receive.urgentFlag) tcp->urgent = 1;
						if (tcp->urgent) result |= NATCP_urgent;
						if (tcp->rpb.csParam.receive.markFlag) tcp->urgent = 0;
						for (rds = tcp->rrds; rds->length; ++rds) {
							if (!rds[1].length) result &= ~NATCP_more;
							(*tcp->callback)(tcp->context, i, result,
								rds->length, rds->ptr);
						}
						tcp->rpb.csCode = TCPRcvBfrReturn;
						PBControl((ParmBlkPtr) &tcp->rpb, false);
					}
				}
			}
			result = tcp->pb.ioResult;
			newstate = 0;
			switch (tcp->state) {
				case TCP_GETHOST:
					if (tcp->dnrdone) {
						tcp->rclose = 3;
						newstate = TCP_CLOSED;
						if (tcp->host.rtnCode != noErr) {
							(*tcp->callback)(tcp->context, i, NATCP_nohost,
								tcp->host.rtnCode, NULL);
						} else {
							(*tcp->callback)(tcp->context, i, NATCP_connect,
								strlen(tcp->host.cname), tcp->host.cname);
							strcpy(tstate->localhost, tcp->host.cname);
						}
					}
					break;
				case TCP_RESOLVE:
					if (tcp->dnrdone) {
						if (tcp->host.rtnCode != noErr) {
							tcp->rclose = 3;
							newstate = TCP_CLOSED;
							(*tcp->callback)(tcp->context, i, NATCP_nohost,
								tcp->host.rtnCode, NULL);
						} else if (!tcp->lclose) {
							memset((void *) &tcp->pb, 0, sizeof (tcp->pb));
							tcp->pb.ioCRefNum = tstate->tcp_driver;
							tcp->pb.tcpStream = tcp->stream;
							tcp->pb.csParam.open.ulpTimeoutValue = 30;
							tcp->pb.csParam.open.ulpTimeoutAction = 1; /* Abort on timeout */
							tcp->pb.csParam.open.tosFlags = tstate->TOS;
							tcp->pb.csParam.open.precedence = tstate->precedence;
							tcp->pb.csParam.open.validityFlags = 
								timeoutValue|timeoutAction|typeOfService|precedence;
							tcp->pb.csParam.open.remoteHost = tcp->host.addr[0];
							if (tcp->server) {
								tcp->pb.csCode = TCPPassiveOpen;
								tcp->pb.csParam.open.commandTimeoutValue = 0;
								tcp->pb.csParam.open.remotePort = 0;
								tcp->pb.csParam.open.localPort = tcp->port;
							} else {
								tcp->pb.csCode = TCPActiveOpen;
								tcp->pb.csParam.open.remotePort = tcp->port;
								tcp->pb.csParam.open.localPort = 0;
							}
							PBControl((ParmBlkPtr) &tcp->pb, true);
							newstate = TCP_CONNECT;
						}
					}
					break;
				case TCP_CONNECT:
					if (result == 1) {
						processed = NA_NOTPROCESSED;
						break;
					}
					if (result != noErr) {
						tcp->rclose = 3;
						newstate = TCP_CLOSED;
						(*tcp->callback)(tcp->context, i, NATCP_nocon, result, NULL);
					} else {
						newstate = TCP_READY;
						if (tcp->server) {
							tcp->port = tcp->pb.csParam.open.remotePort;
							if (!*tcp->host.cname) {
								AddrToStr(tcp->pb.csParam.open.remoteHost, tcp->host.cname);
							}
						}
						(*tcp->callback)(tcp->context, i, NATCP_connect,
							tcp->port, tcp->host.cname);
					}
					break;
				case TCP_READY:
					/* Write data if we have it */
					wb = tcp->wb + tcp->wbnum;
					if (wb->rused && (newstate = beginwrite(tcp))) {
						break;
					}
					/* check if other side wants to close */
					if (tcp->rclose == 1) {
						tcp->rclose = 2;
						(*tcp->callback)(tcp->context, i, NATCP_closing, 0, NULL);
					}
					/* check if connection needs closing at this end */
	 				if (tcp->lclose == 1) {
						tcp->lclose = 2;
						tcp->pb.csCode = TCPClose;
						tcp->pb.csParam.close.validityFlags = 0xC0;
						tcp->pb.csParam.close.ulpTimeoutValue = 30; /* give 30 secs to close */
						tcp->pb.csParam.close.ulpTimeoutAction = 0;
						PBControl((ParmBlkPtr) &tcp->pb, true);
						newstate = TCP_CLOSING;
						break;
					}
					/* check if connection closed at both ends */
					if (tcp->rclose == 3) {
						(*tcp->callback)(tcp->context, i, NATCP_closed, tcp->reason, NULL);
						newstate = TCP_CLOSED;
					}
					break;
				case TCP_WRITING:
					if (result == 1) {
						processed = NA_NOTPROCESSED;
						break;
					}
					wb = tcp->wb;
					if (wb->rused != -1) ++wb;
					freewb(wb);
					if (result != noErr) {
						tcp->pushed = 0;
						(*tcp->callback)(tcp->context, i, NATCP_nowrite, result, NULL);
					}
					newstate = TCP_READY;
					break;
				case TCP_CLOSING:
					if (result == 1) {
						processed = NA_NOTPROCESSED;
						break;
					}
					newstate = TCP_READY;
					break;
				case TCP_CLOSED:
					if (!tcp->rclose) break;
					if (!tcp->gethost) {
						tcp->pb.csCode = TCPRelease;
						PBControl((ParmBlkPtr)&tcp->pb, false);
					}
					freewb(tcp->wb);
					freewb(tcp->wb + 1);
					DisposPtr((Ptr) tcp);
					tstate->tcpbufs[i] = NULL;
					break;
			}
			if (newstate) tcp->state = newstate;
		} while (newstate);
	}
	
	return (processed);
}

/* Async notification routine
 */
static pascal void myTCPNotifyProc(StreamPtr stream, unsigned short eventCode,
	Ptr userDataPtr, unsigned short terminReason, struct ICMPReport *icmpMsg)
{
	tcpinfo *tcp = (tcpinfo *) userDataPtr;
	
	switch (eventCode) {
		case TCPTerminate:
			tcp->rclose = 3;
			tcp->reason = terminReason;
			break;
		case TCPClosing:
			tcp->rclose = 1;
			break;
		case TCPDataArrival:
			tcp->havedata = 1;
			break;
		case TCPUrgent:
			tcp->urgent = 1;
			break;
	}
}

/* DNR resultproc */
static pascal void addrproc(struct hostInfo *hinfop, char *udata)
{
	((tcpinfo *) udata)->dnrdone = 1;
}

/* callback to pass TCP info to window
 */
static void winreadp(void *context, na_tcp i, short status, long len, char *buf)
{
	natcp_win *w;
	
	w = (natcp_win *) NAlockWindow((na_win **) context);
	w->s = i;
	(*w->readp)(&w->winp, status, len, buf);
	NAunlockWindowh((na_win **) context, &w->winp);
}

/* adjust TCP settings
 */
void NATCPsettings(long streamsize, short type_of_service, short precedence, unsigned short wbsize)
{
	if (!streamsize) streamsize = DEF_STREAM_SIZE;
	(*tcpstate)->streamsize = streamsize ? streamsize : DEF_STREAM_SIZE;
	(*tcpstate)->TOS = type_of_service;
	(*tcpstate)->precedence = precedence;
	if (!wbsize) wbsize = 1024;
	(*tcpstate)->wbsize = wbsize;
}

/* initialize TCP system
 */
void NATCPinit(na_tcpinitp *initp)
{
	IOParam *pb;
	int i;
	struct tcpstate *ts;

	pb = (IOParam *) NewPtrClear(sizeof (IOParam));
	tcpstate = (struct tcpstate **) NAaddtask(NATCPtask, sizeof (struct tcpstate));
	if (!tcpstate || !pb) {
		(*initp)(NATCP_nomem);
	} else {
		pb->ioNamePtr = "\p.IPP";
		PBOpen((ParmBlkPtr) pb, true);
		ts = *tcpstate;
		for (i = 0; i < MAX_TCPCON; ++i) ts->tcpbufs[i] = NULL;
		ts->waiticks = 60; /* wait 1 sec for TCP close by default */
		ts->win.type = NA_TCPTYPE;
		ts->win.closep = tcp_closep;
		ts->win.priority = -1;
		ts->tcp_initp = initp;
		ts->open_pb = pb;
		NATCPsettings(0, 0, 0, 0);
	}
}

/* get a TCP buffer block
 */
static tcpinfo *getTCPbuf(na_tcpreadp *callback, void *context, int *id)
{
	int i;
	tcpinfo *tcp;
	
	/* make sure driver is open */
	if (!(*tcpstate)->tcp_driver
		&& (!tcp_wait(NULL, NULL) || !(*tcpstate)->tcp_driver)) {
		(*callback)(context, -1, NATCP_nodriver, 0, NULL);
		return (NULL);
	}
	
	/* find pointer slot and create buffer */
	for (i = 0; i < MAX_TCPCON && (*tcpstate)->tcpbufs[i]; ++i);
	if (i == MAX_TCPCON) {
		(*callback)(context, -1, NATCP_notcpbuf, 0, NULL);
		return (NULL);
	}
	tcp = (tcpinfo *) NewPtr(sizeof (tcpinfo) - 1
		+ (*tcpstate)->streamsize + (unsigned long) (*tcpstate)->wbsize * 2);
	if (!tcp) {
		(*callback)(context, -1, NATCP_nomem, 0, NULL);
		return (NULL);
	};
	*id = i;
	(*tcpstate)->tcpbufs[i] = tcp;
	memset((char *) tcp, 0, sizeof (tcpinfo));
	
	/* initialize fields from global state */
	tcp->wbsize = (*tcpstate)->wbsize;
	tcp->wb[0].buf = tcp->buf + (*tcpstate)->streamsize;
	tcp->wb[1].buf = tcp->wb[0].buf + tcp->wbsize;
	tcp->pb.ioCRefNum = (*tcpstate)->tcp_driver;
	tcp->context = context;
	tcp->callback = callback;
	
	return (tcp);
}

/* get host name
 */
void NATCPgethost(na_tcpreadp *callback, void *context)
{
	int id;
	tcpinfo *tcp;
	struct IPParamBlock *ippb;
	na_win *win;
	
	if ((*tcpstate)->localhost[0]) {
		win = NAlockWindow((na_win **) tcpstate);
		(*callback)(context, -1, NATCP_connect, strlen(tstate->localhost),
			tstate->localhost);
		NAunlockWindowh((na_win **) tcpstate, win);
	} else if ((tcp = getTCPbuf(callback, context, &id)) != NULL) {
		/* here we make the assumption that an IP param block is smaller than
		 * a TCP param block.  This seems like a safe assumption to me.
		 */
		ippb = (struct IPParamBlock *) &tcp->pb;
		/* get IP address */
		ippb->ioCRefNum = (*tcpstate)->tcp_driver;
		ippb->csCode = ipctlGetAddr;
		PBControl((ParmBlkPtr)ippb, false);
		if (ippb->ioResult != 0) {
			(*callback)(context, -1, NATCP_notcpbuf, ippb->ioResult, NULL);
			DisposPtr((Ptr) tcp);
			(*tcpstate)->tcpbufs[id] = NULL;
		} else {
			/* begin IP address lookup */
			tcp->dnrdone = 0;
			AddrToName(ippb->ourAddress, &tcp->host, addrproc, (char *) tcp);
			tcp->state = TCP_GETHOST;
			tcp->gethost = 1;
		}
	}
}

/* open a TCP connection
 */
na_tcp NATCPopen(na_tcpreadp *callback, void *context, char *host, long port, short flags)
{
	int i, err = NATCP_notcpbuf;
	OSErr resolve = noErr;
	tcpinfo *tcp;
	
	if ((tcp = getTCPbuf(callback, context, &i)) == NULL) return (-1);
	if (flags & NATCP_server) tcp->server = 1;
	tcp->port = port;
	tcp->pb.csCode = TCPCreate;
	tcp->pb.csParam.create.rcvBuff = (Ptr) tcp->buf;
	tcp->pb.csParam.create.rcvBuffLen = (*tcpstate)->streamsize;
	tcp->pb.csParam.create.notifyProc = myTCPNotifyProc;
	tcp->pb.csParam.create.userDataPtr = (Ptr) tcp;
	PBControl((ParmBlkPtr)&tcp->pb, false);
	if (tcp->pb.ioResult == 0) {
		tcp->state = TCP_RESOLVE;
		tcp->stream = tcp->pb.tcpStream;
		/* a server isn't required to have a hostname */
		if (!host && tcp->server) return (i);
		tcp->dnrdone = 0;
		resolve = StrToAddr(host, &tcp->host, addrproc, (char *) tcp);
		if (resolve == noErr) tcp->dnrdone = 1;
		if (resolve == cacheFault || resolve == noErr) {
			return (i);
		}
		err = NATCP_nohost;
	}
	DisposPtr((Ptr) tcp);
	(*tcpstate)->tcpbufs[i] = NULL;
	(*callback)(context, -1, err, resolve, NULL);
	
	return (-1);
}

/* open a connection to a tcp window
 */
na_tcp NATCPwinopen(natcp_win *w, char *host, long port, short flags)
{
	return (NATCPopen(winreadp, (void *) RecoverHandle((Ptr) w), host, port, flags));
}

/* pass a buffer to tcp connection for writing
 *  dispose of -1 = copy data
 */
short NATCPwrite(na_tcp i, Ptr data, long len, short dispose)
{
	tcpinfo *tcp = (*tcpstate)->tcpbufs[i];
	rdsEntry *rds = NULL;
	tcpwb *wb;
	long totallen = 0;
	int j;
	
	if (tcp == NULL || tcp->lclose > 0 || tcp->rclose == 3) {
		return (NATCP_nocon);
	}
	wb = tcp->wb + tcp->wbnum;
	if (wb->rused == RDS) wb = tcp->wb + (1 - tcp->wbnum);
	if (wb->rused == -1 || wb->rused == RDS) return (NATCP_notcpbuf);
	for (j = 0; j < wb->rused; ++j) {
		totallen += wb->rds[j].length;
	}
	if (totallen + len >= 65535) return (NATCP_notcpbuf);
	rds = wb->rds + wb->rused;
	rds->length = len;
	rds->ptr = data;
	rds[1].length = 0;
	if (dispose < 0) {
		if (len < tcp->wbsize - wb->wused) {
			/* if data short enough, use small internal buffer */
			rds->ptr = wb->buf + wb->wused;
			wb->wused += len;
			dispose = 0;
			/* If adjacent to last rds, attach to it */
			if (wb->rused && rds[-1].ptr + rds[-1].length == rds->ptr) {
				--wb->rused;
				rds[-1].length += len;
				rds->length = 0;
			}
		} else {
			rds->ptr = NewPtr(len);
			if (!rds->ptr) return (NATCP_nomem);
			dispose = 1;
		}
		memcpy(rds->ptr, data, len);
	}
	wb->fflag[wb->rused++] = dispose;
	if (tcp->push && tcp->state == TCP_READY) {
		(void) beginwrite(tcp);
	}
	
	return (NATCP_data);
}

/* put a character on the TCP connection -- optimized for fast turnaround
 */
short NATCPputchar(na_tcp i, char c)
{
	(*tcpstate)->tcpbufs[i]->push = 1;
	
	return (NATCPwrite(i, (Ptr) &c, 1, -1));
}

/* close a TCP connection
 */
void NATCPclose(na_tcp i)
{
	tcpinfo *tcp = (*tcpstate)->tcpbufs[i];
	
	if (tcp && tcp->lclose < 1) tcp->lclose = 1;
}

/* dispose of all TCP system resources
 */
void NATCPdone(long waiticks)
{
	struct tcpstate *ts;
	
	if (tcpstate) {
		ts = (struct tcpstate *) NAlockWindow((na_win **) tcpstate);
		ts->waiticks = waiticks;
		NAcloseWindow((na_win *) ts, NA_REQCLOSE);
	}
}