Project

General

Profile

Wiki » Documentation » Conversion Reference »

Sockets

The below examples will illustrate server/client socket connections.

Server Sockets

This server socket procedure (with pertinent converted Java within) illustrates the use of:
  • CREATE SERVER-SOCKET
  • SET-CONNECT-PROCEDURE(), ENABLE-CONNECTIONS(), DISABLE-CONNECTIONS(), CONNECT event (e.g. WAIT-FOR CONNECT of <server-socket-handle>)
  • READ()/WRITE() and READ-RESPONSE event (e.g. WAIT-FOR READ-RESPONSE of <socket-handle>)
DEFINE VARIABLE serverSocket AS HANDLE.
DEFINE VARIABLE aOk AS LOGICAL.
DEFINE VARIABLE serverWriteBuffer AS MEMPTR.
DEFINE VARIABLE serverReadBuffer AS MEMPTR.
DEFINE VARIABLE serverMessage AS CHAR.
MESSAGE "We are in the socket server".

CREATE SERVER-SOCKET serverSocket.
/* Marshal data to write */
SET-SIZE(serverWriteBuffer) = 64.
SET-SIZE(serverReadBuffer) = 64.
serverMessage = "SERVER - hello".
PUT-STRING(serverWriteBuffer,1) = serverMessage.
MESSAGE "Start event handling".
serverSocket:SET-CONNECT-PROCEDURE( "connProc").
aOk = serverSocket:ENABLE-CONNECTIONS( "-S 3363").

MESSAGE "Enabled connections:" aOk.
IF NOT aOk THEN
RETURN.

/* This WAIT-FOR completes after the first connection */
WAIT-FOR CONNECT OF serverSocket.
MESSAGE "FIRST CONNECTION RECEIVED".

serverSocket:DISABLE-CONNECTIONS().
DELETE OBJECT serverSocket.
MESSAGE "Finished".


         message("We are in the socket server");
         SocketFactory.createServerSocket(serverSocket);
         /* Marshal data to write */
         serverWriteBuffer.setLength(64);
         serverReadBuffer.setLength(64);
         serverMessage.assign("SERVER - hello");
         serverWriteBuffer.setString(serverMessage, 1);
         message("Start event handling");
         serverSocket.unwrapSocketListener().setConnectProcedure("connProc");
         aOk.assign(serverSocket.unwrapSocketListener().enableConnections("-S 3363"));

         /* This WAIT-FOR completes after the first connection */
         LogicalTerminal.waitFor(null, new EventList("CONNECT", serverSocket));
         message("FIRST CONNECTION RECEIVED");
         serverSocket.unwrapSocketListener().disableConnections();
         HandleOps.delete(serverSocket);
         message("Finished");


/* Connection procedure for server socket */
PROCEDURE connProc.
   /*Socket recieved as parameter*/
   DEFINE INPUT PARAMETER hSocket AS HANDLE. 
   MESSAGE "We are in CONNECT event procedure, connProc".
   hSocket:WRITE (serverWriteBuffer, 1, LENGTH(serverMessage)).
   MESSAGE hSocket:BYTES-WRITTEN "bytes written".
   /* Wait for response from client */
   WAIT-FOR READ-RESPONSE OF hSocket.
   hsocket:READ(serverReadBuffer,1,hsocket:GET-BYTES-AVAILABLE()).
   DEFINE VARIABLE clientMessage AS CHAR.
   clientMessage = GET-STRING(serverReadBuffer,1).
   DISPLAY clientMessage FORMAT "x(64)".
END.


   /** Connection procedure for server socket */
   /**
    * Socket recieved as parameter
    */
   public void connProc(final handle _hSocket)
   {
      ServerSocketFrame0 frame0 = GenericFrame.createFrame(ServerSocketFrame0.class, "");
      handle hSocket = UndoableFactory.initInput(_hSocket);
      character clientMessage = UndoableFactory.character();

      internalProcedure(new Block((Body) () -> 
      {
         frame0.openScope();
         message("We are in CONNECT event procedure, connProc");
         hSocket.unwrapSocket().write(serverWriteBuffer, 1, length(serverMessage));
         message(new Object[]
         {
            hSocket.unwrapSocket().getBytesWritten(),
            "bytes written" 
         });

         /* Wait for response from client */
         LogicalTerminal.waitFor(null, new EventList("READ-RESPONSE", hSocket));
         hSocket.unwrapSocket().read(serverReadBuffer, 1, hSocket.unwrapSocket().getBytesAvailable());
         clientMessage.assign(serverReadBuffer.getString(1));

         FrameElement[] elementList0 = new FrameElement[]
         {
            new Element(clientMessage, frame0.widgetClientMessage())
         };

         frame0.display(elementList0);
      }));
   }

Client Sockets

