GMSock.h File Reference

#include "GreenSock.h"

Include dependency graph for GMSock.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	cfSockCommand (int crate_number, int command_type, int command, int req_param, int req_param_2, char *reply, char *msg)
int	GreenSockCommand (int crate_number, struct greenRequest *gRequest)
int	cfSockCliOpen (int crate_number, int keepopen)
int	cfSockCliSend (int crate_number, struct request *myRequest, struct request *serverReply)
int	cfSockCliClose ()

Function Documentation

cfSockCliClose()

int cfSockCliClose

(

)

Definition at line 234 of file cfSockCli.c.

{
  gSocketKeepOpen = 0;
  close (gSocketFd);
  /*  printf("cfSockCliClose: gSocketKeepOpen=%d\n", gSocketKeepOpen); */
  return (SOCK_OK);
}

References gSocketFd, gSocketKeepOpen, and SOCK_OK.

Referenced by cfSockCli().

Here is the caller graph for this function:

cfSockCliOpen()

int cfSockCliOpen	(	int	crate_number,
		int	keepopen )

Definition at line 84 of file cfSockCli.c.

                                                   {
  struct sockaddr_in  serverAddr;    /* server's socket address */
  int                 sockAddrSize;  /* size of socket address structure */
  char optval;
  char * servername;
 
  /*  printf("cfSockCliOpen: gSocketKeepOpen=%d; keepopen=%d\n",
      gSocketKeepOpen, keepopen);
  */
 
  gSocketKeepOpen = 0;
  /* create client's socket */
  switch (crate_number) {
  case Crate_CountingHouse:
    servername = ServerName_CountingHouse;
    break;
     case Crate_LeftSpect:
    servername = ServerName_LeftSpect;
    break;
  case Crate_RightSpect:
    servername = ServerName_RightSpect;
    break;
  case Crate_Injector:
    servername = ServerName_Injector;
    break;
  case Crate_Qwvmets:
    servername = ServerName_QwTSCrate;
    break;
 
  default:
    return (SOCK_ERROR);
  }
 
  if ((gSocketFd = socket (PF_INET, SOCK_STREAM, 0)) == SOCK_ERROR)
    {
      perror ("socket");
      return (SOCK_ERROR);
    }
 
  optval = 1;
  int test = 0;
  test = setsockopt ( gSocketFd, IPPROTO_TCP, TCP_NODELAY,
           (char *) &optval,
           4 ); /* black magic from Chowdhary's code */
 
 
  test = setsockopt(gSocketFd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
 
  /* bind not required - port number is dynamic */
    /* build server socket address */
 
  sockAddrSize = sizeof (struct sockaddr_in);
  bzero ((char *) &serverAddr, sockAddrSize);
  serverAddr.sin_family = PF_INET;
  serverAddr.sin_port = htons (SERVER_PORT_NUM);
 
  if ((serverAddr.sin_addr.s_addr = inet_addr (servername)) == SOCK_ERROR)
    {
      perror ("unknown server name");
      close (gSocketFd);
      return (SOCK_ERROR);
    }
 
  /* connect to server */
  if (connect (gSocketFd, (struct sockaddr *) &serverAddr, sockAddrSize) == SOCK_ERROR)
    {
      perror ("connect");
      close (gSocketFd);
      return (SOCK_ERROR);
    }
  gSocketKeepOpen = keepopen;
  return (SOCK_OK);
};

References Crate_CountingHouse, Crate_Injector, Crate_LeftSpect, Crate_Qwvmets, Crate_RightSpect, gSocketFd, gSocketKeepOpen, SERVER_PORT_NUM, ServerName_CountingHouse, ServerName_Injector, ServerName_LeftSpect, ServerName_QwTSCrate, ServerName_RightSpect, SOCK_ERROR, and SOCK_OK.

Referenced by cfSockCli().

Here is the caller graph for this function:

cfSockCliSend()

int cfSockCliSend	(	int	crate_number,
		struct request *	myRequest,
		struct request *	serverReply )

Definition at line 158 of file cfSockCli.c.

{
  int  nWrite;
  int i, j;
  int keepopen = gSocketKeepOpen;
 
  /*  printf("cfSockCliSend: gSocketKeepOpen=%d; keepopen=%d\n",
      gSocketKeepOpen, keepopen);
  */
 
  gSocketKeepOpen = 0;
  /*
    buildRequestInteractive(myRequest);
    printf("\n");
    printf("your command type will be: %d \n",ntohl(myRequest->command_type));
    printf("your command will be: %d \n",ntohl(myRequest->command));
    printf("your magic_cookie will be: %d \n",ntohl(myRequest->magic_cookie));
    printf("your request param_1 will be: %d \n",ntohl(myRequest->par1));
    printf("your request param_2 will be: %d \n",ntohl(myRequest->par2));
  */
 
  /* send request to server */
  nWrite = send (gSocketFd, (char *) myRequest, sizeof (*myRequest), 0);
  if ( nWrite != sizeof(*myRequest) )
    {
      printf ( "cfSockCli WARN: nWrite = %d, sizeof (*myRequest) = %d\n",
             nWrite, sizeof (*myRequest) );
      perror ("Connection aborted on error");
      close(gSocketFd);
      return (SOCK_ERROR);
    }
 
  if (myRequest->reply)        /* if expecting reply, read and display it */
    {
      i = recv ( gSocketFd, (char *) serverReply, sizeof(*serverReply), 0 );
 
      if ( i == SOCK_ERROR )
    {
      perror ("Error reading result\n");
      return (SOCK_ERROR);
    }
      /* The reason this while loop exists is that there
       * is a remote possibility of the above recv returning
       * less than sizeof(*serverReply) bytes.  This is because a recv returns
       * as soon as there is some data, and will not wait for
       * all of the requested data to arrive.  Since sizeof(*serverReply) bytes
       * is relatively small compared to the allowed TCP
       * packet sizes, a partial receive is unlikely.  If
       * the reply size were 2048 bytes instead,
       * a partial receive would be far more likely.
       * This loop will keep receiving until all sizeof(*serverReply) bytes
       * have been received, thus guaranteeing that the
       * next recv at the top of the loop will start at
       * the beginning of the next reply.
       */
      while ( i < sizeof(*serverReply) ) {
    j = recv( gSocketFd, ((char *) serverReply)+i, sizeof(*serverReply)-i, 0 );
    if ( j == SOCK_ERROR )
      {
        perror ("Error reading result\n");
        close(gSocketFd);
        return (SOCK_ERROR);
      }
    i += j;
      }
      //      handleReplyInteractive(serverReply);
    }
  gSocketKeepOpen = keepopen;
  /*  printf("cfSockCliSend: End; gSocketKeepOpen=%d\n", gSocketKeepOpen); */
  return (SOCK_OK);
};

References gSocketFd, gSocketKeepOpen, request::reply, SOCK_ERROR, and SOCK_OK.

Referenced by cfSockCli().

Here is the caller graph for this function:

cfSockCommand()

int cfSockCommand	(	int	crate_number,
		int	command_type,
		int	command,
		int	req_param,
		int	req_param_2,
		char *	reply,
		char *	msg )

GreenSockCommand()

int GreenSockCommand	(	int	crate_number,
		struct greenRequest *	gRequest )

Definition at line 334 of file cfSockCli.c.

{
  struct request myRequest;     // request to send to server
  struct request serverReply;   // reply from server
  //  char *reply;
  int mlen;
  int errFlag;
 
  //  char *reply = "Y";
 
  myRequest.command_type = htonl(gRequest->command_type);
  myRequest.command = htonl(gRequest->command);
  myRequest.magic_cookie = htonl(MAGIC_COOKIE);
  myRequest.par1 = htonl(gRequest->par1);
  myRequest.par2 = htonl(gRequest->par2);
 
  switch (*(gRequest->reply))
    {
    case 'y':
    case 'Y': myRequest.reply = TRUE;
      break;
    default: myRequest.reply = FALSE;
      break;
    }
  mlen = strlen(gRequest->message);
  strncpy(myRequest.message,gRequest->message,REQUEST_MSG_SIZE);
  myRequest.msgLen = htonl(mlen);
  myRequest.message[mlen] = '\0';
 
  //  printf("\n");
  //  printf ("Message to send:   <%s> \n",myRequest.message);
  //  printf("your command will be: %d \n",ntohl(myRequest.command));
  //  printf("your request param_1 will be: %d \n",ntohl(myRequest.par1));
  //  printf("your request param_2 will be: %d \n",ntohl(myRequest.par2));
  //  printf("Requested reply?  : %s \n",gRequest->reply);
  //  printf("\n");
 
  errFlag = cfSockCli(crate_number, &myRequest,&serverReply);
 
  if (errFlag != SOCK_OK) return errFlag;
 
  // if expecting reply, read and display it
  if (myRequest.reply) {
    //  gRequest->message = strcpy(serverReply.message,serverReply.message);
    strcpy(gRequest->message,serverReply.message);
    gRequest->command_type = htonl(serverReply.command_type);
    gRequest->command = htonl(serverReply.command);
    gRequest->par1 = htonl(serverReply.par1);
    gRequest->par2 = htonl(serverReply.par2);
 
    //    printf ("cfSockCli: MESSAGE FROM SERVER:   %s\n", gRequest->message);
    //    printf("Server reply command: %d \n",gRequest->command);
    //    printf("Server reply param_1: %d \n",gRequest->req_param);
    //    printf("Server reply param_2: %d \n\n",gRequest->req_param_2);
    //        handleReplyInteractive(&serverReply);
  }
  return errFlag;
}

References cfSockCli(), greenRequest::command, request::command, greenRequest::command_type, request::command_type, FALSE, MAGIC_COOKIE, request::magic_cookie, greenRequest::message, request::message, request::msgLen, greenRequest::par1, request::par1, greenRequest::par2, request::par2, greenRequest::reply, request::reply, REQUEST_MSG_SIZE, and SOCK_OK.

Referenced by GreenMonster::SCNCheckStatus(), GreenMonster::SCNCheckValues(), GreenMonster::SCNSetStatus(), and GreenMonster::SCNSetValue().

Here is the call graph for this function:

Here is the caller graph for this function: