main()
{
int i;
assoctab_t *pt[NTABS];
for (i=0;i<NTABS;i++) {
pt[i] = assoctab_create(sizeof(int));
if (!pt[i]) {
printf("create: test failed\n");
exit(1);
}
if (assoctab_subscript(pt[i], 1) != NULL) {
printf("subcript1: test failed\n");
exit(1);
}
}
for (i=0;i<NTABS;i++) {
int h;
h = _heapchk();
if (h != _HEAPOK) {
printf("heapchk: test failed\n");
exit(1);
}
test1(pt[i], 1);
test1(pt[i], 2);
test1(pt[i], 3);
}
for (i=0;i<NTABS;i++)
assoctab_destroy(pt[i]);
printf("test okay\n");
return 0;
}
/*--------------------------------------------------------------------------
Create a pv_t.
--------------------------------------------------------------------------*/
pv_t *pv_create(struct dp_s *dp)
{
pv_t *pv;
pv = (pv_t *)dp_MALLOC(sizeof(pv_t));
if (!pv) return NULL;
memset(pv, 0, sizeof(pv_t));
pv->peers = assoctab_create(sizeof(pv_peer_t));
if (!pv->peers) {
assoctab_destroy(pv->peers);
dp_FREE(pv);
return NULL;
}
pv->next_send = dp->now;
pv->cur_key_index = -1;
pv->cur_ndests = 0;
pv->new_ndests = 0;
pv->cur_nkeys = 0;
pv->cur_offset = 0;
pv->dp = dp;
return pv;
}
/*------------------------------------------------------------------------
Create an instance of the sbdserv module, listening on port for new
connections.
------------------------------------------------------------------------*/
sbdserv_t *sbdserv_create(unsigned short port)
{
clock_t now = eclock();
sbdserv_t *sbdserv;
struct protoent *pe;
struct sockaddr_in addr;
int sockin;
int flags;
DPRINT(("sbdserv_create: creating my socket\n"));
pe = getprotobyname("tcp");
if (!pe) {
DPRINT(("sbdserv_create: unknown protocol:TCP\n"));
return NULL;
}
if ((sockin = socket(AF_INET, SOCK_STREAM, pe->p_proto)) == -1) {
DPRINT(("sbdserv_create: socket error:%d\n", errno));
return NULL;
}
flags = fcntl(sockin, F_GETFL, 0);
if ((-1 == flags)
|| (-1 == fcntl(sockin, F_SETFL, (flags | O_NONBLOCK)))) {
DPRINT(("sbdserv_create: fcntl(sock:%d) error:%d\n", sockin, errno));
return NULL;
}
DPRINT(("sbdserv_create: binding socket:%d\n", sockin));
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = htons(INADDR_ANY);
if (bind(sockin, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
DPRINT(("sbdserv_create: bind error:%d\n", errno));
return NULL;
}
DPRINT(("sbdserv_create: starting listen\n"));
if (listen(sockin, 10) < 0) {
DPRINT(("sbdserv_create: listen error:%d\n", errno));
return NULL;
}
sbdserv = (sbdserv_t *)malloc(sizeof(sbdserv_t));
if (!sbdserv)
return NULL;
sbdserv->conns = assoctab_create(sizeof(sbdserv_conn_t));
if (!sbdserv->conns) {
free(sbdserv);
return NULL;
}
FD_ZERO(&sbdserv->fds);
sbdserv->sockin = sockin;
sbdserv->sockmax = sbdserv->sockin;
sbdserv->cursock = 0;
sbdserv->nsocks = 0;
sbdserv->t_last_poll = now;
return sbdserv;
}
/*--------------------------------------------------------------------------
Add a particular player to the table.
--------------------------------------------------------------------------*/
static pv_peer_t *pv_addPlayer(pv_t *pv, int player)
{
/* No peer yet. Create one. */
pv_peer_t *peer = (pv_peer_t *)assoctab_subscript_grow(pv->peers, player);
if (!peer) {
DPRINT(("pv_addPlayer(%d): can't grow peers!\n", player));
return NULL;
}
if (peer->vars) return peer;
peer->vars = assoctab_create(sizeof(pv_var_t));
peer->incoming.key = dp_PLAYERDATA_KEY_NONE;
peer->allocated = dpio_MAXLEN_RELIABLE;
peer->incoming.buf = dp_MALLOC(peer->allocated);
if (!peer->incoming.buf) return NULL; /* bug */
DPRINT(("pv_addPlayer: created variable table for player %d\n", player));
return peer;
}
/*------------------------------------------------------------------------
Create an instance of the bhttp module, listening on port for new
connections.
------------------------------------------------------------------------*/
bhttp_t *bhttp_create(unsigned short port, bhttp_url2buf_t url2buf_cb, void *url2buf_context)
{
clock_t now = eclock();
bhttp_t *bhttp;
struct protoent *pe;
struct sockaddr_in addr;
int sockin;
int flags;
if (!url2buf_cb)
return NULL;
DPRINT(("bhttp_create: creating my socket\n"));
pe = getprotobyname("tcp");
if (!pe) {
DPRINT(("bhttp_create: unknown protocol:TCP\n"));
return NULL;
}
if ((sockin = socket(AF_INET, SOCK_STREAM, pe->p_proto)) == -1) {
DPRINT(("bhttp_create: socket error:%d\n", errno));
return NULL;
}
flags = fcntl(sockin, F_GETFL, 0);
if ((-1 == flags)
|| (-1 == fcntl(sockin, F_SETFL, (flags | O_NONBLOCK)))) {
DPRINT(("bhttp_create: fcntl(sock:%d) error:%d\n", sockin, errno));
return NULL;
}
DPRINT(("bhttp_create: binding socket:%d\n", sockin));
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = htons(INADDR_ANY);
if (bind(sockin, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
DPRINT(("bhttp_create: bind error:%d\n", errno));
return NULL;
}
DPRINT(("bhttp_create: starting listen\n"));
if (listen(sockin, 10) < 0) {
DPRINT(("bhttp_create: listen error:%d\n", errno));
return NULL;
}
bhttp = (bhttp_t *)malloc(sizeof(bhttp_t));
if (!bhttp)
return NULL;
bhttp->conns = assoctab_create(sizeof(bhttp_conn_t));
if (!bhttp->conns) {
free(bhttp);
return NULL;
}
FD_ZERO(&bhttp->rfds);
FD_ZERO(&bhttp->wfds);
bhttp->sockin = sockin;
bhttp->sockmax = bhttp->sockin;
bhttp->cursock = 0;
bhttp->nsocks = 0;
bhttp->t_last_poll = now;
bhttp->url2buf_cb = url2buf_cb;
bhttp->url2buf_context = url2buf_context;
return bhttp;
}
int
commInit(
commInitReq_t * req, // Request (or NULL)
commInitResp_t * resp) // Response (or NULL)
{
commInitReq_t reqDummy;
commInitResp_t respDummy;
ip_adr_t adr_broadcast;
ip_adr_t *padr;
OSStatus err;
extern Str255 gSavedSelection;
// DebugStr ( "\pcommInit()" );
DPRINT(("@TRUMP commInit(): "));
if (req == NULL)
req = (commInitReq_t *)memset(&reqDummy, 0, sizeof(*req));
if (resp == NULL)
resp = &respDummy;
scratch_flat = malloc(MAX_RAW_PKTLEN);
//scratch_flat = my_dos_malloc(MAX_RAW_PKTLEN, &scratch_seg, &scratch_off, &scratch_selector);
if (!scratch_flat) {
DPRINT(("commInit: couldn't allocate DOS memory!\n"));
resp->status = comm_STATUS_BAD;
return FALSE;
}
// check for the existanct of OpenTransport
if(!OpenTransportExists() || !OpenTransportInetExists()) {
//DebugStr("\pOpen Transport Does Not Exist");
DPRINT(("commInit: UDP ABI not found\n"));
resp->status = comm_STATUS_NETWORK_NOT_PRESENT;
free(scratch_flat);
return FALSE;
}
// Initialize OpenTransport
err = InitOpenTransport();
if (err != noErr) {
resp->status = comm_STATUS_BAD;
free(scratch_flat);
return FALSE;
}
// initialize Internet Services
gInetService = OTOpenInternetServices(kDefaultInternetServicesPath, 0, &err);
if (err != noErr) {
resp->status = comm_STATUS_BAD;
free(scratch_flat);
return FALSE;
}
// open an endpoint for sending and recieving data
err = CreateAndConfigUDP(&gUDPEndpoint);
if (err != noErr) {
resp->status = comm_STATUS_BAD;
free(scratch_flat);
ShutDownUDP();
return FALSE;
}
// create the peer table
peertab = assoctab_create(sizeof(ip_adr_t));
if (!peertab) {
// ABORT! Out of Memory
resp->status = comm_STATUS_BAD;
free(scratch_flat);
ShutDownUDP();
return FALSE;
}
// Get information about the Internet
err = OTInetGetInterfaceInfo(&gInetInfo, kDefaultInetInterface);
if (err != noErr) {
//DebugStr("\pCannot Get Information About Default Interface");
resp->status = comm_STATUS_BAD;
free(scratch_flat);
ShutDownUDP();
return FALSE;
}
// Store our address in the peer table under the bogus ME handle
padr = (ip_adr_t *)assoctab_subscript_grow(peertab, trump_HDL_ME);
if (!padr) {
DPRINT(("commInit: couldn't grow peer table\n"));
resp->status = comm_STATUS_BAD;
free(scratch_flat);
assoctab_destroy(peertab);
ShutDownUDP();
return FALSE;
}
dprint_peertab(peertab);
DPRINT(("commInit: saving handle %d adr %x at %p\n", trump_HDL_ME, gInetInfo.fAddress, padr));
memcpy(padr, &gInetInfo.fAddress, sizeof(ip_adr_t));
dprint_peertab(peertab);
// Open a handle good for receiving packets on the standard port
// SRC = (*,*)
// DEST = (localhost, pt->port)
adr_broadcast = 0xffffffff;
hdl_rx = trump_adr2hdl(adr_broadcast, SOCKET_MW2, SOCKET_MW2, TRUE);
if (hdl_rx == trump_HDL_NONE) {
DPRINT(("commInit: couldn't open handle for listening\n"));
resp->status = comm_STATUS_BUSY;
free(scratch_flat);
assoctab_destroy(peertab);
ShutDownUDP();
return FALSE;
}
/*
if ((req->flags & comm_INIT_FLAGS_RESUME) == 0) {
if (!DoHostListDialog()) {
resp->status = comm_STATUS_EMPTY;
free(scratch_flat);
assoctab_destroy(peertab);
ShutDownUDP();
return FALSE;
}
} else {
// we need to load the last string selected when we are resuming
OpenPrefsFile();
p2cstr(gSavedSelection); // the apps like C-strings
ClosePrefsFile();
}
*/
// initialize our address list to nothing
InitAddressList();
// add our own address to the beginning of the list (it MUST Be the first
// address in our list - we broadcast to all _other_ addresses in our list)
AddAddressToList(gInetInfo.fAddress);
// add the address from the dialog to our broadcast list if the user chose one
if (gSavedSelection[0] != 0) {
InetHostInfo theHostInfo;
OTSetSynchronous(gInetService);
err = OTInetStringToAddress(gInetService, gSavedSelection, &theHostInfo);
OTSetAsynchronous(gInetService);
if (err == noErr) {
AddAddressToList(theHostInfo.addrs[0]);
}
}
resp->status = comm_STATUS_OK;
DPRINT(("commInit: success\n"));
return TRUE;
}
