Sdr getAcssdr(void)
{
static int haveTriedAcsSdr = 0;
if (acsSdr || haveTriedAcsSdr)
{
return acsSdr;
}
if (ionAttach() < 0)
{
putErrmsg("Can't attach to ION.", NULL);
return NULL;
}
haveTriedAcsSdr = 1;
acsSdr = sdr_start_using(acssdrName);
if (acsSdr == NULL)
{
writeMemoNote("[i] This task is unable to exercise ACS \
because the ACS SDR is not initialized, as noted in message above",
itoa(sm_TaskIdSelf()));
}
return acsSdr;
}
static void sptracePrint(char *txt)
{
char buffer[256];
isprintf(buffer, sizeof buffer, "sptrace (pid %d) %s", sm_TaskIdSelf(),
txt);
writeMemo(buffer);
}
static void unlockPartition(PartitionMap *map)
{
if (map->status == MANAGED
&& map->ownerTask == sm_TaskIdSelf()
&& pthread_equal(map->ownerThread, pthread_self()))
{
map->depth--;
if (map->depth == 0)
{
map->ownerTask = -1;
if (map->semaphore != -1)
{
sm_SemGive(map->semaphore);
}
}
}
}
void bp_close(BpSAP sap)
{
VEndpoint *vpoint;
if (sap == NULL)
{
return;
}
vpoint = sap->vpoint;
if (vpoint->appPid == sm_TaskIdSelf())
{
vpoint->appPid = -1;
}
MRELEASE(sap->endpointMetaEid.nss);
MRELEASE(sap->endpointMetaEid.schemeName);
MRELEASE(sap);
}
void ionDetach()
{
#if defined (VXWORKS) || defined (bionic)
return;
#elif defined (RTEMS)
sm_TaskForget(sm_TaskIdSelf());
#else
Sdr ionsdr = _ionsdr(NULL);
if (ionsdr)
{
sdr_stop_using(ionsdr);
ionsdr = NULL; /* To reset to NULL. */
oK(_ionsdr(&ionsdr));
}
#ifdef mingw
oK(_winsock(1));
#endif
#endif
}
static void lockPartition(PartitionMap *map)
{
int selfTask;
pthread_t selfThread;
CHKVOID(map->status == MANAGED);
selfTask = sm_TaskIdSelf();
selfThread = pthread_self();
if (map->ownerTask == selfTask
&& pthread_equal(map->ownerThread, selfThread))
{
map->depth++;
return;
}
CHKVOID(map->semaphore != -1);
oK(sm_SemTake(map->semaphore));
map->ownerThread = selfThread;
map->ownerTask = selfTask;
map->depth = 1;
}
int tcpclo(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ductName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *ductName = (argc > 1 ? argv[1] : NULL);
#endif
unsigned char *buffer;
VOutduct *vduct;
PsmAddress vductElt;
Sdr sdr;
Outduct duct;
ClProtocol protocol;
Outflow outflows[3];
int i;
char *hostName;
unsigned short portNbr;
unsigned int hostNbr;
struct sockaddr socketName;
struct sockaddr_in *inetName;
int running = 1;
pthread_mutex_t mutex;
KeepaliveThreadParms parms;
ReceiveThreadParms rparms;
pthread_t keepaliveThread;
pthread_t receiverThread;
Object bundleZco;
BpExtendedCOS extendedCOS;
char destDuctName[MAX_CL_DUCT_NAME_LEN + 1];
unsigned int bundleLength;
int ductSocket = -1;
int bytesSent;
int keepalivePeriod = 0;
VInduct *viduct;
if (ductName == NULL)
{
PUTS("Usage: tcpclo <remote host name>[:<port number>]");
return 0;
}
if (bpAttach() < 0)
{
putErrmsg("tcpclo can't attach to BP", NULL);
return 1;
}
buffer = MTAKE(TCPCLA_BUFSZ);
if (buffer == NULL)
{
putErrmsg("No memory for TCP buffer in tcpclo.", NULL);
return 1;
}
findOutduct("tcp", ductName, &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such tcp duct.", ductName);
MRELEASE(buffer);
return 1;
}
if (vduct->cloPid != ERROR && vduct->cloPid != sm_TaskIdSelf())
{
putErrmsg("CLO task is already started for this duct.",
itoa(vduct->cloPid));
MRELEASE(buffer);
return 1;
}
/* All command-line arguments are now validated. */
sdr = getIonsdr();
CHKERR(sdr_begin_xn(sdr));
sdr_read(sdr, (char *) &duct, sdr_list_data(sdr, vduct->outductElt),
sizeof(Outduct));
sdr_read(sdr, (char *) &protocol, duct.protocol, sizeof(ClProtocol));
sdr_exit_xn(sdr);
if (protocol.nominalRate == 0)
{
vduct->xmitThrottle.nominalRate = DEFAULT_TCP_RATE;
}
else
{
vduct->xmitThrottle.nominalRate = protocol.nominalRate;
}
memset((char *) outflows, 0, sizeof outflows);
outflows[0].outboundBundles = duct.bulkQueue;
outflows[1].outboundBundles = duct.stdQueue;
outflows[2].outboundBundles = duct.urgentQueue;
for (i = 0; i < 3; i++)
{
outflows[i].svcFactor = 1 << i;
}
hostName = ductName;
parseSocketSpec(ductName, &portNbr, &hostNbr);
if (portNbr == 0)
{
portNbr = BpTcpDefaultPortNbr;
}
portNbr = htons(portNbr);
if (hostNbr == 0)
{
putErrmsg("Can't get IP address for host.", hostName);
MRELEASE(buffer);
return 1;
}
hostNbr = htonl(hostNbr);
memset((char *) &socketName, 0, sizeof socketName);
inetName = (struct sockaddr_in *) &socketName;
inetName->sin_family = AF_INET;
inetName->sin_port = portNbr;
memcpy((char *) &(inetName->sin_addr.s_addr), (char *) &hostNbr, 4);
if (_tcpOutductId(&socketName, "tcp", ductName) < 0)
{
putErrmsg("Can't record TCP Outduct ID for connection.", NULL);
MRELEASE(buffer);
return -1;
}
/* Set up signal handling. SIGTERM is shutdown signal. */
oK(tcpcloSemaphore(&(vduct->semaphore)));
isignal(SIGTERM, shutDownClo);
#ifndef mingw
isignal(SIGPIPE, handleConnectionLoss);
#endif
/* Start the keepalive thread for the eventual connection. */
tcpDesiredKeepAlivePeriod = KEEPALIVE_PERIOD;
parms.cloRunning = &running;
pthread_mutex_init(&mutex, NULL);
parms.mutex = &mutex;
parms.socketName = &socketName;
parms.ductSocket = &ductSocket;
parms.keepalivePeriod = &keepalivePeriod;
if (pthread_begin(&keepaliveThread, NULL, sendKeepalives, &parms))
{
putSysErrmsg("tcpclo can't create keepalive thread", NULL);
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
return 1;
}
// Returns the VInduct Object of first induct with same protocol
// as the outduct. The VInduct is required to create an acq area.
// The Acq Area inturn uses the throttle information from VInduct
// object while receiving bundles. The throttle information
// of all inducts of the same induct will be the same, so choosing
// any induct will serve the purpose.
findVInduct(&viduct,protocol.name);
if(viduct == NULL)
{
putErrmsg("tcpclo can't get VInduct", NULL);
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
return 1;
}
rparms.vduct = viduct;
rparms.bundleSocket = &ductSocket;
rparms.mutex = &mutex;
rparms.cloRunning = &running;
if (pthread_begin(&receiverThread, NULL, receiveBundles, &rparms))
{
putSysErrmsg("tcpclo can't create receive thread", NULL);
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
return 1;
}
/* Can now begin transmitting to remote duct. */
{
char txt[500];
isprintf(txt, sizeof(txt),
"[i] tcpclo is running, spec=[%s:%d].",
inet_ntoa(inetName->sin_addr),
ntohs(inetName->sin_port));
writeMemo(txt);
}
while (running && !(sm_SemEnded(tcpcloSemaphore(NULL))))
{
if (bpDequeue(vduct, outflows, &bundleZco, &extendedCOS,
destDuctName, 0, -1) < 0)
{
running = 0; /* Terminate CLO. */
continue;
}
if (bundleZco == 0) /* Interrupted. */
{
continue;
}
CHKZERO(sdr_begin_xn(sdr));
bundleLength = zco_length(sdr, bundleZco);
sdr_exit_xn(sdr);
pthread_mutex_lock(&mutex);
bytesSent = sendBundleByTCPCL(&socketName, &ductSocket,
bundleLength, bundleZco, buffer, &keepalivePeriod);
pthread_mutex_unlock(&mutex);
if(bytesSent < 0)
{
running = 0; /* Terminate CLO. */
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
writeMemo("[i] tcpclo done sending");
if (sendShutDownMessage(&ductSocket, SHUT_DN_NO, -1, &socketName) < 0)
{
putErrmsg("Sending Shutdown message failed!!",NULL);
}
if (ductSocket != -1)
{
closesocket(ductSocket);
ductSocket=-1;
}
running = 0;
pthread_join(keepaliveThread, NULL);
writeMemo("[i] tcpclo keepalive thread killed");
pthread_join(receiverThread, NULL);
writeMemo("[i] tcpclo receiver thread killed");
writeErrmsgMemos();
writeMemo("[i] tcpclo duct has ended.");
oK(_tcpOutductId(&socketName, NULL, NULL));
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
bp_detach();
return 0;
}
int ltpcli(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ductName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *ductName = (argc > 1 ? argv[1] : NULL);
#endif
VInduct *vduct;
PsmAddress vductElt;
ReceiverThreadParms rtp;
pthread_t receiverThread;
if (ductName == NULL)
{
PUTS("Usage: ltpcli <local engine number>]");
return 0;
}
if (bpAttach() < 0)
{
putErrmsg("ltpcli can't attach to BP.", NULL);
return -1;
}
findInduct("ltp", ductName, &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such ltp duct.", ductName);
return -1;
}
if (vduct->cliPid != ERROR && vduct->cliPid != sm_TaskIdSelf())
{
putErrmsg("CLI task is already started for this duct.",
itoa(vduct->cliPid));
return -1;
}
/* All command-line arguments are now validated. */
if (ltp_attach() < 0)
{
putErrmsg("ltpcli can't initialize LTP.", NULL);
return -1;
}
/* Set up signal handling; SIGTERM is shutdown signal. */
ionNoteMainThread("ltpcli");
isignal(SIGTERM, interruptThread);
/* Start the receiver thread. */
rtp.vduct = vduct;
rtp.running = 1;
if (pthread_begin(&receiverThread, NULL, handleNotices, &rtp))
{
putSysErrmsg("ltpcli can't create receiver thread", NULL);
return 1;
}
/* Now sleep until interrupted by SIGTERM, at which point
* it's time to stop the induct. */
writeMemo("[i] ltpcli is running.");
ionPauseMainThread(-1);
/* Time to shut down. */
rtp.running = 0;
/* Stop the receiver thread by interrupting client access. */
ltp_interrupt(BpLtpClientId);
pthread_join(receiverThread, NULL);
writeErrmsgMemos();
writeMemo("[i] ltpcli duct has ended.");
ionDetach();
return 0;
}
int bp_receive(BpSAP sap, BpDelivery *dlvBuffer, int timeoutSeconds)
{
Sdr sdr = getIonsdr();
VEndpoint *vpoint;
OBJ_POINTER(Endpoint, endpoint);
Object dlvElt;
Object bundleAddr;
Bundle bundle;
TimerParms timerParms;
pthread_t timerThread;
int result;
char *dictionary;
CHKERR(sap && dlvBuffer);
if (timeoutSeconds < BP_BLOCKING)
{
putErrmsg("Illegal timeout interval.", itoa(timeoutSeconds));
return -1;
}
vpoint = sap->vpoint;
sdr_begin_xn(sdr);
if (vpoint->appPid != sm_TaskIdSelf())
{
sdr_exit_xn(sdr);
putErrmsg("Can't receive: not owner of endpoint.",
itoa(vpoint->appPid));
return -1;
}
if (sm_SemEnded(vpoint->semaphore))
{
sdr_exit_xn(sdr);
writeMemo("[?] Endpoint has been stopped.");
/* End task, but without error. */
return -1;
}
/* Get oldest bundle in delivery queue, if any; wait
* for one if necessary. */
GET_OBJ_POINTER(sdr, Endpoint, endpoint, sdr_list_data(sdr,
vpoint->endpointElt));
dlvElt = sdr_list_first(sdr, endpoint->deliveryQueue);
if (dlvElt == 0)
{
sdr_exit_xn(sdr);
if (timeoutSeconds == BP_POLL)
{
dlvBuffer->result = BpReceptionTimedOut;
return 0;
}
/* Wait for semaphore to be given, either by the
* deliverBundle() function or by timer thread. */
if (timeoutSeconds == BP_BLOCKING)
{
timerParms.interval = -1;
}
else /* This is a receive() with a deadline. */
{
timerParms.interval = timeoutSeconds;
timerParms.semaphore = vpoint->semaphore;
if (pthread_create(&timerThread, NULL, timerMain,
&timerParms) < 0)
{
putSysErrmsg("Can't enable interval timer",
NULL);
return -1;
}
}
/* Take endpoint semaphore. */
if (sm_SemTake(vpoint->semaphore) < 0)
{
putErrmsg("Can't take endpoint semaphore.", NULL);
return -1;
}
if (sm_SemEnded(vpoint->semaphore))
{
writeMemo("[i] Endpoint has been stopped.");
/* End task, but without error. */
return -1;
}
/* Have taken the semaphore, one way or another. */
sdr_begin_xn(sdr);
dlvElt = sdr_list_first(sdr, endpoint->deliveryQueue);
if (dlvElt == 0) /* Still nothing. */
{
/* Either sm_SemTake() was interrupted
* or else timer thread gave semaphore. */
sdr_exit_xn(sdr);
if (timerParms.interval == 0)
{
/* Timer expired. */
dlvBuffer->result = BpReceptionTimedOut;
pthread_join(timerThread, NULL);
}
else /* Interrupted. */
{
dlvBuffer->result = BpReceptionInterrupted;
if (timerParms.interval != -1)
{
pthread_cancel(timerThread);
pthread_join(timerThread, NULL);
}
}
return 0;
}
else /* Bundle was delivered. */
{
if (timerParms.interval != -1)
{
pthread_cancel(timerThread);
pthread_join(timerThread, NULL);
}
}
}
/* At this point, we have got a dlvElt and are in an SDR
* transaction. */
bundleAddr = sdr_list_data(sdr, dlvElt);
sdr_stage(sdr, (char *) &bundle, bundleAddr, sizeof(Bundle));
dictionary = retrieveDictionary(&bundle);
if (dictionary == (char *) &bundle)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't retrieve dictionary.", NULL);
return -1;
}
/* Now fill in the data indication structure. */
dlvBuffer->result = BpPayloadPresent;
if (printEid(&bundle.id.source, dictionary,
&dlvBuffer->bundleSourceEid) < 0)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't print source EID.", NULL);
return -1;
}
dlvBuffer->bundleCreationTime.seconds = bundle.id.creationTime.seconds;
dlvBuffer->bundleCreationTime.count = bundle.id.creationTime.count;
dlvBuffer->adminRecord = bundle.bundleProcFlags & BDL_IS_ADMIN;
dlvBuffer->adu = zco_add_reference(sdr, bundle.payload.content);
dlvBuffer->ackRequested = bundle.bundleProcFlags & BDL_APP_ACK_REQUEST;
/* Now before returning we send delivery status report
* if it is requested. */
if (SRR_FLAGS(bundle.bundleProcFlags) & BP_DELIVERED_RPT)
{
bundle.statusRpt.flags |= BP_DELIVERED_RPT;
getCurrentDtnTime(&bundle.statusRpt.deliveryTime);
}
if (bundle.statusRpt.flags)
{
result = sendStatusRpt(&bundle, dictionary);
if (result < 0)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't send status report.", NULL);
return -1;
}
}
/* Finally delete the delivery list element and, if
* possible, destroy the bundle itself. */
if (dictionary)
{
MRELEASE(dictionary);
}
sdr_list_delete(sdr, dlvElt, (SdrListDeleteFn) NULL, NULL);
bundle.dlvQueueElt = 0;
sdr_write(sdr, bundleAddr, (char *) &bundle, sizeof(Bundle));
if (bpDestroyBundle(bundleAddr, 0) < 0)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't destroy bundle.", NULL);
return -1;
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Failure in bundle reception.", NULL);
return -1;
}
return 0;
}
int bp_open(char *eidString, BpSAP *bpsapPtr)
{
Sdr sdr;
MetaEid metaEid;
VScheme *vscheme;
PsmAddress vschemeElt;
Sap sap;
VEndpoint *vpoint;
PsmAddress vpointElt;
CHKERR(eidString && *eidString && bpsapPtr);
*bpsapPtr = NULL; /* Default, in case of failure. */
sdr = getIonsdr();
sdr_begin_xn(sdr); /* Just to lock memory. */
/* First validate the endpoint ID. */
if (parseEidString(eidString, &metaEid, &vscheme, &vschemeElt) == 0)
{
sdr_exit_xn(sdr);
putErrmsg("Malformed EID.", eidString);
return -1;
}
if (vschemeElt == 0)
{
sdr_exit_xn(sdr);
putErrmsg("Scheme not known.", metaEid.schemeName);
restoreEidString(&metaEid);
return -1;
}
findEndpoint(NULL, metaEid.nss, vscheme, &vpoint, &vpointElt);
if (vpointElt == 0)
{
sdr_exit_xn(sdr);
putErrmsg("Endpoint not known.", metaEid.nss);
restoreEidString(&metaEid);
return -1;
}
/* Endpoint exists; make sure it's not already opened
* by some application. */
if (vpoint->appPid > 0) /* Endpoint not closed. */
{
if (sm_TaskExists(vpoint->appPid))
{
sdr_exit_xn(sdr);
if (vpoint->appPid == sm_TaskIdSelf())
{
return 0;
}
restoreEidString(&metaEid);
putErrmsg("Endpoint is already open.",
itoa(vpoint->appPid));
return -1;
}
/* Application terminated without closing the
* endpoint, so simply close it now. */
vpoint->appPid = -1;
}
/* Construct the service access point. */
sap.vpoint = vpoint;
memcpy(&sap.endpointMetaEid, &metaEid, sizeof(MetaEid));
sap.endpointMetaEid.colon = NULL;
sap.endpointMetaEid.schemeName = MTAKE(metaEid.schemeNameLength + 1);
if (sap.endpointMetaEid.schemeName == NULL)
{
sdr_exit_xn(sdr);
putErrmsg("Can't create BpSAP.", NULL);
restoreEidString(&metaEid);
return -1;
}
sap.endpointMetaEid.nss = MTAKE(metaEid.nssLength + 1);
if (sap.endpointMetaEid.nss == NULL)
{
sdr_exit_xn(sdr);
MRELEASE(sap.endpointMetaEid.schemeName);
putErrmsg("Can't create BpSAP.", NULL);
restoreEidString(&metaEid);
return -1;
}
*bpsapPtr = MTAKE(sizeof(Sap));
if (*bpsapPtr == NULL)
{
sdr_exit_xn(sdr);
MRELEASE(sap.endpointMetaEid.nss);
MRELEASE(sap.endpointMetaEid.schemeName);
putErrmsg("Can't create BpSAP.", NULL);
restoreEidString(&metaEid);
return -1;
}
istrcpy(sap.endpointMetaEid.schemeName, metaEid.schemeName,
sizeof sap.endpointMetaEid.schemeName);
istrcpy(sap.endpointMetaEid.nss, metaEid.nss,
sizeof sap.endpointMetaEid.nss);
restoreEidString(&metaEid);
sap.recvSemaphore = vpoint->semaphore;
memcpy((char *) *bpsapPtr, (char *) &sap, sizeof(Sap));
/* Having created the SAP, give its owner exclusive
* access to the endpoint. */
vpoint->appPid = sm_TaskIdSelf();
sdr_exit_xn(sdr); /* Unlock memory. */
return 0;
}
int udplsi(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *endpointSpec = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *endpointSpec = (argc > 1 ? argv[1] : NULL);
#endif
LtpVdb *vdb;
unsigned short portNbr = 0;
unsigned int ipAddress = INADDR_ANY;
struct sockaddr socketName;
struct sockaddr_in *inetName;
ReceiverThreadParms rtp;
socklen_t nameLength;
pthread_t receiverThread;
int fd;
char quit = '\0';
/* Note that ltpadmin must be run before the first
* invocation of ltplsi, to initialize the LTP database
* (as necessary) and dynamic database. */
if (ltpInit(0) < 0)
{
putErrmsg("udplsi can't initialize LTP.", NULL);
return 1;
}
vdb = getLtpVdb();
if (vdb->lsiPid != ERROR && vdb->lsiPid != sm_TaskIdSelf())
{
putErrmsg("LSI task is already started.", itoa(vdb->lsiPid));
return 1;
}
/* All command-line arguments are now validated. */
if (endpointSpec)
{
if(parseSocketSpec(endpointSpec, &portNbr, &ipAddress) != 0)
{
putErrmsg("Can't get IP/port for endpointSpec.",
endpointSpec);
return -1;
}
}
if (portNbr == 0)
{
portNbr = LtpUdpDefaultPortNbr;
}
portNbr = htons(portNbr);
ipAddress = htonl(ipAddress);
memset((char *) &socketName, 0, sizeof socketName);
inetName = (struct sockaddr_in *) &socketName;
inetName->sin_family = AF_INET;
inetName->sin_port = portNbr;
memcpy((char *) &(inetName->sin_addr.s_addr), (char *) &ipAddress, 4);
rtp.linkSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (rtp.linkSocket < 0)
{
putSysErrmsg("LSI can't open UDP socket", NULL);
return -1;
}
nameLength = sizeof(struct sockaddr);
if (reUseAddress(rtp.linkSocket)
|| bind(rtp.linkSocket, &socketName, nameLength) < 0
|| getsockname(rtp.linkSocket, &socketName, &nameLength) < 0)
{
closesocket(rtp.linkSocket);
putSysErrmsg("Can't initialize socket", NULL);
return 1;
}
/* Set up signal handling; SIGTERM is shutdown signal. */
ionNoteMainThread("udplsi");
isignal(SIGTERM, interruptThread);
/* Start the receiver thread. */
rtp.running = 1;
if (pthread_begin(&receiverThread, NULL, handleDatagrams, &rtp))
{
closesocket(rtp.linkSocket);
putSysErrmsg("udplsi can't create receiver thread", NULL);
return 1;
}
/* Now sleep until interrupted by SIGTERM, at which point
* it's time to stop the link service. */
{
char txt[500];
isprintf(txt, sizeof(txt),
"[i] udplsi is running, spec=[%s:%d].",
inet_ntoa(inetName->sin_addr), ntohs(portNbr));
writeMemo(txt);
}
ionPauseMainThread(-1);
/* Time to shut down. */
rtp.running = 0;
/* Wake up the receiver thread by sending it a 1-byte
* datagram. */
fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (fd >= 0)
{
isendto(fd, &quit, 1, 0, &socketName, sizeof(struct sockaddr));
closesocket(fd);
}
pthread_join(receiverThread, NULL);
closesocket(rtp.linkSocket);
writeErrmsgMemos();
writeMemo("[i] udplsi has ended.");
ionDetach();
return 0;
}
int udpclo(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
#else
int main(int argc, char *argv[])
{
#endif
unsigned char *buffer;
VOutduct *vduct;
PsmAddress vductElt;
Sdr sdr;
Outduct outduct;
ClProtocol protocol;
Outflow outflows[3];
int i;
char *hostName;
unsigned short portNbr;
unsigned int hostNbr;
struct sockaddr socketName;
struct sockaddr_in *inetName;
Object bundleZco;
BpExtendedCOS extendedCOS;
char destDuctName[MAX_CL_DUCT_NAME_LEN + 1];
unsigned int bundleLength;
int ductSocket = -1;
int bytesSent;
if (bpAttach() < 0)
{
putErrmsg("udpclo can't attach to BP.", NULL);
return -1;
}
buffer = MTAKE(UDPCLA_BUFSZ);
if (buffer == NULL)
{
putErrmsg("No memory for UDP buffer in udpclo.", NULL);
return -1;
}
findOutduct("udp", "*", &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such udp duct.", "*");
MRELEASE(buffer);
return -1;
}
if (vduct->cloPid > 0 && vduct->cloPid != sm_TaskIdSelf())
{
putErrmsg("CLO task is already started for this duct.",
itoa(vduct->cloPid));
MRELEASE(buffer);
return -1;
}
/* All command-line arguments are now validated. */
sdr = getIonsdr();
sdr_read(sdr, (char *) &outduct, sdr_list_data(sdr, vduct->outductElt),
sizeof(Outduct));
sdr_read(sdr, (char *) &protocol, outduct.protocol, sizeof(ClProtocol));
if (protocol.nominalRate <= 0)
{
vduct->xmitThrottle.nominalRate = DEFAULT_UDP_RATE;
}
else
{
vduct->xmitThrottle.nominalRate = protocol.nominalRate;
}
memset((char *) outflows, 0, sizeof outflows);
outflows[0].outboundBundles = outduct.bulkQueue;
outflows[1].outboundBundles = outduct.stdQueue;
outflows[2].outboundBundles = outduct.urgentQueue;
for (i = 0; i < 3; i++)
{
outflows[i].svcFactor = 1 << i;
}
/* Set up signal handling. SIGTERM is shutdown signal. */
oK(udpcloSemaphore(&(vduct->semaphore)));
isignal(SIGTERM, shutDownClo);
/* Can now begin transmitting to remote duct. */
writeMemo("[i] udpclo is running.");
while (!(sm_SemEnded(vduct->semaphore)))
{
if (bpDequeue(vduct, outflows, &bundleZco, &extendedCOS,
destDuctName) < 0)
{
sm_SemEnd(udpcloSemaphore(NULL));/* Stop. */
continue;
}
if (bundleZco == 0) /* Interrupted. */
{
continue;
}
hostName = destDuctName;
parseSocketSpec(destDuctName, &portNbr, &hostNbr);
if (portNbr == 0)
{
portNbr = BpUdpDefaultPortNbr;
}
portNbr = htons(portNbr);
if (hostNbr == 0)
{
writeMemoNote("[?] Can't get IP address for host",
hostName);
}
hostNbr = htonl(hostNbr);
memset((char *) &socketName, 0, sizeof socketName);
inetName = (struct sockaddr_in *) &socketName;
inetName->sin_family = AF_INET;
inetName->sin_port = portNbr;
memcpy((char *) &(inetName->sin_addr.s_addr),
(char *) &hostNbr, 4);
bundleLength = zco_length(sdr, bundleZco);
bytesSent = sendBundleByUDP(&socketName, &ductSocket,
bundleLength, bundleZco, buffer);
if (bytesSent < bundleLength)
{
sm_SemEnd(udpcloSemaphore(NULL));/* Stop. */
continue;
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
if (ductSocket != -1)
{
close(ductSocket);
}
writeErrmsgMemos();
writeMemo("[i] udpclo duct has ended.");
MRELEASE(buffer);
ionDetach();
return 0;
}
int bsspclo(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ductName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *ductName = (argc > 1 ? argv[1] : NULL);
#endif
Sdr sdr;
VOutduct *vduct;
PsmAddress vductElt;
vast destEngineNbr;
Outduct outduct;
ClProtocol protocol;
Outflow outflows[3];
int i;
int running = 1;
Object bundleZco;
BpExtendedCOS extendedCOS;
char destDuctName[MAX_CL_DUCT_NAME_LEN + 1];
BsspSessionId sessionId;
unsigned char *buffer;
Lyst streams;
Bundle bundleImage;
char *dictionary = 0;
unsigned int bundleLength;
if (ductName == NULL)
{
PUTS("Usage: bsspclo [-]<destination engine number>");
return 0;
}
if (bpAttach() < 0)
{
putErrmsg("bsspclo can't attach to BP.", NULL);
return -1;
}
sdr = getIonsdr();
findOutduct("bssp", ductName, &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such bssp duct.", ductName);
return -1;
}
if (vduct->cloPid != ERROR && vduct->cloPid != sm_TaskIdSelf())
{
putErrmsg("BSSPCLO task is already started for this duct.",
itoa(vduct->cloPid));
return -1;
}
/* All command-line arguments are now validated. */
buffer = (unsigned char *) MTAKE(BP_MAX_BLOCK_SIZE);
if (buffer == NULL)
{
putErrmsg("Can't get buffer for decoding bundle ZCOs.", NULL);
return -1;
}
streams = lyst_create_using(getIonMemoryMgr());
if (streams == NULL)
{
putErrmsg("Can't create lyst of streams.", NULL);
MRELEASE(buffer);
return -1;
}
lyst_delete_set(streams, eraseStream, NULL);
CHKERR(sdr_begin_xn(sdr));
sdr_read(sdr, (char *) &outduct, sdr_list_data(sdr, vduct->outductElt),
sizeof(Outduct));
sdr_read(sdr, (char *) &protocol, outduct.protocol, sizeof(ClProtocol));
sdr_exit_xn(sdr);
destEngineNbr = strtovast(ductName);
if (protocol.nominalRate == 0)
{
vduct->xmitThrottle.nominalRate = DEFAULT_BSSP_RATE;
}
else
{
vduct->xmitThrottle.nominalRate = protocol.nominalRate;
}
memset((char *) outflows, 0, sizeof outflows);
outflows[0].outboundBundles = outduct.bulkQueue;
outflows[1].outboundBundles = outduct.stdQueue;
outflows[2].outboundBundles = outduct.urgentQueue;
for (i = 0; i < 3; i++)
{
outflows[i].svcFactor = 1 << i;
}
if (bssp_attach() < 0)
{
putErrmsg("bsspclo can't initialize BSSP.", NULL);
lyst_destroy(streams);
MRELEASE(buffer);
return -1;
}
/* Set up signal handling. SIGTERM is shutdown signal. */
oK(bsspcloSemaphore(&(vduct->semaphore)));
isignal(SIGTERM, shutDownClo);
/* Can now begin transmitting to remote duct. */
writeMemo("[i] bsspclo is running.");
while (running && !(sm_SemEnded(bsspcloSemaphore(NULL))))
{
if (bpDequeue(vduct, outflows, &bundleZco, &extendedCOS,
destDuctName, 0, -1) < 0)
{
running = 0; /* Terminate CLO. */
continue;
}
if (bundleZco == 0) /* Interrupted. */
{
continue;
}
if (decodeBundle(sdr, bundleZco, buffer, &bundleImage,
&dictionary, &bundleLength) < 0)
{
putErrmsg("Can't decode bundle ZCO.", NULL);
CHKERR(sdr_begin_xn(sdr));
zco_destroy(sdr, bundleZco);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Failed destroying ZCO.", NULL);
break;
}
continue;
}
switch (bssp_send(destEngineNbr, BpBsspClientId, bundleZco,
isInOrder(streams, &bundleImage), &sessionId))
{
case 0:
putErrmsg("Unable to send this bundle via BSSP.", NULL);
break;
case -1:
putErrmsg("BsspSend failed.", NULL);
running = 0; /* Terminate CLO. */
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
/* Note: bundleZco is destroyed later, when BSSP's
* ExportSession is closed following transmission
* of bundle ZCOs as aggregated into a block. */
}
writeErrmsgMemos();
writeMemo("[i] bsspclo duct has ended.");
lyst_destroy(streams);
MRELEASE(buffer);
ionDetach();
return 0;
}
static void logEvent(PsmPartition trace, int opType, unsigned long
addr, int objectSize, char *msg, char *fileName,
int lineNbr, PsmAddress *eltp)
{
PsmAddress traceHeaderAddress;
TraceHeader *trh;
PsmAddress itemAddr;
TraceItem *item;
int buflen;
PsmAddress elt;
if (eltp)
{
*eltp = 0;
}
traceHeaderAddress = psm_get_root(trace);
trh = (TraceHeader *) psp(trace, traceHeaderAddress);
if (trh == NULL) return;
itemAddr = psm_zalloc(trace, sizeof(TraceItem));
if (itemAddr == 0)
{
discardEvent(trace);
return;
}
item = (TraceItem *) psp(trace, itemAddr);
memset((char *) item, 0, sizeof(TraceItem));
if (msg)
{
buflen = strlen(msg) + 1;
item->msg = psm_zalloc(trace, buflen);
if (item->msg == 0)
{
discardEvent(trace);
return;
}
istrcpy((char *) psp(trace, item->msg), msg, buflen);
}
item->taskId = sm_TaskIdSelf();
item->fileName = findFileName(trace, trh, fileName);
if (item->fileName == 0)
{
return; /* Events are being discarded. */
}
item->lineNbr = lineNbr;
trh->opCount++;
item->opNbr = trh->opCount;
item->opType = opType;
item->objectAddress = addr;
item->objectSize = objectSize;
elt = sm_list_insert_last(trace, trh->log, itemAddr);
if (elt == 0)
{
discardEvent(trace);
return;
}
if (eltp)
{
*eltp = elt;
}
}
int pmqlso(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *mqName = (char *) a1;
uvast remoteEngineId = a2 != 0 ? strtouvast((char *) a2) : 0;
#else
int main(int argc, char *argv[])
{
char *mqName = argc > 1 ? argv[1] : NULL;
uvast remoteEngineId = argc > 2 ? strtouvast(argv[2]) : 0;
#endif
Sdr sdr;
LtpVspan *vspan;
PsmAddress vspanElt;
struct mq_attr mqAttributes = { 0, PMQLSA_MAXMSG, PMQLSA_MSGSIZE, 0 };
mqd_t mq;
int running;
int segmentLength;
char *segment;
if (remoteEngineId == 0 || mqName == NULL)
{
puts("Usage: pmqlso <message queue name> <remote engine ID>");
return 0;
}
/* Note that ltpadmin must be run before the first
* invocation of ltplso, to initialize the LTP database
* (as necessary) and dynamic database. */
if (ltpInit(0) < 0)
{
putErrmsg("pmqlso can't initialize LTP.", NULL);
return 1;
}
sdr = getIonsdr();
CHKERR(sdr_begin_xn(sdr)); /* Just to lock memory. */
findSpan(remoteEngineId, &vspan, &vspanElt);
if (vspanElt == 0)
{
sdr_exit_xn(sdr);
putErrmsg("No such engine in database.", itoa(remoteEngineId));
return 1;
}
if (vspan->lsoPid > 0 && vspan->lsoPid != sm_TaskIdSelf())
{
sdr_exit_xn(sdr);
putErrmsg("LSO task is already started for this span.",
itoa(vspan->lsoPid));
return 1;
}
/* All command-line arguments are now validated. */
sdr_exit_xn(sdr);
mq = mq_open(mqName, O_RDWR | O_CREAT, 0777, &mqAttributes);
if (mq == (mqd_t) -1)
{
putSysErrmsg("pmqlso can't open message queue", mqName);
return 1;
}
oK(_pmqlsoSemaphore(&vspan->segSemaphore));
isignal(SIGTERM, interruptThread);
/* Can now begin transmitting to remote engine. */
writeMemo("[i] pmqlso is running.");
running = 1;
while (running && !(sm_SemEnded(_pmqlsoSemaphore(NULL))))
{
segmentLength = ltpDequeueOutboundSegment(vspan, &segment);
if (segmentLength < 0)
{
running = 0; /* Terminate LSO. */
continue;
}
if (segmentLength == 0) /* Interrupted. */
{
continue;
}
if (segmentLength > PMQLSA_MSGSIZE)
{
putErrmsg("Segment is too big for PMQ LSO.",
itoa(segmentLength));
running = 0; /* Terminate LSO. */
continue;
}
if (sendSegmentByPMQ(mq, segment, segmentLength) < 0)
{
putSysErrmsg("pmqlso failed sending segment", mqName);
running = 0; /* Terminate LSO. */
continue;
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
mq_close(mq);
writeErrmsgMemos();
writeMemo("[i] pmqlso duct has ended.");
ionDetach();
return 0;
}
int pmqlsi(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *mqName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *mqName = (argc > 1 ? argv[1] : NULL);
#endif
LtpVdb *vdb;
struct mq_attr mqAttributes =
{ 0, PMQLSA_MAXMSG, PMQLSA_MSGSIZE, 0 };
ReceiverThreadParms rtp;
pthread_t receiverThread;
char stop = '0';
if (mqName == NULL)
{
puts("Usage: pmqlsi <message queue name>");
return 0;
}
/* Note that ltpadmin must be run before the first
* invocation of ltplsi, to initialize the LTP database
* (as necessary) and dynamic database. */
if (ltpInit(0, 0) < 0)
{
putErrmsg("pmqlsi can't initialize LTP.", NULL);
return 1;
}
vdb = getLtpVdb();
if (vdb->lsiPid > 0 && vdb->lsiPid != sm_TaskIdSelf())
{
putErrmsg("LSI task is already started.", itoa(vdb->lsiPid));
return 1;
}
/* All command-line arguments are now validated. */
rtp.mq = mq_open(mqName, O_RDWR | O_CREAT, 0777, &mqAttributes);
if (rtp.mq == (mqd_t) -1)
{
putSysErrmsg("pmglsi can't open message queue", mqName);
return 1;
}
/* Set up signal handling; SIGTERM is shutdown signal. */
isignal(SIGTERM, interruptThread);
/* Start the receiver thread. */
rtp.running = 1;
rtp.mainThread = pthread_self();
if (pthread_create(&receiverThread, NULL, handleMessages, &rtp))
{
mq_close(rtp.mq);
putSysErrmsg("pmqlsi can't create receiver thread", NULL);
return 1;
}
/* Now sleep until interrupted by SIGTERM, at which point
* it's time to stop the link service. */
writeMemo("[i] pmqlsi is running");
snooze(2000000000);
/* Time to shut down. */
rtp.running = 0;
mq_send(rtp.mq, &stop, 1, 0); /* Tell receiver to stop. */
pthread_join(receiverThread, NULL);
mq_close(rtp.mq);
writeErrmsgMemos();
writeMemo("[i] pmqlsi duct has ended.");
return 0;
}
int stcpclo(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ductName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *ductName = (argc > 1 ? argv[1] : NULL);
#endif
unsigned char *buffer;
VOutduct *vduct;
PsmAddress vductElt;
Sdr sdr;
Outduct duct;
ClProtocol protocol;
Outflow outflows[3];
int i;
char *hostName;
unsigned short portNbr;
unsigned int hostNbr;
struct sockaddr socketName;
struct sockaddr_in *inetName;
int running = 1;
pthread_mutex_t mutex;
KeepaliveThreadParms parms;
pthread_t keepaliveThread;
Object bundleZco;
BpExtendedCOS extendedCOS;
char destDuctName[MAX_CL_DUCT_NAME_LEN + 1];
unsigned int bundleLength;
int ductSocket = -1;
int bytesSent;
if (ductName == NULL)
{
PUTS("Usage: stcpclo <remote host name>[:<port number>]");
return 0;
}
if (bpAttach() < 0)
{
putErrmsg("stcpclo can't attach to BP.", NULL);
return -1;
}
buffer = MTAKE(TCPCLA_BUFSZ);
if (buffer == NULL)
{
putErrmsg("No memory for TCP buffer in stcpclo.", NULL);
return -1;
}
findOutduct("stcp", ductName, &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such stcp duct.", ductName);
MRELEASE(buffer);
return -1;
}
if (vduct->cloPid > 0 && vduct->cloPid != sm_TaskIdSelf())
{
putErrmsg("CLO task is already started for this duct.",
itoa(vduct->cloPid));
MRELEASE(buffer);
return -1;
}
/* All command-line arguments are now validated. */
sdr = getIonsdr();
sdr_read(sdr, (char *) &duct, sdr_list_data(sdr, vduct->outductElt),
sizeof(Outduct));
sdr_read(sdr, (char *) &protocol, duct.protocol, sizeof(ClProtocol));
if (protocol.nominalRate <= 0)
{
vduct->xmitThrottle.nominalRate = DEFAULT_TCP_RATE;
}
else
{
vduct->xmitThrottle.nominalRate = protocol.nominalRate;
}
memset((char *) outflows, 0, sizeof outflows);
outflows[0].outboundBundles = duct.bulkQueue;
outflows[1].outboundBundles = duct.stdQueue;
outflows[2].outboundBundles = duct.urgentQueue;
for (i = 0; i < 3; i++)
{
outflows[i].svcFactor = 1 << i;
}
hostName = ductName;
parseSocketSpec(ductName, &portNbr, &hostNbr);
if (portNbr == 0)
{
portNbr = BpTcpDefaultPortNbr;
}
portNbr = htons(portNbr);
if (hostNbr == 0)
{
putErrmsg("Can't get IP address for host.", hostName);
MRELEASE(buffer);
return -1;
}
hostNbr = htonl(hostNbr);
memset((char *) &socketName, 0, sizeof socketName);
inetName = (struct sockaddr_in *) &socketName;
inetName->sin_family = AF_INET;
inetName->sin_port = portNbr;
memcpy((char *) &(inetName->sin_addr.s_addr), (char *) &hostNbr, 4);
/* Set up signal handling. SIGTERM is shutdown signal. */
oK(stcpcloSemaphore(&(vduct->semaphore)));
isignal(SIGTERM, shutDownClo);
isignal(SIGPIPE, handleConnectionLoss);
/* Start the keepalive thread for the eventual connection. */
parms.cloRunning = &running;
pthread_mutex_init(&mutex, NULL);
parms.mutex = &mutex;
parms.socketName = &socketName;
parms.ductSocket = &ductSocket;
if (pthread_create(&keepaliveThread, NULL, sendKeepalives, &parms))
{
putSysErrmsg("stcpclo can't create keepalive thread", NULL);
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
return 1;
}
/* Can now begin transmitting to remote duct. */
writeMemo("[i] stcpclo is running.");
while (!(sm_SemEnded(stcpcloSemaphore(NULL))))
{
if (bpDequeue(vduct, outflows, &bundleZco, &extendedCOS,
destDuctName) < 0)
{
sm_SemEnd(stcpcloSemaphore(NULL));/* Stop. */
continue;
}
if (bundleZco == 0) /* Interrupted. */
{
continue;
}
bundleLength = zco_length(sdr, bundleZco);
pthread_mutex_lock(&mutex);
bytesSent = sendBundleByTCP(&socketName, &ductSocket,
bundleLength, bundleZco, buffer);
pthread_mutex_unlock(&mutex);
if (bytesSent < bundleLength)
{
sm_SemEnd(stcpcloSemaphore(NULL));/* Stop. */
continue;
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
running = 0; /* Terminate keepalive. */
pthread_join(keepaliveThread, NULL);
if (ductSocket != -1)
{
close(ductSocket);
}
pthread_mutex_destroy(&mutex);
writeErrmsgMemos();
writeMemo("[i] stcpclo duct has ended.");
MRELEASE(buffer);
ionDetach();
return 0;
}