This is macntcp.c in view mode; [Download] [Up]
/* 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);
}
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.