/* Send a 5K string to the client. Assume mystring contains 5K of chars */
SockSend(client, mystring)

myreturn = myscript.rex(myarg)

/* ServerSelect.rex
 *
 * Demonstrates an example of a server using RxSock 1.8
 * with Reginald REXX interpreter.
 *
 * This script runs on a server and waits for a client
 * to connect. When a client connects to the server,
 * then the server launches a child script named
 * HandleMe.rex as a separate, asynchronous process to
 * manage that client.
 */

/* Make things easy for us with WINFUNC option */
OPTIONS "WINFUNC NOSOURCE"

/* Register all RXSOCK functions */
LIBRARY rxsock

/* Register CreateProcess() */
process_info = "32u,32u,32u,32u"
startup_info = "32u,32u,32u,32u,32u,32u,32u,32u,32u,32u,32u,32u,16u,16u,32u,32u,32u,32u"
FUNCDEF('CreateProcess', '32u, str, str, 32u, 32u, 32u, 32u, 32u, str, struct STARTUP_INFO, struct PROCESS_INFO stor', 'kernel32')

/* Tell RXSOCK that we want it to raise USER 10 condition for any
 * error (besides SYNTAX errors of course). We also want SockErrNo
 * set (instead of ErrNo)
 */
SockInit(10, 1)

DO

/* Fill in a sockaddr_in struct which we pass to SockSocket */
server.!family = "AF_INET" /* Must be AF_INET since RxSock supports only that */
server.!addr = "INADDR_ANY"  /* Let RxSock fill in the local computer's address */
server.!port = 20248   /* This is the port we use to communicate. The client must use the same port # */

/* Get a socket (of type SOCK_STREAM, and using TCP/IP networking protocol)
 * and bind it to the above port/address. Set it into "listening for
 * connections from clients" mode, and allow 5 clients to wait for
 * us to call SockAccept.
 */
server = SockSocket(, , , 'server.!', 5)
SAY "Socket created and waiting for connections from clients..."

moreclients:
/* SockAccept() will wait for and accept an incoming client connection
 * and return that client's socket
 */
client = SockAccept(server, 'client.!')

/* We got a client connecting */
SAY "Client connected from address" client.!addr

/* Get the Berkeley socket from what SockAccept() returned */
berkeley = sockgethandle(client, 'B')

/* Launch HandleMe.rex as a separate process. Pass it the
 * Berkeley socket
 */

/* Here we launch a child script named "HandleMe.rex". We launch
 * it by calling CreateProcess() and let it inherit any handles
 * we have open. We need to invoke the Reginald Script Launcher
 * which is RXLAUNCH.EXE. Note that we may need to supply the
 * full path in order for Windows to find it, and also we double
 * quote that path if it has spaces in it.
 *
 * After RXLAUNCH.EXE, we list the name of the rexx script to
 * run. Anything you add to this string after the script name
 * are comma-delimited arguments that will get passed to the
 * child script. For example, here we pass the arg "Berkeley"
 * to the child script.
 *
 * If CreateProcess() succeeds, it returns a 1. If it
 * fails, then it returns 0.
 */

startup_info. = 0
startup_info.1 = 68
result = createprocess(, '"E:\Program files\Reginald\RxLaunch.exe" HandleMe.rex' berkeley, , , 1, 8, , , startup_info, process_info)
IF result == 0 THEN SAY "Failed to run."

/* Close the client socket (but don't tell it we're closing its connection).
 * NOTE: I believe that both this script, and HandleMe.rex, will need
 * to do a SockClose on the handle. But I'm not absolutely sure of
 * this. If there is a problem, first try putting a Sleep() before
 * this call, and if worse comes to worse, comment it out.
 */
SockClose(client, 1)

/* At this point we loop around to SockAccept to wait for another
 * client to connect.
 */
SIGNAL moreclients

CATCH user 10
/* We told RXSOCK to raise the USER 10 condition if there is
 * ever any error (other than a SYNTAX error). So we CATCH
 * USER 10, and  REXX jumps here if it is raised.
 * So, if we're here, then some RXSOCK function has had an
 * error.
 *
 * CONDITION('D') reports the name of the RXSOCK function that
 * had the error. SIGL is the line number in our script where
 * we had the error. The variable named "SockErrNo" is set to an
 * RXSOCK "error name" such as "EINPROGRESS" or "ENETDOWN" etc.
 * We can pass this variable to the RXSOCK function SockErrMsg()
 * to get an appropriate error message or call SockPSock_Errno
 * to display a message box.
 */
 SockPSock_Errno()

FINALLY
  /* Close any open socket. NOTE: RxSock doesn't mind if you try
   * to close a socket that was never opened
   */
  SockClose(server)
  SAY "Socket closed"

END

RETURN

LIBRARY rxsock

SockInit(10, 1)

DO

/* Get the Berkeley socket passed to us and create an RXSOCK socket */
berkeley = ARG(1)
client = sockgethandle(berkeley)

/* Now you can SockSend and SockRecv with the client handle */

CATCH user 10
   SockPSock_Errno()

FINALLY
  /* When done, close the client socket (and tell it we're closing
   * its connection)
   */
  SockClose(client, 1)

END

RETURN