*DECK IPPSEND
USETEXT TEXTIPL
USETEXT TEXTXDR
PROC IPPSEND (SOCKID, BUFFER1, BUFLEN1, BUFFER2, BUFLEN2,
ADDRESS, SOCKSTATUS);
*CALL COPYRITE CDCNET - COPYRIGHT CONTROL DATA. 1992.
# TITLE IPPSEND - SEND DATA FROM A SOCKET #
BEGIN # IPPSEND #
#
**** IPPSEND SEND DATA FROM A SOCKET
*
* THIS PROCEDURE SENDS A BLOCK OF DATA FROM THE SOCKET *SOCKID*
* TO THE HOST AT *ADDRESS*.
*
* PROC IPPSEND
*
* ENTRY SOCKID = INTEGER VALUE OF SOCKET
* BUFFER1 = FIRST BUFFER WHICH CONTAINS THE DATA TO SEND
* BUFLEN1 = NUMBER OF BYTES IN *BUFFER1* TO SEND
* BUFFER2 = SECOND BUFFER WHICH CONTAINS THE DATA TO SEND
* BUFLEN2 = NUMBER OF BYTES IN *BUFFER2* TO SEND
* ADDRESS = 4 WORD DESTINATION IP ADDRESS ARRAY
*
* EXIT SOCKSTATUS = COMPLETION STATUS
*
* METHOD IF THE SOCKET HAS BEEN ABORTED BY NAM, RETURN AN
* ABORT STATUS TO INFORM THE CALLER. IF THE SOCKET
* IS NOT CONNECTED, RETURN AN ERROR STATUS. IF THE
* APPLICATION BLOCK LIMIT HAS NOT BEEN REACHED, SET UP
* THE UDP CALL BLOCK HEADER AND COPY THE CONTENTS OF
* *BUFFER1* AND *BUFFER2* INTO THE DATA BLOCK AND SEND
* THE BLOCK TO NAM.
* IF THE APPLICATION BLOCK LIMIT HAS BEEN REACHED, CALL THE
* NAM INPUT TRAFFIC HANDLER WAITING FOR THE OUTSTANDING
* BLOCK COUNT TO FALL BELOW THE LIMIT OR FOR THE BLOCKING
* WAIT TIMER TO EXPIRE.
* IF NOT BLOCKING, CALL THE NAM INPUT TRAFFIC HANDLER
* ONCE. IF THE DATA BLOCK CAN NOT BE SENT, SET THE STATUS
* TO *FLOWCTRL* TO INDICATE THE BLOCK WAS NOT SENT.
#
#
**** PROC IPPSEND - XREF LIST
#
XREF
BEGIN
PROC IMNS; # MOVE NON-OVERLAPPING STRING #
PROC IPINITH; # NAM INPUT TRAFFIC HANDLER #
PROC NETPUT; # SEND OUTPUT BUFFER TO NETWORK #
PROC RTIME; # REAL TIME CLOCK #
PROC XDRBYTE; # CONVERT BYTES TO XDR FORMAT #
PROC XDRINT; # CONVERT INTEGERS TO XDR FORMAT #
END
#
**
#
ITEM SOCKID I; # SOCKET IDENTIFIER #
ARRAY BUFFER1 [00:00] S(1);; # OUTPUT BUFFER TO SEND #
ITEM BUFLEN1 U; # LENGTH OF DATA IN *BUFFER1* #
ARRAY BUFFER2 [00:00] S(1);; # SECOND OUTPUT BUFFER TO SEND #
ITEM BUFLEN2 U; # LENGTH OF DATA IN *BUFFER2* #
ARRAY ADDRESS [00:00] S(1);; # SOURCE ADDRESS FOR DATA #
ITEM SOCKSTATUS S:SOCKSTAT; # RETURNED SOCKET STATUS #
ITEM BUFPOS U; # OFFSET IN *OUTBUF* #
ITEM DESTBUF I; # CURRENT WRD LOCATION IN BUFFER#
ITEM DESTPOS U; # BIT OFFSET IN BUFFER WORD #
ITEM INDEX I; # LOOP COUNTER #
ITEM LOOP I; # LOOP COUNTER #
ITEM MOVEBITS U; # BITS TO MOVE TO *BUFFER* #
ITEM SCRBUF U; # CURRENT LOCATION INP$BUF #
ITEM SCRPOS U; # BIT OFFSET IN INP$BUF WORD #
ITEM WAITLOOP I; # NUMBER OF WAIT CYCLES #
ITEM WRITENUM I; # NUMBER OF XDR ITEMS TO WRITE #
CONTROL EJECT;
#
**** START MAIN PROCEDURE
#
IF (ACN$ABORT [SOCKID])
THEN
BEGIN # CONNECTION ABORTED #
SOCKSTATUS = S"ABORT";
RETURN;
END
IF ACN$STATE [SOCKID] NQ S"BOUND"
THEN
BEGIN
SOCKSTATUS = SOCKSTAT"INVALIDST";
RETURN;
END
IF (ACN$OBC [SOCKID] GQ ACN$ABL [SOCKID])
THEN
BEGIN # MAXIMUM OUTSTANDING BLOCK LMT #
BLOCK = ACN$BLOCK [SOCKID]; # SET GLOBAL BLOCKING FLAG #
IF BLOCK
THEN
BEGIN # WAIT FOR FC/ACK ON CONNECTION #
WAITLOOP = ACN$WAITIME [SOCKID] / 2 + 1;
RTIME (BWT$TIME); # CURRENT TIME #
BWT$EXPIRE [0] = BWT$SECONDS [0] + ACN$WAITIME [SOCKID];
#
**** CONTINUE POLLING THE NETWORK WAITING FOR FC/ACK SUPERVISORY
* MESSAGES TO BE RECEIVED ON THE CONNECTION OR UNTIL THE WAIT TIMER
* HAS EXPIRED. THE LOOP COUNTERIS SETTO THE WAIT TIME/2 DUE TO THE
* NETWAIT TIME OF 2 SECONDS WHILE BLOCKING.
#
FOR LOOP = 0
WHILE (ACN$OBC [SOCKID] GQ ACN$ABL [SOCKID])
DO
BEGIN # WAIT FOR ACK OR EXPIRED TIME #
FOR INDEX = 1 STEP 1
WHILE (ACN$OBC [SOCKID] GQ ACN$ABL [SOCKID]) AND
(NOT ACN$ABORT [SOCKID]) AND
(INDEX LQ WAITLOOP)
DO
BEGIN
IPINITH; # NAM INPUT TRAFFIC HANDLER #
END
IF (ACN$ABORT [SOCKID])
THEN
BEGIN # CONNECTION ABORTED #
SOCKSTATUS = S"ABORT";
RETURN;
END
IF (ACN$OBC [SOCKID] GQ ACN$ABL [SOCKID])
THEN
BEGIN # CHECK IF TIMED OUT #
RTIME (BWT$TIME);
IF (BWT$SECONDS [0] GQ BWT$EXPIRE [0])
THEN
BEGIN # TIMER EXPIRED #
SOCKSTATUS = S"FLOWCTRL";
RETURN;
END
ELSE
BEGIN # TIME STILL TO WAIT #
WAITLOOP = (BWT$EXPIRE [0] -
BWT$SECONDS [0]) / 2 + 1;
END
END # CHECK IF TIMED OUT #
END # WAIT FOR ACK OR EXPIRED TIME #
END # WAIT FOR FC/ACK ON CONNECTION #
ELSE
BEGIN # NO ACK/NOT BLOCKING #
IPINITH; # NAM INPUT TRAFFIC HANDLER #
IF (ACN$ABORT [SOCKID])
THEN
BEGIN # CONNECTION ABORTED #
SOCKSTATUS = S"ABORT";
RETURN;
END
IF (ACN$OBC [SOCKID] GQ ACN$ABL [SOCKID])
THEN
BEGIN
SOCKSTATUS = S"FLOWCTRL";
RETURN;
END
END # NO ACK/NOT BLOCKING #
END # DATA NOT AVAILABLE #
#
**** DATA CAN BE SENT. PLACE THE UDP CALL HEADER INTO *OUTBUF*. THE
* REQUEST CONSISTS OF THE CALL TYPE, UDP VERSION, AND FOUR 32 BIT
* INTEGER ADDRESS. FOLLOWING THE ADDRESS THE CONTENTS OF *BUFFER*
* ARE MOVED INTO *OUTBUF*. IF THE BLOCK TO BE TRANSMITTED IS
* GREATER THAN *INPSIZE$* THEN AN ERROR STATUS IS RETURNED.
#
BUFPOS = 0; # INITIALIZE BUFFER POSITION #
P<IP$ADDR$REC> = LOC (ADDRESS);
UDP$HEADER [0] = DESTREQ$;
WRITENUM = 2;
XDRBYTE (OUTBUF, BUFPOS, UDP$HEAD$REC, WRITENUM, XDROPER"WRITE");
WRITENUM = 4;
XDRINT (OUTBUF, BUFPOS, IP$ADDR$REC, WRITENUM, XDROPER"WRITE");
P<ABH> =
LOC (DABH
); # BASE ABH POINTER # ABHTLC [0] = BUFPOS + BUFLEN1 + BUFLEN2;# STORE LENGTH IN BYTES #
IF ((ABHTLC [0] * 2) / 15) GR INPSIZE$
THEN
BEGIN # *OUTBUF* TOO SMALL FOR DATA #
SOCKSTATUS = S"REQFAIL";
RETURN;
END # *OUTBUF* TOO SMALL FOR DATA #
IF BUFLEN1 GR 0
THEN
BEGIN
MOVEBITS = BUFLEN1 * 8;
DESTBUF = LOC (OUTBUF) + (BUFPOS * 2) / 15;
DESTPOS = XDRMODU ((BUFPOS * 8), 60);# WORD BIT OFFSET #
SCRBUF = LOC (BUFFER1);
SCRPOS = 0;
IMNS (MOVEBITS, SCRBUF, SCRPOS, DESTBUF, DESTPOS);
IF BUFLEN2 GR 0
THEN
BEGIN
SCRBUF = LOC (BUFFER2);
SCRPOS = 0;
MOVEBITS = BUFLEN2 * 8;
IMNS (MOVEBITS, SCRBUF, SCRPOS, DESTBUF, DESTPOS);
END
END
ABHADR [0] = SOCKID; # STORE CONNECTION NUMBER #
ABHABN [0] = ACN$ABN [SOCKID]; # STORE APPLICATION BLOCK NUMBER#
ACN$ABN [SOCKID] = ACN$ABN [SOCKID] + 1;
ACN$OBC [SOCKID] = ACN$OBC [SOCKID] + 1;
NETPUT (DABH, OUTBUF); # SEND THE REQUEST #
SOCKSTATUS = S"OK";
RETURN; # RETURN TO CALLER #
END # IPPSEND #
TERM