This client socket procedure (with pertinent converted Java within) illustrates the use of:
  • CREATE SOCKET
  • CONNECT(), DISCONNECT()
  • SET-READ-RESPONSE-PROCEDURE(), READ-RESPONSE event (e.g. WAIT-FOR READ-RESPONSE of <socket-handle>)
  • READ()/WRITE()
DEFINE VARIABLE clientSocket AS HANDLE.
DEFINE VARIABLE acknowledge AS LOGICAL.
DEFINE VARIABLE clientReadBuffer AS MEMPTR.
DEFINE VARIABLE clientWriteBuffer AS MEMPTR.
DEFINE VARIABLE cString AS CHARACTER.
DEFINE VARIABLE clientMessage AS CHARACTER.
define variable myhost as CHARACTER init "localhost".
assign myhost = "192.168.40.226".
MESSAGE "We are in socket client:" myhost.

CREATE SOCKET clientSocket.
clientSocket:CONNECT ("-H " + myhost + " -S 3363").
IF clientSocket:CONNECTED() THEN
   MESSAGE "Connected OK".
ELSE DO:
   MESSAGE "Could not connect".
   RETURN.
END.

/* Do READ-RESPONSE event handling */
MESSAGE "Start event handling".
clientSocket:SET-READ-RESPONSE-PROCEDURE( "readProc").
/* This WAIT-FOR completes after the first data reception */
WAIT-FOR READ-RESPONSE OF clientSocket.

MESSAGE "Freeing up resources".
clientSocket:DISCONNECT().
DELETE OBJECT clientSocket.
MESSAGE "Finished".


         myhost.assign("192.168.40.226");
         message(new Object[]
         {
            "We are in socket client:",
            myhost
         });
         SocketFactory.createSocket(clientSocket);
         clientSocket.unwrapConnectable().connect(concat("-H ", myhost, " -S 3363"));

         if ((clientSocket.unwrapConnectable().connected()).booleanValue())
         {
            message("Connected OK");
         }
         else
         {
            message("Could not connect");
            returnNormal();
         }

         /* Do READ-RESPONSE event handling */
         message("Start event handling");
         clientSocket.unwrapSocket().setReadResponseProcedure("readProc");

         /* This WAIT-FOR completes after the first data reception */
         LogicalTerminal.waitFor(null, new EventList("READ-RESPONSE", clientSocket));
         message("Freeing up resources");
         clientSocket.unwrapConnectable().disconnect();
         HandleOps.delete(clientSocket);
         message("Finished");


/* Read procedure for socket */
PROCEDURE readProc.
   DEFINE VARIABLE clientReadBuffer AS MEMPTR.
   MESSAGE "We are in READ-RESPONSE event procedure, readProc".
   SET-SIZE(clientReadBuffer) = 64.
   SET-SIZE(clientWriteBuffer) = 64.
   clientSocket:READ(clientReadBuffer,1,clientSocket:GET-BYTES-AVAILABLE()).

   /*In the socket procedure SELF will point to the handle of the socket for
   which this procedure is set */
   MESSAGE clientSocket:BYTES-READ "bytes read".
   /*Unmarshal data*/
   cString = GET-STRING(clientReadBuffer,1).
   DISPLAY cString FORMAT "x(64)".
   /* send data to server*/
   MESSAGE "send back data to the server".
   clientMessage = "Client - hi".
   PUT-STRING(clientWriteBuffer,1) = clientMessage. 
   clientSocket:WRITE (clientWriteBuffer,1,LENGTH(clientMessage)).
END PROCEDURE.


   public void readProc()
   {
      ClientSocketFrame0 frame0 = GenericFrame.createFrame(ClientSocketFrame0.class, "");
      memptr clientReadBuffer_1 = UndoableFactory.memptr();

      internalProcedure(new Block((Body) () -> 
      {
         frame0.openScope();
         message("We are in READ-RESPONSE event procedure, readProc");
         clientReadBuffer_1.setLength(64);
         clientWriteBuffer.setLength(64);
         clientSocket.unwrapSocket().read(clientReadBuffer_1, 1, clientSocket.unwrapSocket().getBytesAvailable());
         /*In the socket procedure SELF will point to the handle of the socket for
            which this procedure is set */
         message(new Object[]
         {
            clientSocket.unwrapSocket().getBytesRead(),
            "bytes read" 
         });
         /*Unmarshal data*/
         cString.assign(clientReadBuffer_1.getString(1));

         FrameElement[] elementList0 = new FrameElement[]
         {
            new Element(cString, frame0.widgetCString())
         };

         frame0.display(elementList0);

         /* send data to server*/
         message("send back data to the server");
         clientMessage.assign("Client - hi");
         clientWriteBuffer.setString(clientMessage, 1);
         clientSocket.unwrapSocket().write(clientWriteBuffer, 1, length(clientMessage));
      }));
   }

© 2004-2022 Golden Code Development Corporation. ALL RIGHTS RESERVED.