#define	    IDENT	"1A03"
/*
** +--------------------------------------------------------------+
** |                  Paul Scherrer Institute                     |
** |                     SINQ Division				  |
** |                                                              |
** | This software may be used freely by non-profit organizations.|
** | It may be copied provided that the name of P.S.I. and of the |
** | author is included. Neither P.S.I. nor the author assume any |
** | responsibility for the use of this software outside of P.S.I.|
** +--------------------------------------------------------------+
**
** Module Name  . . . . . . . . : [...SinqHM]FOCUS_srv_main.c
**
** Author   . . . . . . . . . . : D. Maden
** Date of creation . . . . . . : Mar 2000
**	    Well, start a motor. But not a3 in powder mode in order to

** Updates:
**  1A01  7-Mar-2000 DM	    Initial version.
**---------------------------------------------------------------------------
**  FOCUS_srv_main.c is the main program of a SINQ Histogram Memory process
**  for the FOCUS TOF spectrometer at SINQ. It acts as an intermediary between
**  host software, which believes that it is talking to a single version of
**  SinqHM_srv, and 3 copies of SinqHM_srv on 3 different front-end processors,
**  each of which is histogramming data from one of the 3 detector banks on
**  FOCUS.
**
**  Communication between FOCUS_srv and the client is via TCP/IP protocol.
**
**  To compile and link this program for VxWorks on PSS123, use:
**
	    ccvx '-DINST="<instr>"' FOCUS_srv_main.c
	    ccvx '-DINST="<instr>"' FOCUS_srv_server.c
	    ccvx '-DINST="<instr>"' FOCUS_srv_routines.c
** where
	    ccvx = ccppc -O0			\
		    -mcpu=603			\
		    -I${WIND_BASE}/target/h	\
		    -fno-builtin		\
		    -fno-for-scope		\
		    -nostdinc			\
		    -DCPU=PPC603		\
		    -D_GNU_TOOL			\
		    -gdwarf -c -Wimplicit
** and
**	    <instr> = FOCUS or ...

    ldppc -o FOCUS_srv.o -r FOCUS_srv_main.o	    \
			     FOCUS_srv_routines.o  \
			     FOCUS_srv_server.o

**  and, on the target,
**
**   -> ld < /home/pss123/aco/maden/wind/SinqHM/FOCUS/NEW/FOCUS_srv.o
**   -> sp FOCUS_main, \
**	      <hostM>, <ncM>, <hostO>, <ncO>, <hostU>, <ncU>, <c_port>, <s_port>
**	         ^       ^       ^       ^       ^       ^       ^         ^
** Name of Host  |       |       |       |       |       |       |         |
** for Mittel-Bnk+       |       |       |       |       |       |         |
** # Counters in Mittel- +       |       |       |       |       |         |
**    Bank                       |       |       |       |       |         |
** Name of Host for Ober-Bank ---+       |       |       |       |         |
** # Counters in Ober-Bank --------------+       |       |       |         |
** Name of Host for Unter-Bank ------------------+       |       |         |
** # Counters in Unter-Bank -----------------------------+       |         |
** Port number of Bank Servers (dflt = 2500) --------------------+         |
** Our Port number as a Server (dflt = 2400) ------------------------------+
** e.g.
**     sp  FOCUS_main, "localhost", 150, "lnse05.vme", 117, "lnse06.vme", 116
**  or sps FOCUS_main, "localhost", 150, "lnse05.vme", 117, "lnse06.vme", 116
**====================================================================
*/
#include    "vxWorks.h"
#include    "taskLib.h"
#include    "msgQLib.h"
#include    "sockLib.h"
#include    "inetLib.h"
#include    "sysLib.h"

#include    <stdlib.h>
#include    <stdio.h>
#include    <ctype.h>
#include    <string.h>
#include    <unistd.h>
#include    <errno.h>
#include    <netinet/in.h>
#include    <arpa/inet.h>
#include    <netdb.h>
#include    <sys/types.h>
#include    <sys/socket.h>
#include    <setjmp.h>
#include    <time.h>

#include    <signal.h>		/* Get POSIX signal definitions. */
#include    <timers.h>
#include    <sys/mman.h>	/* Get POSIX mem mgmnt definitions. */
#include    <sys/wait.h>	/* Get POSIX wait definitions. */
/*
**====================	Global Definitions =====================================
*/
#include    "SinqHM_def.h"
#include    "FOCUS_gbl.h"

#define READBUFSIZE 66560
  extern    char    *vxWorksVersion;	/* Version string of vxWorks */
  extern    char    *creationDate;	/* Creation Date string of vxWorks */
  static    uchar   readBuffer[READBUFSIZE];

/*
**=============================================================================
**  Local routines.
**--------------------------------------------------------------------------
**	    FOCUS_server:  This is the Child Process Code for FOCUS_srv.
**
**		Set up TCP/IP port for operations with client, accept his
**		connection and perform services for him.
**
**		Note:	There must be NO return from this function.
*/
  int	FOCUS_server (
/*	============
*/		pid_t	 parent_pid,
		SEM_ID	 sem,
		int	 index,
		int	 pkt_size,
		int	 suspend_flag,
		int	*iret) {    /* Return a status to parent here:
				    **	0 = all OK
				    ** -1 = sigaction error.
				    ** -2 = socket or bind error with cnct_skt.
				    ** -3 = listen error with cnct_skt.
				    ** -4 = socket or bind error with clnt_skt.
				    ** -5 = failed to connect to a slave mstr.
				    ** -6 = SQHM_CNCT error response from slave.
				    ** -7 = socket or bind error with child.
				    ** -8 = failed to connect to a slave srvr.
				    */
    int			status;
    int			i, is, nbytes, bytes_to_come;
    char		recd[80];
    char		*p_nxt_byte;
    int			cnct_skt, rw_skt, clnt_skt, serve_port;
    struct sockaddr_in	rmt_sockname;
    int			rmt_sockname_len;
    char		*buff_pntr;
    int			port;

    sigset_t		proc_sigmask;
    struct sigaction	sig_action;

    struct req_buff_struct  my_req_bf;
    struct rply_buff_struct my_rply_bf;

/*============================================================================
*/
    *iret = 0;	    /* Assume initialisation will be OK */

    port = FS_port + index;

    StrJoin (FS_name[index], sizeof (FS_name[0]), taskName (get_pid ()), "");

    if (suspend_flag != 0) {
      printf ("\n%s: Suspending ..\n", FS_name[index]);
      taskSuspend (0);	    /* We've been told to suspend ourself, ..
			    **  .. presumably for debug reasons.
			    */
      printf ("\n%s: Suspension ended!\n", FS_name[index]);
    }
/*============================================================================
**	Define our signal mask first and define an action routine to catch
**	the SIGINT signal our parent will send us when he wants us to exit.
*/
    status = sigemptyset (&proc_sigmask);
    status = sigprocmask (SIG_SETMASK, &proc_sigmask, NULL);

    status = sigemptyset (&sig_action.sa_mask);
    sig_action.sa_handler = FS_catch_int_signal;
    sig_action.sa_flags   = 0;
    if (sigaction (SIGINT, &sig_action, NULL) == -1) {
      getErrno (&FS_errno);
      perror ("sigaction error:");
      *iret = -1;			/* Tell our parent we've given up */
      is = semGive (sem);		/* Let our parent continue */
      exit (KER__BAD_VALUE);
    }
/*============================================================================
**	Create a TCP/IP socket for communication, bind it and listen.
*/
    FS_chld_cnct_skt[index] = 0;
    cnct_skt = socket_bind (port, FS_name[index]);
    if (cnct_skt == -1) {
      *iret = -2;			/* Tell our parent we've given up */
      is = semGive (sem);		/* Let our parent continue */
      exit (KER__BAD_VALUE);
    }

    status = listen (cnct_skt, 1);
    if (status != 0) {
      close (cnct_skt);
      perror (StrJoin (recd, sizeof (recd),
			FS_name[index], " -- cnct_skt listen error"));
      *iret = -3;		/* Tell our parent we've given up */
      is = semGive (sem);	/* Let our parent continue */
      exit (KER__BAD_VALUE);
    }
/*============================================================================
**	    Now open client connections to each of the Slaves
*/
    my_req_bf.bigend = htonl (0x12345678);
    my_req_bf.cmnd   = htonl (SQHM_CNCT);
    my_req_bf.u.cnct.max_pkt   = htonl (pkt_size);
    my_req_bf.u.cnct.strt_mode = 0;
    for (i = 0; i < FS_n_slaves; i++) {
      if (FS_slv_active[i]) {
		/*
		** Create a socket and bind it
		*/
	clnt_skt = socket_bind (0, FS_name[index]);
	if (clnt_skt == -1) {
	  *iret = -4;		 /* Tell our parent we've given up */
	  FS_close_all (index);	 /* Shut down any client cnct'ns we've made */
	  close (cnct_skt);
	  is = semGive (sem);	 /* Let our parent continue */
	  exit (KER__BAD_VALUE);
	}
		/*
		** Make a connection to Master-server in slave
		*/
	rmt_sockname_len = sizeof (FS_rmt_socknam[0]);
	status = connect (clnt_skt, (struct sockaddr *) &FS_rmt_socknam[i],
					rmt_sockname_len);
	if (status == -1) {
	  StrJoin (recd, sizeof (recd),
			": error connecting to master in ", FS_slaves[i]);
	  perror (StrJoin (recd, sizeof (recd), FS_name[index], recd));
	  *iret = -5;		/* Tell our parent we've given up */
	  close (clnt_skt);
	  FS_close_all (index);	/* Shut down any client cnct'ns we've made */
	  close (cnct_skt);
	  is = semGive (sem);	/* Let our parent continue */
	  exit (KER__BAD_VALUE);
	}
		/*
		** Send SQHM_CNCT command to Master-server and get response
		*/
	status = rqst_send_get (clnt_skt, &my_req_bf, sizeof (my_req_bf),
			 &my_rply_bf, sizeof (my_rply_bf),
			 &FS_bytes_got, &FS_bytes_put, FS_name[index]);
	if (!status || (ntohl (my_rply_bf.status) != KER__SUCCESS)) {
	  if (ntohl (my_rply_bf.status) != KER__SUCCESS) {
	    printf (
             "\n%s: %s to %s.\n, status = %d, substatus = %d ",
                        "error response to SINQHM_CNCT",
			FS_name[index], FS_slaves[i], 
                        ntohl(my_rply_bf.status), 
                        ntohl(my_rply_bf.sub_status));
	  }
	  *iret = -6;		/* Tell our parent we've given up */
	  close (clnt_skt);
	  FS_close_all (index);	/* Shut down any client cnct'ns we've made */
	  close (cnct_skt);
	  is = semGive (sem);	/* Let our parent continue */
	  exit (KER__BAD_VALUE);
	}
	close (clnt_skt);
	serve_port = ntohl (my_rply_bf.u.cnct.port);
	FS_pkt_siz[index][i] = ntohl (my_rply_bf.u.cnct.pkt_size);
		/*
		** Create a socket for talking to our server in slave and bind
		*/
	clnt_skt = socket_bind (0, FS_name[index]);
	if (clnt_skt == -1) {
	  *iret = -7;		 /* Tell our parent we've given up */
	  FS_close_all (index);	 /* Shut down any client cnct'ns we've made */
	  close (cnct_skt);
	  is = semGive (sem);	 /* Let our parent continue */
	  exit (KER__BAD_VALUE);
	}
		/*
		** Make a connection to our server in slave
		*/
	rmt_sockname = FS_rmt_socknam[i];
	rmt_sockname.sin_port = htons (serve_port);
	rmt_sockname_len = sizeof (rmt_sockname);
	status = connect (clnt_skt, (struct sockaddr *) &rmt_sockname,
					rmt_sockname_len);
	if (status == -1) {
	  StrJoin (recd, sizeof (recd),
			": error connecting to server in ", FS_slaves[i]);
	  perror (StrJoin (recd, sizeof (recd), FS_name[index], recd));
	  *iret = -8;		/* Tell our parent we've given up */
	  close (clnt_skt);
	  FS_close_all (index);	/* Shut down any client cnct'ns we've made */
	  close (cnct_skt);
	  is = semGive (sem);	/* Let our parent continue */
	  exit (KER__BAD_VALUE);
	}
	FS_skt[index][i] = clnt_skt;
      }
    }
/*============================================================================
**	    Tell parent our cnct port is set up and waiting by releasing
**	    semaphore so that our parent can continue. The parent will then
**	    send a message to the client telling him which port he is to use.
*/
    FS_chld_cnct_skt[index] = cnct_skt;
    is = semGive (sem);
    if (is != OK) {
      kill (parent_pid, SIGUSR1);   /* Inform parent that we are in trouble */
      printf ("\n%s -- sem release error\n", FS_name[index]);
      close (FS_chld_cnct_skt[index]); FS_chld_cnct_skt[index] = 0;
      FS_close_all (index);	    /* Close connections to our servers */
      exit (KER__BAD_VALUE);
    }
/*============================================================================
**	    Wait for the client to connect to our port
*/
    rmt_sockname_len = sizeof (rmt_sockname);
    rw_skt = accept (FS_chld_cnct_skt[index],
		    (struct sockaddr *) &rmt_sockname, &rmt_sockname_len);
    if (rw_skt == -1) {
      perror (StrJoin (recd, sizeof (recd),
			FS_name[index], " -- cnct_skt accept error"));
      close (FS_chld_cnct_skt[index]); FS_chld_cnct_skt[index] = 0;
      FS_close_all (index);	    /* Close connections to our servers */
      kill (parent_pid, SIGUSR1);   /* Inform parent that we are in trouble */
      exit (KER__BAD_VALUE);
    }
    FS_chld_rw_skt[index] = rw_skt;
/*
**-------------------------------------------------------------------------
**			    Here is the main recv loop
*/
  main_loop:
/*=========
*/  bytes_to_come = sizeof (my_req_bf);	    /* Read a command */
    p_nxt_byte = (char *) &my_req_bf;
    while (bytes_to_come > 0) {
      nbytes = recv (FS_chld_rw_skt[index], p_nxt_byte, bytes_to_come, 0);
      if (nbytes <= 0) break;
      FS_bytes_got += nbytes;
      bytes_to_come -= nbytes;
      p_nxt_byte += nbytes;
    }
    if ((bytes_to_come == 0) &&
	(ntohl (my_req_bf.bigend) == 0x12345678) &&
	(ntohl (my_req_bf.cmnd) != SQHM_CLOSE)) {
      is = FS_do_command (index, FS_chld_rw_skt[index], pkt_size,
					&my_req_bf, &my_rply_bf);
      if (is) goto main_loop;	/* Break out of loop on error */
    }
/*
**			    End of the main recv loop
**-------------------------------------------------------------------------
**	Get here if we drop out of the "recv" loop.
**	This should only happen on getting a SQHM_CLOSE message or if our
**	client closes his socket without sending a SQHM_CLOSE message.
**	Anything else is a fatal error.
*/
    close (FS_chld_rw_skt[index]); FS_chld_rw_skt[index] = 0;
    close (FS_chld_cnct_skt[index]); FS_chld_cnct_skt[index] = 0;
		/*
		** Check the various error conditions
		*/
    if (bytes_to_come != 0) {	/* Was a complete request read? */
				/* No, it may be a network error, in which case
				** nbytes is -1, or nothing was read, which
				** indicates that our client simply closed
				** his connection (forgetting to send a
				** SQHM_CLOSE message), or the client has
				** screwed up the protocol! */
      if (nbytes == -1) {
						/* It's a network error */
	perror (StrJoin (recd, sizeof (recd),
			    FS_name[index], " -- rw_skt recv error"));
	status = KER__EXIT_SIGNAL;
      }else if (bytes_to_come == sizeof (my_req_bf)) {
				/* Our client simply closed his connection.
				** Treat this as normal. */
	printf ("\n%s exiting.\n", FS_name[index]);
	status = KER__SUCCESS;
      }else {
	printf ("\n%s -- rw_skt recv wrong number of bytes: %d\n",
				    FS_name[index], nbytes);
	status = KER__EXIT_SIGNAL;
      }
    }else if (ntohl (my_req_bf.bigend) != 0x12345678) {
					    /* Network byte-order wrong! */
      printf ("\n%s -- big-endian/little-endian problem!\n"
	    "    Buffer received in non-network byte order!\n", FS_name[index]);
      status = KER__EXIT_SIGNAL;
    }else if (ntohl (my_req_bf.cmnd) == SQHM_CLOSE) {
			       /* SQHM_CLOSE request received. This is normal */
      printf ("\n%s exiting.\n", FS_name[index]);
      status = KER__SUCCESS;
    }else {
					/* Unrecognised request received! */
      printf ("\n%s -- unrecognised command received: 0x%x\n",
			FS_name[index], ntohl (my_req_bf.cmnd));
      status = KER__EXIT_SIGNAL;
    }

    FS_close_all (index);	    /* Close connections to our servers */
    kill (parent_pid, SIGUSR1);	    /* Inform parent that we are exiting */
    exit (status);
  }
/*
**--------------------------------------------------------------------------
*/
  void FS_catch_signal (int signo) {
/*     ===============
**		    Action Routine for catching signals from Child Processes.
**
**		This routine is specific to FOCUS_srv.
*/
    pid_t   my_pid;

    my_pid = get_pid ();
    if (FS_dbg_lev0) printf ("\nFS_catch_signal: "
			"Signal %d received by PID 0x%x.\n", signo, my_pid);
    switch (signo) {
     case SIGUSR1:	    /* A child is about to exit. */
       FS_cnt_SIGUSR1++;
       sleep (1);	    /* Give it a chance to disappear! */
       break;
     default:
       printf ("\nFS_catch_signal: Unexpected signal received "
			    "by PID 0x%x: %d.\n", my_pid, signo);
    }
  }
/*
**--------------------------------------------------------------------------*/
  void FS_catch_int_signal (int signo) {
/*     ===================
**	    Action Routine for catching SIGINT signals. This is a signal
**	    from the parent to get its child to exit. An exit will be performed.
**
**		This routine is specific to FOCUS_srv.
*/
    int	    i, j;
    pid_t   my_pid;

    my_pid = get_pid ();
			    /*
			    ** Try to find our index by searching the PID list
			    */
    if (my_pid == FS_pids[0]) {
      ;				    /* Should not get here - there's no Filler
				    ** for FOCUS_srv! */
    }else {
      for (i = MAX_CLIENTS; i > 0; i--) if (my_pid == FS_pids[i]) break;
      if (i > 0) {
	if (FS_chld_rw_skt[i] != 0) {
	  printf ("\nClosing r/w socket of task %s\n", FS_name[i]);
	  close (FS_chld_rw_skt[i]); FS_chld_rw_skt[i] = 0;
	}
	if (FS_chld_cnct_skt[i] != 0) {
	  printf ("\nClosing connect socket of task %s\n", FS_name[i]);
	  close (FS_chld_cnct_skt[i]); FS_chld_cnct_skt[i] = 0;
	}
	for (j = 0; j < FS_n_slaves; j++) {
	  if (FS_skt[i][j] != 0) {
	    printf ("\nClosing client socket of task %s to %s\n",
			    FS_name[i], FS_slaves[i]);
	    close (FS_skt[i][j]); FS_skt[i][j] = 0;
	  }
	}
      }
    }

    if (FS_dbg_lev0) printf ("\nFS_catch_int_signal: "
			"Signal %d received by PID 0x%x.\n", signo, my_pid);
    switch (signo) {
     case SIGINT:	    /* A SIGINT signal has been received. Exit. */
       exit (KER__SUCCESS);
       break;
     default:
       printf ("\nFS_catch_int_signal: "
		 "Unexpected signal %d received by PID 0x%x.\n", signo, my_pid);
    }
  }
/*
**--------------------------------------------------------------------------
**	    FS_cleanup_children:    Find out which child(ren) have exited and
**			    update the list of task PID's so the associated
**			    task slot becomes free.
**
**		    If FILLER should be present but has fallen off, then any
**		    active children will be told to exit and we shall set our
**		    state to "deconfig".
*/
  void	FS_cleanup_children (
/*	===================
*/		int	  max_chld,	/* The size of the pids array */
		pid_t	 *pids,		/* Array of pids. Index 0 is FILLER */
		int	 *pcnt_SIGUSR1,	/* Flag set on SIGUSR1 signals whenever
					** a child exits. */
		int	  verbose,	/* If true, report what's going on */
		char	**tsk_names,
		char	 *filler_name) {

    int		i, status, n_active, do_newline = False;
    char       *t_name;
    pid_t	pid;

    if (pids[0] != 0) {
      if (verbose) printf ("\n  ... checking state of %s ...", filler_name);
      t_name = taskName (pids[0]);
      if (t_name == NULL) {
        if (verbose) printf (" it has exited.");
        pids[0] = 0;
      }else {
        if (verbose) printf (" it is still active.");
      }
      if (verbose) do_newline = True;
    }

    n_active = 0;
    for (i = 1; i <= max_chld; i++) {
      if (pids[i] != 0) {
	if (verbose) printf ("\n  ... checking state of %s ...", tsk_names[i]);
	t_name = taskName (pids[i]);
	if (t_name == NULL) {
	  if (verbose) printf (" it has exited.");
	  pids[i] = 0;
	}else {
	  if (verbose) printf (" it is still active.");
	  n_active += 1;
	}
	if (verbose) do_newline = True;
      }
    }
    if (do_newline) printf ("\n");
    if (pcnt_SIGUSR1 != NULL) *pcnt_SIGUSR1 = 0;

    if ((filler_name[0] != NIL) &&	/* Must we force a de-config? */
	(pids[0] == 0) &&
	(n_active > 0)) {
      for (;;) {			/* Loop for ever till programmed! */
	printf ("\nThe filler process, %s, has terminated abnormally.\n"
		"A de-configure must be forced\n"
		"This has not yet been programmed.\n"
		"Re-boot the histogram memory!!\n", filler_name);
	sleep (5);
      }
    }
  }
/*
**--------------------------------------------------------------------------
**	    FS_close_all:	Shut down any active client cnct'ns
*/
  int	FS_close_all (
/*	============
*/		int	  index) {

    int			    i, status;
    char		    recd[80];
    struct req_buff_struct  my_req_bf;
    struct rply_buff_struct my_rply_bf;

    my_req_bf.bigend = htonl (0x12345678);
    my_req_bf.cmnd   = htonl (SQHM_CLOSE);
    for (i = 0; i < FS_n_slaves; i++) {
      if (FS_skt[index][i] != 0) {
	status = send (FS_skt[index][i],
			(char *) &my_req_bf, sizeof (my_req_bf), 0);
	if (status == -1) {
	  perror (StrJoin (recd, sizeof (recd),
		FS_name[index], "/rqst_send_get: send error"));
	}
	close (FS_skt[index][i]);
	FS_skt[index][i] = 0;
      }
    }
  }
/*
**--------------------------------------------------------------------------
**	    FS_close_down_offspring:	Close down FILLER and, if directed,
**					other children too.
*/
  int	FS_close_down_offspring (
/*	=======================
*/		int	  harshness,
		int	  max_chld,
		pid_t	 *pids,
		int	 *exit_stat,
		int	 *pcnt_SIGUSR1,	/* Flag set on SIGUSR1 signals
					** whenever a child exits. */
		int	  verbose,	/* If true, report what's going on */
		char	**tsk_names,
		char	 *filler_name) {

    int		i, j;
    int		n_children, new_c = 0;
    char	buff[132];

    n_children = 0;		/* See if any server children are active */
    for (i = 1; i <= max_chld; i++) {
      if (pids[i] != 0) n_children += 1;
    }
    if (n_children > 0) {   /* If so, only proceed if asked to be ruthless */
      if (harshness == 0) {
	printf ("\nDe-configure error. ");
        if (n_children == 1) sprintf (buff, "1 server is");
        if (n_children != 1) sprintf (buff, "%d servers are", n_children);
	printf ("%s still active.\n", buff);
	return False;
      }else {
        if (n_children == 1) sprintf (buff, " -- 1 server is still active. It");
        if (n_children != 1) sprintf (buff, " -- %d servers are still active. "
						"They", n_children);
	printf ("\n%s will be terminated.\n", buff);
      }
    }

    FS_kill_children (max_chld, pids,
	    tsk_names, filler_name);   /* Kill FILLER and any server children */
    sleep (1);			       /* Give them chance to exit */
    FS_cleanup_children (max_chld, pids,    /* Update the PIDs */
			    pcnt_SIGUSR1, verbose, tsk_names, filler_name);

    for (j = 0; j < n_children; j++) {	    /* Check to see if all gone */
      if (pids[0] == 0) new_c = 0; else new_c = 1;  /* Count remainder */
      for (i = max_chld; i > 0; i--) {
	if (pids[i] != 0) new_c += 1;
      }
      if (new_c == 0) break;
      sleep (1);
      FS_cleanup_children (max_chld, pids,
			    pcnt_SIGUSR1, verbose, tsk_names, filler_name);
    }
    if (new_c != 0) {
      printf ("     ... failed to tidy up. %d children still active.\n", new_c);
      return False;
    }else {
      return True;
    }
  }
/*
**--------------------------------------------------------------------------
**	    FS_deconfig_all:  Deconfigure any active slaves.
**
**		This routine is specific to FOCUS_srv.
*/
  int	FS_deconfig_all (int harshness) {
/*	===============
*/
    int				i, iret, all_ok = True;
    struct req_buff_struct	rqst;
    struct rply_buff_struct	reply;

    rqst.bigend	    = htonl (0x12345678);     /* Set up the deconfig request */
    rqst.cmnd	    = htonl (SQHM_DECONFIG);
    rqst.u.decnfg.sub_code = htonl (harshness);
					/*
					** Loop sending it to active slaves
					*/
    for (i = 0; i < FS_n_slaves; i++) {
      if (FS_slv_active[i]) {
	iret = FS_send_cmnd_to_mstr (&FS_rmt_socknam[i],
		    &rqst, sizeof (rqst), &reply,
		    &FS_bytes_got, &FS_bytes_put);
	if (iret && (ntohl (reply.status) == KER__SUCCESS)) {
	  FS_slv_active[i] = False;
	}else {
	  all_ok = False;
	}
      }
    }
    return all_ok;
  }
/*
**--------------------------------------------------------------------------
**	    FS_do_command:  Action routine for an SQHM_??? command.
**			    The command is processed (including returning a
**			    status response message).
**
**		This routine is specific to FOCUS_srv.
*/
  int	FS_do_command (
/*	=============
*/		int			 index,
		int			 skt,
		int			 pkt_size,
		struct req_buff_struct	*rqst,
		struct rply_buff_struct *reply) {

    int		status, indx, is, suspendMode, i, j, sub_cmnd;
    int		txt_len, txt_offset, bytes_to_go, harshness;
    int		my_first_bin, my_nbins, my_bytes_per_bin, my_hist_no;
    int		my_sub_code, my_x_lo, my_nx, my_y_lo, my_ny, my_xdim, my_h_slct;
    time_t	secs;
    char       *msge, *p_buff, *p_txt;

    reply->bigend = htonl (0x12345678);  /* Put in the "endian" flag. */
    rply_status_setup (reply, KER__SUCCESS, 0, "All OK");

    switch (ntohl (rqst->cmnd)) {

     case SQHM_CLOSE:		     /* Close the connection. */
      return False;		     /* Do nothing. */

     case SQHM_CNCT:		     /* Make a new connection. */
      printf ("\n%s: connecting ...", FS_name[index]);

      time (&secs);
      secs = secs - FS_start_time;
      reply->u.cnct.up_time = htonl (secs);

      if (!FS_cfgn_done) {	     /* Check we've been configured */
	printf (" but not yet configured!\n");
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
					    "Not configured", &FS_bytes_put);
      }else if (index != 0) {
	printf (" but not issued to SinqHM-master!\n");
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
					    "Not SinqHM-master", &FS_bytes_put);
      }else {
	pkt_size = ntohl (rqst->u.cnct.max_pkt);
	if ((pkt_size < 1024) || (pkt_size > 8192)) pkt_size = 8192;
	pkt_size = pkt_size & ~3;     /* Ensure pkt_size is multiple of 4 */
	indx = FS_make_child (FOCUS_server, 100,
			ntohl (rqst->u.cnct.strt_mode), pkt_size,
			MAX_CLIENTS, FS_pids, FS_chld_exit_status,
			&FS_cnt_SIGUSR1, "FSserv");
	if (indx <= 0) {	          /* Child created and ready? */
	  printf ("\n%s: creation of child failed: %d.\n",
					FS_name[0], indx);
	  switch (indx) {
	   case -1: msge = "Spawn failed"; break;
	   case -2: msge = "No more ports"; break;
	   case -3: msge = "Time-out of child start-up"; break;
	   case -4: msge = "Child could not get started"; break;
	   default: msge = "Bad status from make_child";
	  }
	  is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_CREATE,
						    indx, msge, &FS_bytes_put);
	}else {			    /* Yes, child is up and ready. */
	  reply->u.cnct.port	      = htonl (FS_port + indx);
	  reply->u.cnct.pkt_size      = htonl (pkt_size);
	  reply->u.cnct.hm_mode	      = htonl (FS_mode_ALL);
	  reply->u.cnct.n_hists	      = htonl (FS_hi_cntr - FS_lo_cntr + 1);
	  reply->u.cnct.num_bins      = htonl (FS_hi_bin - FS_lo_bin + 1);
	  reply->u.cnct.bytes_per_bin = htonl (FS_bpb);
	  reply->u.cnct.curr_hist     = htonl (0);
	  reply->u.cnct.max_block = htonl (memFindMax ());  /* Max free mem */
	  reply->u.cnct.total_bytes = htonl (FS_totl_bytes);
	  reply->u.cnct.lo_cntr = htonl (FS_lo_cntr);
	  reply->u.cnct.lo_bin = htonl (FS_lo_bin);
	  reply->u.cnct.compress = htonl (FS_compress);
	  printf (" %s started. Packet size = %d.\n", FS_name[indx], pkt_size);
	  is = FS_rply_status_send (skt, reply, &FS_bytes_put);
	}
      }
      if (!is)
	printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
      return is;

     case SQHM_CONFIG:
      printf ("\n%s: Configure ..", FS_name[index]);
      if (FS_cfgn_done) {
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
					  "Already configured", &FS_bytes_put);
	printf (" already configured!\n");
	return False;
      }

      FS_free_memory (NULL);	/* There should be no memory allocated but
				** go and release it anyway!
				*/
      is = FS_do_config (skt, rqst, reply);	/* No, do the config */
      if (!is) {
	FS_rply_status_send (skt, reply, &FS_bytes_put);
	return False;
      }else {
	FS_cfgn_done = True;
	is = FS_rply_status_send (skt, reply, &FS_bytes_put);
	if (!is)
	    printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
	return is;
      }

     case SQHM_DAQ:		    /* Start or stop data acquisition.
				    ** Simply forward to our slaves. */
      printf ("\n%s: SQHM_DAQ", FS_name[index]);
      if (!FS_cfgn_done) {		      /* Configured yet? */
	FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,  /* No */
					    "Not configured", &FS_bytes_put);
	printf (" -- not configured!\n");
	return False;
      }
      sub_cmnd = ntohl (rqst->u.daq.sub_cmnd);
      if (sub_cmnd == DAQ__CLR)  printf ("/DAQ__CLR:");
      if (sub_cmnd == DAQ__GO)   printf ("/DAQ__GO:");
      if (sub_cmnd == DAQ__INH)  printf ("/DAQ__INH:");
      if (sub_cmnd == DAQ__STOP) printf ("/DAQ__STOP:");
      if (sub_cmnd == DAQ__TST)  printf ("/DAQ__TST:");

      is = FS_do_daq (index, sub_cmnd, rqst, reply);

      if (FS_dsbl_mask == 0) {
	printf (" data acquisition is active.\n");
      }else {
	printf (" data acquisition is inhibited.\n");
      }

      is = FS_rply_status_send (skt, reply, &FS_bytes_put);
      if (!is)
	    printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
      return is;

     case SQHM_DBG:			     /* Set debug parameters.
					     ** Just do this locally. Do not
					     ** pass on to slaves. */
      FS_dbg_mask = ntohl (rqst->u.dbg.mask);
      FS_dbg_lev0 = ((FS_dbg_mask & 1) != 0) ? 1 : 0;
      FS_dbg_lev1 = ((FS_dbg_mask & 2) != 0) ? 1 : 0;
      FS_dbg_lev2 = ((FS_dbg_mask & 4) != 0) ? 1 : 0;
      FS_dbg_lev3 = ((FS_dbg_mask & 8) != 0) ? 1 : 0;
      printf ("\n%s: Debug mask = 0x%x\n", FS_name[index], FS_dbg_mask);
      is = FS_rply_status_setup_and_send (skt, reply, KER__SUCCESS, 0,
						NULL, &FS_bytes_put);
      if (!is)
	    printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
      return is;

     case SQHM_DECONFIG:	/* Close down any servers and then deconfigure
				** our slaves */
      printf ("\n%s: De-configure", FS_name[index]);
      if (!FS_cfgn_done) {		    /* Anything to do? */
	printf (" -- already de-configured!\n");
	is = FS_rply_status_setup_and_send (skt, reply, KER__SUCCESS, 0,
						NULL, &FS_bytes_put);
      }else if (index != 0) {
	printf (" -- not issued to Master Server!\n");
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
					    "Not Master Server", &FS_bytes_put);
      }else {
	harshness = ntohl (rqst->u.decnfg.sub_code);  /* Pick out "harshness" */
	is = FS_close_down_offspring (harshness,
		    MAX_CLIENTS, FS_pids, FS_chld_exit_status,
		    &FS_cnt_SIGUSR1, FS_dbg_lev0, FS_p_names, "");
	if (is) {
	  is = FS_deconfig_all (harshness);
	  if (is) {
	    printf (" done.\n");
	    FS_cfgn_done = False;
	    is = FS_rply_status_setup_and_send (skt, reply, KER__SUCCESS, 0,
						    NULL, &FS_bytes_put);
	  }else {
	    printf ("\nFailed! Problem deconfiguring slaves.\n");
	    is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, is,
			    "Problem deconfiguring slaves", &FS_bytes_put);
	  }
	}else {
	  printf ("\nFailed! Problem terminating children.\n");
	  is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, is,
			    "Problem terminating children", &FS_bytes_put);
	}
	FS_free_memory (NULL);	    /* Release all reserved memory */
      }
      if (!is)
	    printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
      return is;

     case SQHM_EXIT:				    /* Rundown */
      printf ("\n%s: Run-down ...", FS_name[index]);
      if (index != 0) {
	printf (" -- not issued to Master Server!\n");
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
				    "Not SinqHM-master", &FS_bytes_put);
      }else if (FS_cfgn_done) {
	printf (" -- not issued to SinqHM-master!\n");
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
				    "Not SinqHM-master", &FS_bytes_put);
      }else {
	rqst->u.decnfg.sub_code = htonl (1);	    /* Set "harshness" = 1 */
	is = FS_close_down_offspring (
		    ntohl (rqst->u.decnfg.sub_code),  /* Pick out "harshness" */
		    MAX_CLIENTS, FS_pids, FS_chld_exit_status,
		    &FS_cnt_SIGUSR1, FS_dbg_lev0, FS_p_names, "");
	if (is) {
	  if (FS_cfgn_done) {
	    printf (" deconfiguring ...");
	    is = FS_deconfig_all (1);
	    if (is) {
	      printf (" done.\n");
	      FS_cfgn_done = False;
	      is = FS_rply_status_setup_and_send (skt, reply, KER__SUCCESS, 0,
						    NULL, &FS_bytes_put);
	    }else {
	      printf (" WARNING: deconfig failed.\n");
	      is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE,
			is, "Problem deconfiguring", &FS_bytes_put);
	    }
	  }
	}else {
	  printf (" WARNING: problem terminating children.\n");
	  is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, is,
			    "Problem terminating children", &FS_bytes_put);
	}
	FS_free_memory (NULL);	    /* Release all reserved memory */
      }
      if (!is)
	    printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
      return True;

     case SQHM_IDENT:		     /* Give info on software identification. */
      txt_len = IDENT_MSGE_LEN;
      txt_offset = 0;
      p_buff = calloc (txt_len, 1);	    /* Get a buffer for text info */
      if (p_buff == NULL) {
	printf ("\n%s -- SQHM_IDENT: failed to get buffer!\n",
	    FS_name[index]);
	FS_rply_status_setup_and_send (skt, reply, KER__BAD_ALLOC, 0,
	    "Failed to get buffer for composing Ident", &FS_bytes_put);
	return False;
      }
      time (&secs);
      secs = secs - FS_start_time;
      reply->u.ident.up_time = htonl (secs);
      reply->u.ident.n_extra_bytes = htonl (IDENT_MSGE_LEN);
      p_txt = p_buff;

      reply->u.ident.offset_vxWorks_ident = htons (txt_offset);
      StrJoin (p_txt, txt_len, vxWorksVersion, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;
      
      reply->u.ident.offset_vxWorks_date = htons (txt_offset);
      StrJoin (p_txt, txt_len, creationDate, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_instr = htons (txt_offset);
      StrJoin (p_txt, txt_len, FS_inst, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_def_ident = htons (txt_offset);
      StrJoin (p_txt, txt_len, FS_def_ident, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_sinqhm_main_ident = htons (txt_offset);
      StrJoin (p_txt, txt_len, FS_main_ident, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_sinqhm_main_date = htons (txt_offset);
      StrJoin (p_txt, txt_len, FS_main_date, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_sinqhm_server_ident = htons (txt_offset);
      StrJoin (p_txt, txt_len, FS_serv_ident, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_sinqhm_server_date = htons (txt_offset);
      StrJoin (p_txt, txt_len, FS_serv_date, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_sinqhm_filler_ident = htons (txt_offset);
      StrJoin (p_txt, txt_len, "", "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_sinqhm_filler_date = htons (txt_offset);
      StrJoin (p_txt, txt_len, "", "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_sinqhm_routines_ident = htons (txt_offset);
      StrJoin (p_txt, txt_len, FS_rout_ident, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      reply->u.ident.offset_sinqhm_routines_date = htons (txt_offset);
      StrJoin (p_txt, txt_len, FS_rout_date, "");
      i = strlen (p_txt) + 1;
      txt_offset += i; p_txt += i; txt_len -= i;

      is = FS_rply_status_send (skt, reply, &FS_bytes_put);
		    /*
		    ** Now send the data
		    */
      p_txt = p_buff;
      bytes_to_go = IDENT_MSGE_LEN;
      while (bytes_to_go > 0) {
	i = (bytes_to_go > pkt_size) ? pkt_size : bytes_to_go;
	is = send (skt, p_txt, i, 0);
	if (is > 0) {
	  FS_bytes_put += is;
	  bytes_to_go  -= is;
	  p_txt        += is;
	}else {
	  free (p_buff);
	  printf ("\n%s -- SQHM_IDENT: failed to send extra data!\n",
				    FS_name[index]);
	  return False;		    /* Fatal error on send */
	}
      }
      free (p_buff);
      return True;

     case SQHM_PROJECT:	    /* Read a projected "rectangle" of the HM. */
      if (!FS_cfgn_done) {	     /* Check we've been configured */
	printf ("\n%s -- projecting but not yet configured!\n", FS_name[index]);
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
					    "Not configured", &FS_bytes_put);
	return False;
      }else {
	if (FS_dbg_lev0) printf ("\n%s -- projecting ...", FS_name[index]);
	my_sub_code = ntohl (rqst->u.project.sub_code);
	my_x_lo     = ntohl (rqst->u.project.x_lo);
	my_nx       = ntohl (rqst->u.project.nx);
	my_y_lo     = ntohl (rqst->u.project.y_lo);
	my_ny       = ntohl (rqst->u.project.ny);
	my_xdim     = ntohl (rqst->u.project.xdim);
	my_h_slct   = ntohl (rqst->u.project.nhist);
	is = FS_do_project (index, reply, skt, pkt_size,
	       my_sub_code, my_x_lo, my_nx, my_y_lo, my_ny, my_xdim, my_h_slct);
	if (!is) {
	  printf ("\n%s -- SQHM_PROJECT fatal error sending status reply or "
			"histo data.\n", FS_name[index]);
	}else {
	  if (FS_dbg_lev0) printf (" done.\n");
	}
	return is;
      }

     case SQHM_READ:	/* Read a section of the HM. */
      if (!FS_cfgn_done) {	     /* Check we've been configured */
	printf ("\n%s -- reading but not yet configured!\n", FS_name[index]);
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
					    "Not configured", &FS_bytes_put);
	return False;
      }else {
	if (FS_dbg_lev0) printf ("\n%s -- reading ...", FS_name[index]);
	my_hist_no   = ntohl (rqst->u.read.hist_no);
	my_first_bin = ntohl (rqst->u.read.first_bin);
	my_nbins     = ntohl (rqst->u.read.n_bins);
	is = FS_do_read (index, reply, skt, pkt_size,
		    my_nbins, my_first_bin, my_hist_no);
	if (!is) {
	  printf ("\n%s -- SQHM_READ fatal error sending status reply or "
			"histo data.\n", FS_name[index]);
	}else {
	  if (FS_dbg_lev0) printf (" done.\n");
	}
	return is;
      }

     case SQHM_SELECT:	    /* SQHM_SELECT still needs to be programmed. */
      printf ("\n%s: Select ...", FS_name[index]);
      is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_VALUE, 0,
				    "Not yet available!", &FS_bytes_put);
      if (!is) {
	printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
      }else {
	printf (" not yet implemented!\n");
      }
      return is;

     case SQHM_STATUS:			/* Get-Status request */
      if (FS_dbg_lev0) printf ("\n%s: Status ...", FS_name[index]);
		    /*
		    ** Build up info
		    */
      reply->status = htonl (KER__SUCCESS);	/* Indicate success */
      strcpy ((char *) &reply->sub_status,	/* Set up the Ident */
			    SINQHM_DEF_ID);	/* This does not need htonl! */
      reply->u.status.max_n_hists  = htonl (N_HISTS_MAX);
      reply->u.status.max_num_bins = htonl (N_BINS_MAX + 1);
      reply->u.status.max_srvrs    = MAX_CLIENTS;
      reply->u.status.max_block    = htonl (memFindMax ());  /* Max free mem */
      if (!FS_cfgn_done) {
	reply->u.status.cfg_state     = 0;
	reply->u.status.n_hists	      = 0;
	reply->u.status.curr_hist     = 0;
	reply->u.status.num_bins      = 0;
	reply->u.status.act_srvrs     = 0;
	reply->u.status.bytes_per_bin = 0;
	reply->u.status.compress      = 0;
	reply->u.status.daq_now	      = 0;
	reply->u.status.filler_mask   = 0;
	reply->u.status.tsi_status    = 0;
	reply->u.status.flags	      = 0;
	reply->u.status.dt_or_dts.both = 0;
	reply->u.status.num_bad_events = 0;
      }else {
	reply->u.status.cfg_state    = htonl (FS_mode_ALL);
	reply->u.status.n_hists      = htonl (FS_hi_cntr - FS_lo_cntr + 1);
	reply->u.status.curr_hist    = htons (0);
	reply->u.status.num_bins     = htonl (FS_hi_bin - FS_lo_bin + 1);

	for (j = 0, i = 1; i <= MAX_CLIENTS; i++) if (FS_pids[i] != 0) j++;
	reply->u.status.act_srvrs  = j;

	reply->u.status.bytes_per_bin = FS_bpb;
	reply->u.status.compress      = FS_compress;
	reply->u.status.daq_now	      = htons (FS_dsbl_mask);
	reply->u.status.filler_mask   = htons (FS_srv_masks[0]);
	reply->u.status.tsi_status    = htonl (0);
	reply->u.status.flags	      = htonl (0);
	reply->u.status.dt_or_dts.both = htonl (0);
	reply->u.status.num_bad_events = htonl (0);
      }
      time (&secs);
      secs = secs - FS_start_time;
      reply->u.status.up_time = htonl (secs);

      is = FS_rply_status_send (skt, reply, &FS_bytes_put);
      if (FS_dbg_lev0) {
	if (!is) {
	  printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
	}else {
	  printf (" has been sent.\n");
	}
      }
      return is;

     case SQHM_WRITE:	/* Write a section of the HM.
			**
			** NOTE: always call FS_do_write, even if not configured
			** ====  since network data has always to be read.
			*/
      printf ("\n%s: writing ...", FS_name[index]);
      my_hist_no       = ntohl (rqst->u.write.hist_no);
      my_first_bin     = ntohl (rqst->u.write.first_bin);
      my_nbins	       = ntohl (rqst->u.write.n_bins);
      my_bytes_per_bin = ntohl (rqst->u.write.bytes_per_bin);
      is = FS_do_write (index, rqst, reply, skt, pkt_size,
			my_nbins, my_first_bin, my_bytes_per_bin, my_hist_no);
      if (!is) {
	printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
      }else {
	printf (" done.\n");
      }
      return is;

     case SQHM_ZERO:
      if (!FS_cfgn_done) {	     /* Check we've been configured */
	printf ("\n%s -- zeroing but not yet configured!\n", FS_name[index]);
	is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_STATE, 0,
					    "Not configured", &FS_bytes_put);
	return False;
      }else {
        printf ("\n%s -- zeroing ...", FS_name[index]);

	my_hist_no   = ntohl (rqst->u.zero.hist_no);
	my_first_bin = ntohl (rqst->u.zero.first_bin);
        my_nbins     = ntohl (rqst->u.zero.n_bins);

	FS_do_zero (reply, index, my_nbins, my_first_bin, my_hist_no);
	is = FS_rply_status_send (skt, reply, &FS_bytes_put);
	if (!is) {
	  printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
	}else {
	  printf (" done.\n");
	}
	return is;
      }

     default:
      printf ("\n%s: Unrecognised command received ...\n", FS_name[index]);
      is = FS_rply_status_setup_and_send (skt, reply, KER__BAD_VALUE, 0,
				"Unrecognised command!", &FS_bytes_put);
      if (!is) {
	printf ("\n%s -- send of status reply failed.\n", FS_name[index]);
      }else {
	printf (" it has been acknowledged.\n");
      }
      return is;
    }
    printf ("\nSoftware error in do_command - switch statement completed!\n");
    return False;
  }
/*
**--------------------------------------------------------------------------
**	    FS_do_config:  ...
*/
  int	FS_do_config (
/*	============
*/		int			 skt,
		struct req_buff_struct  *request,
		struct rply_buff_struct *reply) {

    int			i, n_bytes_got, iret, return_status;
    uint		bytes_needed, n_extra, n_edges, n_banks;
    uint		sizeof_edge_arr, n_bins, flag;
    uint		lo_cntr, hi_cntr, n_cntrs, slv_lo_cntr, slv_hi_cntr;
    char		    *p_addr;
    struct tof_bank	    *p_bank;
    struct req_buff_struct  *my_rqu;
    struct rply_buff_struct  my_rply;

    FS_mode_ALL = ntohl (request->u.cnfg.mode);	/* The histogramming mode */

    FS_mode	    = FS_mode_ALL & (~SQHM__SUB_MODE_MSK);
    FS_mode_DEBUG   = FS_mode_ALL & SQHM__DEBUG;
    FS_mode_UD	    = FS_mode_ALL & SQHM__UD;
    FS_mode_BO	    = FS_mode_ALL & SQHM__BO_MSK;
    FS_mode_STROBO  = FS_mode_ALL & SQHM__STROBO;
    FS_mode_REFLECT = FS_mode_ALL & SQHM__REFLECT;
    FS_mode_NO_STAT = FS_mode_ALL & SQHM__NO_STAT;

    if (FS_mode != SQHM__TOF) {	    /* The mode must be TOF */
      printf ("\nFS_do_config: mode is not TOF\n");
      return False;
    }
	    /*
	    ** For complicated configurations, there may be more config
	    ** data to be read. If so n_extra_bytes will be non-zero.
	    */
    n_extra = ntohl (request->u.cnfg.u.tof.n_extra_bytes);
    if (n_extra != 0) {
	    /*
	    ** There is extra data to be read. Get buffer space for the
	    ** extra stuff plus space to copy over what has already been
	    ** read so that everything is in a contiguous buffer.
	    */
      bytes_needed = n_extra + sizeof (*request);
      bytes_needed = (bytes_needed + 3) & (~3);	/* Round up to multiple of 4 */
      p_addr = malloc (bytes_needed);
      if (p_addr == NULL) {
	printf ("\nFS_do_config:"
	    " cannot allocate memory for extra config data!\n");
	net_flush (skt, n_extra);
	rply_status_setup (reply, KER__BAD_ALLOC, 0,
	    "Failed to get buffer for extra config data");
	return False;
      }
      my_rqu = (struct req_buff_struct *) p_addr;
      memcpy (p_addr, request, sizeof (*request));  /* Copy in what has already
						    ** been read. */
      bytes_needed = n_extra;		/* And read the rest */
      p_addr += sizeof (*request);
      while (bytes_needed > 0) {
	n_bytes_got = recv (skt, p_addr, bytes_needed, 0);
	if (n_bytes_got <= 0) break;
	FS_bytes_got += n_bytes_got;
	bytes_needed -= n_bytes_got;
	p_addr += n_bytes_got;
      }
      if (n_bytes_got < 0) {
	printf ("\n"
	    "%s -- R/W-Socket recv error\n"
	    "%s -- Connection will be closed.\n", FS_name[0], FS_name[0]);
	rply_status_setup (reply, KER__BAD_VALUE, 0, "recv failed");
	free (my_rqu);
	return False;
      }
    }else {
      my_rqu = request;
    }

    n_bins = ntohl (my_rqu->u.cnfg.u.tof.edge_0.n_bins);
    flag   = ntohl (my_rqu->u.cnfg.u.tof.edge_0.flag);
    if ((flag & FLAG__VAR_BIN) != 0) {
      sizeof_edge_arr = OffsetOf (struct tof_edge_arr, edges) +
			((n_bins + 1) * sizeof (uint));
      FS_compress = 0;
    }else {
      sizeof_edge_arr = sizeof (struct tof_edge_arr);
      FS_compress = ntohl (my_rqu->u.cnfg.u.tof.edge_0.edges[1]) -
			ntohl (my_rqu->u.cnfg.u.tof.edge_0.edges[0]);
    }
    p_bank = (struct tof_bank *) (
		(char *) &my_rqu->u.cnfg.u.tof.edge_0 + sizeof_edge_arr);


    n_edges = ntohs (my_rqu->u.cnfg.u.tof.n_edges);
    n_banks = ntohs (my_rqu->u.cnfg.u.tof.n_banks);
    if ((n_edges != 1) || (n_banks != 1)) {
      printf ("\nFS_do_config: configuration is too complex.\n");
      return False;
    }
    lo_cntr = ntohl (p_bank->first);
    n_cntrs = ntohl (p_bank->n_cntrs);
    hi_cntr = lo_cntr + n_cntrs -1;
		    /*
		    ** Now loop sending the configuration request to
		    ** all slaves.
		    */
    return_status = True;		    /* Assume all will be OK */
    for (i = 0; i < FS_n_slaves; i++) {
      if (FS_slaves[i] != NULL) {
	slv_lo_cntr = (FS_lo_det[i] > lo_cntr) ? FS_lo_det[i] : lo_cntr;
	slv_hi_cntr = (FS_hi_det[i] < hi_cntr) ? FS_hi_det[i] : hi_cntr;
	if (slv_hi_cntr >= slv_lo_cntr) {
	  FS_slv_active[i] = True;
	  p_bank->first	  = htonl (slv_lo_cntr - FS_lo_det[i]);
	  p_bank->n_cntrs = htonl (slv_hi_cntr - slv_lo_cntr + 1);
	  iret = FS_send_cmnd_to_mstr (&FS_rmt_socknam[i],
		my_rqu, (sizeof (*request) + n_extra),
		&my_rply, &FS_bytes_got, &FS_bytes_put);
	  if (iret && (ntohl (my_rply.status) != KER__SUCCESS)) {
	    reply->status     = my_rply.status;
	    reply->sub_status = my_rply.sub_status;
	    StrJoin (reply->u.message, sizeof (reply->u.message),
				FS_slaves[i], ": ");
	    StrJoin (reply->u.message, sizeof (reply->u.message),
				reply->u.message, my_rply.u.message);
	    FS_slv_active[i] = False;
	    return_status = False;
	    break;
	  }
	}else {
	  FS_slv_active[i] = False;
	}
      }
    }

    if (!return_status) {   /* If any error, force deconfig */
      FS_deconfig_all (1);
      return return_status;
    }

    FS_lo_cntr = lo_cntr;
    FS_hi_cntr = hi_cntr;
    FS_lo_bin = 0;
    FS_hi_bin = n_bins - 1;
    FS_bpb = ntohl (p_bank->bytes_per_bin);
    FS_totl_bytes = FS_bpb * (FS_hi_cntr - FS_lo_cntr + 1) *
				(FS_hi_bin - FS_lo_bin + 1);

    if (n_extra != 0) free (my_rqu);
    return return_status;
  }
/*
**--------------------------------------------------------------------------
**	    FS_do_daq:  Handle an SQHM_DAQ command.
*/
  int	FS_do_daq (
/*	=========
*/		int			 indx,
		int			 sub_cmnd,
		struct req_buff_struct  *request,
		struct rply_buff_struct *reply) {

    int		i, iret, all_ok = True;

    if (sub_cmnd == DAQ__TST) {	    /* DAQ__TST is special - we just give the ..
				    ** .. caller a snapshot of our status ..
				    ** .. without invoking our slaves. */
      reply->status = htonl (KER__SUCCESS);
      reply->u.daq.daq_was = htons (FS_dsbl_mask);
      reply->u.daq.filler_mask = htons (FS_srv_masks[0]);
      reply->u.daq.server_mask = htons (FS_srv_masks[indx]);
      reply->u.daq.daq_now = reply->u.daq.daq_was;
    }else {
		/*
		** Claim the sem to avoid race conditions with other threads
		*/
      if (FS_use_sem_tmo) {
	iret = semTake (FS_sem_daq, FS_sem_tmo);
      }else {
	iret = semTake (FS_sem_daq, WAIT_FOREVER);
      }
			/*
			** Loop sending the SQHM_DAQ command to active slaves
			*/
      request->bigend	      = htonl (0x12345678);
      request->cmnd	      = htonl (SQHM_DAQ);
      request->u.daq.sub_cmnd = htonl (sub_cmnd);
      for (i = 0; i < FS_n_slaves; i++) {
	if (FS_slv_active[i]) {
	  if (indx == 0) {	/* If we are the master-server, send it to the
				** master-servers in the slaves. */
	    iret = FS_send_cmnd_to_mstr (&FS_rmt_socknam[i],
		    request, sizeof (*request), reply,
		    &FS_bytes_got, &FS_bytes_put);
	    if (!iret || (ntohl (reply->status) != KER__SUCCESS)) all_ok=False;
	  }else {
	    iret = rqst_send_get (FS_skt[indx][i], request, sizeof (*request),
			 reply, sizeof (*reply),
			 &FS_bytes_got, &FS_bytes_put, FS_name[indx]);
	    if (!iret || (ntohl (reply->status) != KER__SUCCESS)) all_ok=False;
	  }
	}
      }
      if (!all_ok) {		/* If error, go no further! */
	semGive (FS_sem_daq);
	return all_ok;
      }
      reply->status = htonl (KER__SUCCESS);
      reply->u.daq.daq_was = htons (FS_dsbl_mask);
      reply->u.daq.filler_mask = htons (FS_srv_masks[0]);
      reply->u.daq.server_mask = htons (FS_srv_masks[indx]);
      switch (sub_cmnd) {
       case DAQ__CLR:
	FS_dsbl_mask &= (~FS_srv_masks[indx]);  /* Clear user's mask bit. */
	break;
       case DAQ__GO:
	FS_dsbl_mask &= (~FS_srv_masks[0]);	/* Clear "filler's" mask bit. */
	break;
       case DAQ__INH:
	FS_dsbl_mask |= FS_srv_masks[indx];	    /* Set user's mask bit */
	break;
       case DAQ__STOP:
	FS_dsbl_mask |= FS_srv_masks[0];	/* Set "filler's" mask bit. */
      }
      reply->u.daq.daq_now = htons (FS_dsbl_mask);  /* Complete the status
						    ** response message */
      iret = semGive (FS_sem_daq);	    /* Release the semaphore */
    }
    return all_ok;
  }
/*
**--------------------------------------------------------------------------
**	    FS_do_project:  Read a "rectangular" region of Hist Mem and send it
**			    to the client.
*/
  int	FS_do_project (
/*	=============
*/		int			index,
		struct rply_buff_struct *rply_bf,
		int			rw_skt,
		int			pkt_size,
		uint			sub_code,
		uint			x_lo,
		uint			nx,
		uint			y_lo,
		uint			ny,
		uint			xdim,
		uint			h_slct) {
/*
**                  Read a "rectangular" region of Hist Mem and send it
**		    to the client.
*/
    uint		    my_bin_lo,  my_bin_hi;
    uint		    my_cntr_lo, my_cntr_hi;
    int			    i, is, nput, my_daq_save;
    uint		    my_nbins, bins_to_go, bytes_in_buff, bytes_to_go;
    uchar		   *buff_pntr;
    char		    recd[132], *nxt;
    struct req_buff_struct  my_rqst;
    struct rply_buff_struct my_rply;

    register union {
      void	    *base;
      uchar	    *ch;
      usint	    *i2;
      uint	    *i4;
    } my_pntr0, my_pntr1;

    rply_status_setup (rply_bf, KER__BAD_VALUE, 0, "Bad argument"); /* Assume ..
						** .. we shall find a bad arg */
/*--------------------------------------------------------------------
**	    There's no need to test the hist mode; it must be SQHM_TOF because
**	    SQHM_CONFIG rejects anything else. So, start by checking arguments.
*/
    if ((sub_code & PROJECT__1_DIM) != 0) {
      printf ("\n%s -- SQHM_PROJECT: SQHM__TOF+PROJECT__1_DIM not yet "
			"implemented!\n", FS_name[index]);
      is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__BAD_VALUE, 0,
			    "Not yet implemented", &FS_bytes_put);
      return OK;
    }
				/* Check the arguments */
				/* Check that counter numbers are in range */
    my_cntr_lo = y_lo;
    if ((my_cntr_lo < FS_lo_cntr) ||
	(my_cntr_lo > FS_hi_cntr)) {
      printf ("\n%s -- SQHM_PROJECT: Bad y_lo!\n", FS_name[index]);
      is = FS_rply_status_send (rw_skt, rply_bf, &FS_bytes_put);
      return OK;
    }
    my_cntr_hi = (ny != 0) ? (y_lo + ny - 1) : FS_hi_cntr;
    if ((my_cntr_hi < my_cntr_lo) || (my_cntr_hi > FS_hi_cntr)) {
      printf ("\n%s -- SQHM_PROJECT: Bad ny!\n", FS_name[index]);
      is = FS_rply_status_send (rw_skt, rply_bf, &FS_bytes_put);
      return OK;
    }
				/* Check that bin numbers are in range */
    my_bin_lo = x_lo;
    if ((my_bin_lo < FS_lo_bin) ||
	(my_bin_lo > FS_hi_bin)) {
      printf ("\n%s -- SQHM_PROJECT: Bad x_lo!\n", FS_name[index]);
      is = FS_rply_status_send (rw_skt, rply_bf, &FS_bytes_put);
      return OK;
    }
    my_bin_hi = (nx != 0) ?
		    (x_lo + nx - 1) : FS_hi_bin;
    if ((my_bin_hi < my_bin_lo) ||
	(my_bin_hi > FS_hi_bin)) {
      printf ("\n%s -- SQHM_PROJECT: Bad nx!\n", FS_name[index]);
      is = FS_rply_status_send (rw_skt, rply_bf, &FS_bytes_put);
      return OK;
    }
		    /*
		    ** All the arguments have been checked. Reserve some space
		    ** for projecting the data. The amount of space that we
		    ** need for the projection depends on whether the
		    ** projection is onto the x-axis or y-axis.
		    */
    my_nbins = ((sub_code & PROJECT__ON_Y) == 0) ?
		    (my_bin_hi - my_bin_lo + 1) : (my_cntr_hi - my_cntr_lo + 1);

    my_pntr0.base = calloc (my_nbins, sizeof (uint));
    my_pntr1.base = calloc (my_nbins, sizeof (uint));
    if ((my_pntr0.base == NULL) || (my_pntr1.base == NULL)) {
      printf ("\n%s -- SQHM_PROJECT: failed to get buffer!\n",
				FS_name[index]);
      FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__BAD_ALLOC, 0,
	    "Failed to get buffer for projecting data", &FS_bytes_put);
      return OK;
      free (my_pntr1.base);
    }
		    /*-----------------------------------------------------
		    ** We got some buffer space so inhibit data acqu ...
		    */
    my_daq_save = FS_dsbl_mask & FS_srv_masks[index]; /* Remember the ..
			** .. state of our inhibit bit and disable data acq
			** .. if not already disabled by us. This is necessary
			** .. to prevent data "skewing" as we read out our
			** .. 3 slaves. */
    if (my_daq_save == 0) FS_do_daq (index, DAQ__INH, &my_rqst, &my_rply);
		    /*-----------------------------------------------------
		    ** ... then do the projection ...
		    */
    bins_to_go = FS_project_hm (index, pkt_size,
		    my_pntr0.base, my_pntr1.base, my_nbins,
		    sub_code, my_cntr_lo, my_cntr_hi, my_bin_lo, my_bin_hi);
    if (bins_to_go <= 0) {
      if (my_daq_save == 0) FS_do_daq (index, DAQ__CLR, &my_rqst, &my_rply);
      perror (StrJoin (recd, sizeof (recd),
		    FS_name[index], "/FS_do_project: FS_project_hm error"));
      free (my_pntr0.base);
      free (my_pntr1.base);
      return False;
    }
		    /*-----------------------------------------------------
		    ** ... projection complete so let Filler continue and
		    **     send data back to client.
		    */
    if (my_daq_save == 0) FS_do_daq (index, DAQ__CLR, &my_rqst, &my_rply);

    rply_bf->u.project.n_bins	     = htonl (my_nbins);
    rply_bf->u.project.bytes_per_bin = htonl (sizeof (uint));
    rply_bf->u.project.cnts_lo	     = htonl (0);
    rply_bf->u.project.cnts_hi	     = htonl (0);

    if (rply_bf->bigend != 0x12345678) {    /* If byte swapping needed, ...
					    ** .. then swap them! */
      for (i = 0; i < my_nbins; i++) my_pntr0.i4[i] = htonl (my_pntr0.i4[i]);
    }

    is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__SUCCESS, 0,
		    NULL, &FS_bytes_put);

    bytes_to_go = my_nbins * sizeof (uint);
    buff_pntr = (uchar *) my_pntr0.base;

    while (bytes_to_go > 0) {
      nput = (bytes_to_go > pkt_size) ? pkt_size : bytes_to_go;
      is = send (rw_skt, buff_pntr, nput, 0);
      if (is > 0) {
	FS_bytes_put += is;
	bytes_to_go  -= is;
	buff_pntr    += is;
      }else {
	free (my_pntr0.base);
        free (my_pntr1.base);
	return ERROR;	    /* Fatal error on send */
      }
    }
    free (my_pntr0.base);	    /* Release our bit of memory */
    free (my_pntr1.base);
    return True;
  }
/*
**--------------------------------------------------------------------------
**	    FS_do_read:	    Read a consecutive region of 'nbins' bins of the
**			    Hist Mem starting with bin 'first' and send it to
**			    the client.
*/
  int	FS_do_read (
/*	==========
*/		int			index,
		struct rply_buff_struct *rply_bf,
		int			rw_skt,
		int			pkt_size,
		uint			nbins,
		uint			first,
		uint			hist_no) {

    register int	    i, my_fstbin, my_topbin;
    int			    is, status, bytes_to_go, nput, nxtbin, nb;
    int			    my_daq_save;
    uint		    maxbins, my_nbins, bins_in_buff;
    uint		    nxtbin_to_send, nbins_to_send, bytes_in_buff;
    uint		    bins_to_go, lastbin;
    struct req_buff_struct  my_rqst;
    struct rply_buff_struct my_rply;
    uchar		    *buff_pntr, *last_byte, *nxt;
    uchar		    buff[pkt_size];

    register union {
      void	    *base;
      uchar	    *ch;
      usint	    *i2;
      uint	    *i4;
    } my_pntr, hm_pntr;
/*--------------------------------------------------------------------
**	    There's no need to test the hist mode; it must be SQHM_TOF because
**	    SQHM_CONFIG rejects anything else. So, start by checking arguments.
*/
    maxbins = (FS_hi_cntr - FS_lo_cntr + 1) * (FS_hi_bin - FS_lo_bin + 1);
/***************************************************************/
/***************************************************************/
    if ((hist_no == -1) || (hist_no == 0)) {
		/* Regard the histograms as 1 long array */
      if ((first == -1) && (nbins == -1)) {
		/* The user just wants to read everything */
	my_fstbin = 0;
	my_nbins  = maxbins;
      }else {
		/* The user wants a part of the histogram data */
	if (first >= maxbins) {
	  if (FS_dbg_lev0) printf (
	       "\n%s -- SQHM_READ: bad first_bin %d!\n", FS_name[index], first);
	  is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__BAD_VALUE,
			    0, "\"first_bin\" too big", &FS_bytes_put);
	  return is;
	}else if ((nbins > maxbins) || ((first + nbins) > maxbins)) {
	  if (FS_dbg_lev0) printf (
		"\n%s -- SQHM_READ: bad n_bins %d!\n", FS_name[index], nbins);
	  is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__BAD_VALUE,
			    0, "\"n_bins\" too big", &FS_bytes_put);
	  return is;
	}
	my_fstbin = first;
	my_nbins  = nbins;
      }
    }else {
		/* The user wants a part of the histogram of a single counter */
      if ((hist_no < FS_lo_cntr) || (hist_no > FS_hi_cntr)) {
	if (FS_dbg_lev0) printf (
		"\n%s -- SQHM_READ: bad hist_no!\n", FS_name[index]);
	is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__BAD_VALUE,
			    0, "\"hist_no\" out of range", &FS_bytes_put);
	return is;
      }else if ((first < FS_lo_bin) || (first > FS_hi_bin)) {
	if (FS_dbg_lev0) printf (
		"\n%s -- SQHM_READ: bad first_bin!\n", FS_name[index]);
	is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__BAD_VALUE,
			    0, "\"first_bin\" out of range", &FS_bytes_put);
	return is;
      }else if ((nbins > (FS_hi_bin - FS_lo_bin + 1)) ||
		((first + nbins) > (FS_hi_bin + 1))) {
	if (FS_dbg_lev0) printf (
		"\n%s -- SQHM_READ: bad n_bins!\n", FS_name[index]);
	is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__BAD_VALUE,
			    0, "\"n_bins\" out of range", &FS_bytes_put);
	return is;
      }
      my_fstbin = (hist_no - FS_lo_cntr) * (FS_hi_bin - FS_lo_bin + 1) + first;
      my_nbins  = nbins;
    }
/***************************************************************/
		    /*
		    ** The args are OK.
		    ** Set up fixed buffer to do transfer
		    */
    my_pntr.base = NULL;
    my_pntr.base = readBuffer;
    bins_in_buff = READBUFSIZE/FS_bpb;

    if (my_pntr.base == NULL ) {
      if (FS_dbg_lev0) printf (
		"\n%s -- SQHM_READ: no buffer space available!\n",
					    FS_name[index]);
      is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__BAD_VALUE,
			    0, "No buffer space", &FS_bytes_put);
      return is;
    }
		    /*
		    ** The args are OK and we have some buffer space.
		    ** Tell client he's about to get some data!
		    */
    rply_bf->u.read.first_bin	    = htonl (my_fstbin);
    rply_bf->u.read.n_bins	    = htonl (my_nbins);
    rply_bf->u.read.bytes_per_bin   = htonl (FS_bpb);
    rply_bf->u.read.cnts_lo	    = 0;    /* \  cnts_lo and cnts_hi not */
    rply_bf->u.read.cnts_hi	    = 0;    /* /  yet implemented	  */
    is = FS_rply_status_setup_and_send (rw_skt, rply_bf, KER__SUCCESS,
				    0, NULL, &FS_bytes_put);

    my_daq_save = FS_dsbl_mask & FS_srv_masks[index]; /* Remember the ..
			** .. state of our inhibit bit and disable data acq
			** .. if not already disabled by us. This is necessary
			** .. to prevent data "skewing" as we read out our
			** .. 3 slaves. */
    if (my_daq_save == 0) FS_do_daq (index, DAQ__INH, &my_rqst, &my_rply);
    nxtbin_to_send = my_fstbin;
    nbins_to_send = my_nbins;
    bytes_in_buff = 0;
    nxt = (char *) my_pntr.base;

    while (nbins_to_send > 0) {
				    /* Read some histogram data into buffer */
      lastbin = nxtbin_to_send + bins_in_buff;
      if(lastbin > my_nbins-1){
	lastbin = my_nbins-1;
      }
      bins_to_go = FS_read_hm (index, pkt_size,
				my_pntr.base, bins_in_buff,
				nxtbin_to_send, lastbin);
      if (bins_to_go <= 0) {
	perror (StrJoin (buff, pkt_size,
		    FS_name[index], "/FS_do_read: FS_read_hm error"));
	free (my_pntr.base);
	if (my_daq_save == 0) FS_do_daq (index, DAQ__CLR, &my_rqst, &my_rply);
	return False;
      }
      nxt = (char *) my_pntr.base;
      bytes_in_buff = bins_to_go * FS_bpb;
      while (bytes_in_buff > 0) {	    /* Send data to user */
	bytes_to_go = (bytes_in_buff > pkt_size) ? pkt_size : bytes_in_buff;
	is = send (rw_skt, nxt, bytes_to_go, 0);
	if (is <= 0) {
	  perror (StrJoin (buff, pkt_size,
		    FS_name[index], "/FS_do_read: send error"));
	  free (my_pntr.base);
	  if (my_daq_save == 0) FS_do_daq (index, DAQ__CLR, &my_rqst, &my_rply);
	  return False;
	}
	FS_bytes_put += bytes_to_go;
	bytes_in_buff -= bytes_to_go;
	nxt += bytes_to_go;
      }
      nxtbin_to_send += bins_to_go;
      nbins_to_send  -= bins_to_go;
    }

		    /*
		    ** Read-out complete so let DAQ continue.
		    */
    if (my_daq_save == 0) FS_do_daq (index, DAQ__CLR, &my_rqst, &my_rply);
    return True;
  }
/*
**--------------------------------------------------------------------------
**	    FS_do_write:    Preset a consecutive region of the Hist Mem. The
**			    number of bins to preset is 'nbins' starting with
**			    bin 'first'. The data for the bins is read from
**			    the client.
*/
  int	FS_do_write (
/*	===========
*/		int			index,
		struct req_buff_struct	*req_bf,
		struct rply_buff_struct *rply_bf,
		int			rw_skt,
		int			pkt_size,
		int			nbins,
		int			first,
		int			bytes_per_bin,
		int			hist_no) {
    return True;
  }
/*
**--------------------------------------------------------------------------
**	    FS_do_zero:	    Action routine for SQHM_ZERO command.
 *
 * This is only partially functional. The definition for SQHM_ZERO states
 * that it is possible to zero only parts of the histogram. The version
 * below just forwards a full zero request to all slaves and thus fits
 * the bill for FOCUS. Probably for any other instrument as well.
 *  
 * Mark Koennecke, November 2000 
*/
  int	FS_do_zero (
/*	===========
*/		struct rply_buff_struct *reply,
		int			indx,
		int			nbins,
		int			first_bin,
		int			hist_no) {

    int		i, iret, all_ok = True;
    struct req_buff_struct request;

    /*
      set up the request structure which zeros the whole histogram
    */
    request.bigend = htonl(0x12345678);
    request.cmnd   = htonl(SQHM_ZERO);
    request.u.zero.hist_no = htonl(-1);
    request.u.zero.first_bin = htonl(-1);
    request.u.zero.n_bins = htonl(-1);

		/*
		** Claim the sem to avoid race conditions with other threads
		*/
    if (FS_use_sem_tmo) {
	iret = semTake (FS_sem_daq, FS_sem_tmo);
    }else {
	iret = semTake (FS_sem_daq, WAIT_FOREVER);
    }

    /*
      send the request to all known slaves 
    */
      for (i = 0; i < FS_n_slaves; i++) {
	if (FS_slv_active[i]) {
	  if (indx == 0) {	/* If we are the master-server, send it to the
				** master-servers in the slaves. */
	    iret = FS_send_cmnd_to_mstr (&FS_rmt_socknam[i],
		    &request, sizeof (request), reply,
		    &FS_bytes_got, &FS_bytes_put);
	    if (!iret || (ntohl (reply->status) != KER__SUCCESS)) all_ok=False;
	  }else {
	    iret = rqst_send_get (FS_skt[indx][i], &request, sizeof (request),
			 reply, sizeof (*reply),
			 &FS_bytes_got, &FS_bytes_put, FS_name[indx]);
	    if (!iret || (ntohl (reply->status) != KER__SUCCESS)) all_ok=False;
	  }
	}
      }
      if (!all_ok) {		/* If error, go no further! */
        printf("Error zeroing histogram no %d\n", i);
	semGive (FS_sem_daq);
	return all_ok;
      }

      /*
       tell the world about our success 
      */
      reply->status = htonl (KER__SUCCESS);

      /* release semaphore */
      semGive (FS_sem_daq);


    return True;
  }
/*
**--------------------------------------------------------------------------
**	    FS_free_memory: Free any memory allocated for FOCUS_srv
*/
  void	FS_free_memory (
/*	==============
*/		    void *extras) {

    int	    i;
			/*
			** Release a possible pending buffer
			*/
    free (extras);
			/*
			** Release any allocated histogram buffer
			*/
    free (FS_base_addr);
    FS_base_addr = NULL;
  }
/*
**--------------------------------------------------------------------------
**	    FS_kill_children:	Send signals to all our offspring to cause
**				them to terminate.
*/
  void	FS_kill_children (
/*	================
*/		    int	     max_chld,
		    pid_t   *pids,
		    char   **tsk_names,
		    char    *filler_name) {

    int	    i, is;

    if (pids[0] != 0) {
      printf (" .. closing down %s ..", filler_name);
      is = kill (pids[0], SIGINT);
      if (!is) printf ("\nBad status killing %s.\n", filler_name);
    }
    for (i = 1; i <= max_chld; i++) {
      if (pids[i] != 0) {
        printf ("\n    Terminating %s ..", tsk_names[i]);
        is = kill (pids[i], SIGINT);
	if (is == ERROR) printf ("\nBad status killing %s.\n", tsk_names[i]);
      }
    }
  }
/*
**--------------------------------------------------------------------------
**	    FS_make_child:  Find a free child index, create a child process and
**		    invoke procedure proc in the child procedure.
**		    Return value >= 0 if child successfully created;
**				 = -1 if error returned by fork;
**				 = -2 if there are too many children already;
**				 = -3 if time-out waiting for child to signal.
**				 < -3 the child indicated a start-up error. The
**					child's error code is the return
**					value + 3.
*/
  int	FS_make_child (
/*	=============
*/		int   (* proc) (),  /* The procedure to be started */
		int	 prty,	    /* The child's priority */
		int	 spnd,	    /* "Suspend" flag to help debug the child */
		int	 pkt_size,  /* TCP/IP packet size to be used */
		int	 max_chld,  /* The size of the following arrays */
		pid_t	*pids,	    /* Array of PIDs of children */
		int	*exit_stat, /* Array of children's exit stati */
		int	*pcnt_SIGUSR1,	/* Flag set on SIGUSR1 signals whenever
					** a child exits. */
		char	*name) {    /* Prefix for child's name */
		
    int	    i, status, tmo;
    pid_t   created_pid;
    char    tsknam[20];
    SEM_ID  my_sem;
/*
**	    Find a free PID index. Zero is not a permitted value.
*/
    for (i = 1; i <= max_chld; i++) if (pids[i] == 0) break;

    if (i > max_chld) {		/* Free index found? */
      return -2;		/* No, there are already too many children. */
    }else {
      if (pcnt_SIGUSR1 != NULL) *pcnt_SIGUSR1 = 0;
      my_sem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);  /* Create a claimed sem-
				** -aphore which the child can release when
				** it has finished its initialisation. */
      exit_stat[i] = 0;		/* Zero child's status indicator */
      sprintf (tsknam, "%.*s%02d", (sizeof (tsknam) - 3),
			name, i);	    /* Generate the child's name */
      created_pid = taskSpawn (		    /* Make a child */
			tsknam,		    /* Name */
			prty,		    /* Priority */
			VX_FP_TASK,	    /* Options - fl.pt. usage assumed */
			20000,		    /* Stack size */
			proc,		    /* The entry point */
			FS_pid, (int) my_sem, i, pkt_size, spnd,
			(int) &exit_stat[i],
			0, 0, 0, 0);
      if (created_pid == ERROR) {	    /* Error? */
        return -1;			    /* Yes. */
      }else {				    /* Parent */
	pids[i] = created_pid;
	tmo = 1000;		    /* Normally give child 1000 ticks to ..
				    ** .. get going */
	if (spnd != 0) {
	  tmo = WAIT_FOREVER;	    /* But in debug mode, wait forever! */
	}
	status = semTake (my_sem, tmo);	    /* Wait for child to get going */
	semDelete (my_sem);
	if (status == ERROR) {		    /* Timeout? */
	  taskDelete (pids[i]);		    /* Yes, kill child. */
	  pids[i] = 0;
	  return -3;			    /* Return with error. */
	}else {				/* No timeout so child is ready. */
	  if (exit_stat[i] >= 0) {	/* Did the child have a startup ..
					** .. problem */
	    return i;			/* No, so return its index */
	  }else {
	    return (exit_stat[i] - 3);	/* Yes, so return error */
	  }
	}
      }
    }
  }
/*
**--------------------------------------------------------------------------
**	    FS_project_hm: Project a block of histogram data.
**
**		Return value = # of bins in buffer, each of size uint.
**		Notes:
**		  This is an internal routine so all args are assumed to be OK.
*/
  int	FS_project_hm (
/*	=============
*/		int	     index,
		int	     pkt_size,
		uint	    *buff,	    /* Buffer to receive the data */
		uint	    *w_buff,	    /* Workspace */
		uint	     blen_in_bins,  /* Size of buff and w_buff in bins */
		uint	     sub_code,	    /* 0 or PROJECT__ON_Y */
		uint	     lo_cntr,	    /* First counter wanted */
		uint	     hi_cntr,	    /* Last counter wanted */
		uint	     fst_bin,	    /* First bin wanted */
		uint	     lst_bin) {	    /* Last bin wanted */

    int			    i, j, k, nx, ny, iret;
    uint		    s_lo_cntr, s_hi_cntr, bytes_to_come;
    uint		    f_cntr, l_cntr, n_cntr_got;
    uint		    f_bin,  l_bin,  n_bins_got;
    uchar		   *b_pntr;
    struct req_buff_struct  my_rq;
    struct rply_buff_struct my_rp;
			/*
			** There are 2 cases: project on x and project on y.
			** Project on x is expected to be the more common!
			*/
    if (sub_code != PROJECT__ON_Y) {
      n_cntr_got = 0;			/* Project on X */
      memset (buff, 0, (blen_in_bins * sizeof (uint)));	/* Zero the buffer */
      for (i = 0; i < FS_n_slaves; i++) { /* Find which slave(s) has the wanted data */
	s_lo_cntr = FS_lo_det[i];
	s_hi_cntr = FS_hi_det[i];
	if (((s_lo_cntr >= lo_cntr) && (s_hi_cntr <= hi_cntr)) ||
	    ((s_lo_cntr <  lo_cntr) && (s_hi_cntr >  hi_cntr)) ||
	    ((s_lo_cntr <  lo_cntr) && (s_hi_cntr >= lo_cntr)) ||
	    ((s_lo_cntr <= hi_cntr) && (s_hi_cntr >  hi_cntr))) {
	  f_cntr = (s_lo_cntr >= lo_cntr) ? 0 : (lo_cntr - s_lo_cntr);
	  l_cntr = (s_hi_cntr <= hi_cntr) ? (s_hi_cntr - s_lo_cntr) :
					    (hi_cntr - s_lo_cntr);
	  my_rq.bigend             = htonl (0x12345678);
	  my_rq.cmnd               = htonl (SQHM_PROJECT);
	  my_rq.u.project.sub_code = htonl (0);
	  my_rq.u.project.x_lo     = htonl (fst_bin);
	  my_rq.u.project.nx       = htonl (lst_bin - fst_bin + 1);
	  my_rq.u.project.y_lo     = htonl (f_cntr);
	  my_rq.u.project.ny       = htonl (l_cntr - f_cntr + 1);
	  my_rq.u.project.xdim     = htonl (0);
	  my_rq.u.project.nhist    = htonl (0);
	  iret = rqst_send_get (FS_skt[index][i], &my_rq, sizeof (my_rq),
				&my_rp, sizeof (my_rp),
				&FS_bytes_put, &FS_bytes_got, FS_name[index]);
	  if (!iret) {return 0;};
	  if (ntohl (my_rp.status) != KER__SUCCESS) {return 0;};
	  nx = ntohl (my_rp.u.project.n_bins);	/* # of bins to be read */
	  bytes_to_come = nx * ntohl (my_rp.u.project.bytes_per_bin);
	  b_pntr = (uchar *) w_buff;
	  while (bytes_to_come > 0) {
	    j = (bytes_to_come > pkt_size) ? pkt_size : bytes_to_come;
	    k = recv (FS_skt[index][i], b_pntr, j, 0);
	    if (k <= 0) {perror ("FS_project_hm"); return 0;}
	    bytes_to_come -= k;
	    b_pntr += k;
	  }
	  k = l_cntr - f_cntr + 1;
	  n_cntr_got += k;
	  lo_cntr += k;
	  for (k = 0; k < nx; k++) buff[k] += ntohl (w_buff[k]);
	}
      }
      return nx;
    }else {
      n_cntr_got = 0;			/* Project on Y */
      for (i = 0; i < 3; i++) {	/* Find which slave(s) has the wanted data */
	s_lo_cntr = FS_lo_det[i];
	s_hi_cntr = FS_hi_det[i];
	if (((s_lo_cntr >= lo_cntr) && (s_hi_cntr <= hi_cntr)) ||
	    ((s_lo_cntr <  lo_cntr) && (s_hi_cntr >  hi_cntr)) ||
	    ((s_lo_cntr <  lo_cntr) && (s_hi_cntr >= lo_cntr)) ||
	    ((s_lo_cntr <= hi_cntr) && (s_hi_cntr >  hi_cntr))) {
	  f_cntr = (s_lo_cntr >= lo_cntr) ? 0 : (lo_cntr - s_lo_cntr);
	  l_cntr = (s_hi_cntr <= hi_cntr) ? (s_hi_cntr - s_lo_cntr) :
					    (hi_cntr - s_lo_cntr);
	  my_rq.bigend             = htonl (0x12345678);
	  my_rq.cmnd               = htonl (SQHM_PROJECT);
	  my_rq.u.project.sub_code = htonl (PROJECT__ON_Y);
	  my_rq.u.project.x_lo     = htonl (fst_bin);
	  my_rq.u.project.nx       = htonl (lst_bin - fst_bin + 1);
	  my_rq.u.project.y_lo     = htonl (f_cntr);
	  my_rq.u.project.ny       = htonl (l_cntr - f_cntr + 1);
	  my_rq.u.project.xdim     = htonl (0);
	  my_rq.u.project.nhist    = htonl (0);
	  iret = rqst_send_get (FS_skt[index][i], &my_rq, sizeof (my_rq),
				&my_rp, sizeof (my_rp),
				&FS_bytes_put, &FS_bytes_got, FS_name[index]);
	  if (!iret) {return 0;};
	  if (ntohl (my_rp.status) != KER__SUCCESS) {return 0;};
	  ny = ntohl (my_rp.u.project.n_bins);	/* # of elements to be read */
	  bytes_to_come = ny * ntohl (my_rp.u.project.bytes_per_bin);
	  b_pntr = (uchar *) w_buff;
	  while (bytes_to_come > 0) {
	    j = (bytes_to_come > pkt_size) ? pkt_size : bytes_to_come;
	    k = recv (FS_skt[index][i], b_pntr, j, 0);
	    if (k <= 0) {perror ("FS_project_hm"); return 0;}
	    bytes_to_come -= k;
	    b_pntr += k;
	  }
	  for (k = 0; k < ny; k++) buff[n_cntr_got+k] = ntohl (w_buff[k]);
	  n_cntr_got += ny;
	  lo_cntr += ny;
	}
      }
      return n_cntr_got;
    }
  }
/*
**--------------------------------------------------------------------------
**	    FS_read_hm: Read a block of histogram data.
**
**		Return value = # of bins read.
*/
  int	FS_read_hm (
/*	==========
*/		int	     index,
		int	     pkt_size,
		uchar	    *buff,	    /* Buffer to receive the data */
		uint	     blen_in_bins,  /* Size of buff in bins */
		uint	     fst_bin,	    /* First bin wanted */
		uint	     lst_bin) {	    /* Last bin wanted */

    int			    i, j, k, iret;
    uint		    s_fst_bin, s_lst_bin, bins_per_hist;
    uint		    f_bin, l_bin, bytes_to_come, n_bins_got;
    struct req_buff_struct  my_rq;
    struct rply_buff_struct my_rp;

    bins_per_hist = FS_hi_bin - FS_lo_bin + 1;
    n_bins_got = 0;

    for (i = 0; i < 3; i++) {	/* Find which slave(s) has the wanted data */
      s_fst_bin = 0;
      for (j = 0; j < i; j++) {
	s_fst_bin += (FS_hi_det[j] - FS_lo_det[j] + 1) * bins_per_hist;
      }
      s_lst_bin = s_fst_bin +
	    (FS_hi_det[i] - FS_lo_det[i] + 1) * bins_per_hist - 1;
      if (((s_fst_bin >= fst_bin) && (s_lst_bin <= lst_bin)) ||
	  ((s_fst_bin <  fst_bin) && (s_lst_bin >  lst_bin)) ||
	  ((s_fst_bin <  fst_bin) && (s_lst_bin >= fst_bin)) ||
	  ((s_fst_bin <= lst_bin) && (s_lst_bin >  lst_bin))) {
	f_bin = (s_fst_bin >= fst_bin) ? 0 : (fst_bin - s_fst_bin);
	l_bin = (s_lst_bin <= lst_bin) ? (s_lst_bin - s_fst_bin) :
					    (lst_bin - s_fst_bin);
	my_rq.bigend           = htonl (0x12345678);
	my_rq.cmnd             = htonl (SQHM_READ);
	my_rq.u.read.hist_no   = htonl (-1);
	my_rq.u.read.first_bin = htonl (f_bin);
	my_rq.u.read.n_bins    = htonl (l_bin - f_bin + 1);
	iret = rqst_send_get (FS_skt[index][i], &my_rq, sizeof (my_rq),
				&my_rp, sizeof (my_rp),
				&FS_bytes_put, &FS_bytes_got, FS_name[index]);
	if (!iret) {return 0;};
	if (ntohl (my_rp.status) != KER__SUCCESS) {return 0;};
	k = ntohl (my_rp.u.read.n_bins);	/* # of bins to be read */
	bytes_to_come = k * FS_bpb;
	while (bytes_to_come > 0) {
	  j = (bytes_to_come > pkt_size) ? pkt_size : bytes_to_come;
	  k = recv (FS_skt[index][i], buff, j, 0);
	  if (k <= 0) {perror ("FS_read_hm"); return 0;}
	  bytes_to_come -= k;
	  buff += k;
	}
	k = l_bin - f_bin + 1;
	n_bins_got += k;
	fst_bin += k;
      }
    }
    return n_bins_got;
  }
/*
**--------------------------------------------------------------------------*/
  int	FS_rply_status_send (
/*	===================
*/		int			skt,
		struct rply_buff_struct	*rply_bf,
		uint			*cntr_out) {

    int	    is;

    is = send (skt, (char *) rply_bf, sizeof (*rply_bf), 0);
    if (is == sizeof (*rply_bf)) {
      *cntr_out += is;
      return True;
    }else {
      return False;
    }
  }
/*
**--------------------------------------------------------------------------*/
  int	FS_rply_status_setup_and_send (
/*	=============================
*/		int			skt,
		struct rply_buff_struct	*rply_bf,
		int			status,
		int			sub_status,
		char			*msg,
		uint			*cntr_out) {

    int	    is;

    rply_status_setup (rply_bf, status, sub_status, msg);
    is = FS_rply_status_send (skt, rply_bf, cntr_out);

    return is;
  }
/*
**--------------------------------------------------------------------------
**	    FS_send_cmnd_to_mstr:	Send command to Sinqm-Master process
**					in a slave.
*/
  int	FS_send_cmnd_to_mstr (
/*	====================
*/		    struct sockaddr_in	    *rmt_sockname,
		    struct req_buff_struct  *request,
		    int			     requ_len,
		    struct rply_buff_struct *reply,
		    uint		    *in_cntr,
		    uint		    *out_cntr) {

    int			 status, cnct_skt, rmt_sockname_len, i;
    int			 bytes_to_come, nbytes;
    char		*p_nxt_byte;
    struct sockaddr_in	 lcl_sockname;
/*
**  	   Create a TCP/IP socket for connecting to SINQHM_SRV root and bind it.
*/
    cnct_skt = socket (AF_INET, SOCK_STREAM, 0);
    i = 1;
    setsockopt(cnct_skt,SOL_SOCKET, SO_REUSEADDR, &i,sizeof(int));
    if (cnct_skt == -1) {
      close(cnct_skt);
      failInet ("\nFS_send_cmnd_to_mstr: socket error.");
    }

    setup_host (NULL, &lcl_sockname, 0, False);
    status = bind (cnct_skt, (struct sockaddr *) &lcl_sockname,
					sizeof (lcl_sockname));
    if (status == -1){
      close(cnct_skt);
      failInet ("\nFS_send_cmnd_to_mstr: bind error.");
    }
/*
**		Connect to SINQHM_SRV root.
*/
    rmt_sockname_len = sizeof (*rmt_sockname);
    status = connect (cnct_skt, (struct sockaddr *) rmt_sockname,
				    rmt_sockname_len);
    if (status == -1) {
      close(cnct_skt);
      getErrno (&FS_errno);
      failInet ("\nFS_send_cmnd_to_mstr: connect error");
    }
	    /*
	    ** Send the request to the server
	    */
    status = send (cnct_skt, (char *) request, requ_len, 0);
    if (status == -1) {
      close(cnct_skt);
      failInet ("\nFS_send_cmnd_to_mstr -- send error");
    }
    if (status != requ_len) {
      printf ("\nFS_send_cmnd_to_mstr -- wrong number of bytes sent: %d %d\n",
			status, requ_len);
      close(cnct_skt);
      return False;
    }
    *out_cntr += requ_len;
/*
**		    Wait for the status response.
*/
    bytes_to_come = sizeof (*reply);
    p_nxt_byte = (char *) reply;
    while (bytes_to_come > 0) {
      nbytes = recv (cnct_skt, p_nxt_byte, bytes_to_come, 0);
      if (nbytes <= 0) break;
      *in_cntr += nbytes;
      bytes_to_come -= nbytes;
      p_nxt_byte += nbytes;
    }
    if (nbytes == -1) {
      close(cnct_skt);
      failInet ("\nFS_send_cmnd_to_mstr -- recv error");
      return False;
    }else if (nbytes == 0) {
      printf ("\nFS_send_cmnd_to_mstr -- server has closed connection!\n");
      close(cnct_skt);
      return False;
    }else if (ntohl (reply->bigend) != 0x12345678) {
					    /* Network byte-order wrong! */
      printf ("\nFS_send_cmnd_to_mstr -- big-endian/little-endian problem!\n"
		"    Buffer received in non-network byte order!\n");
      close(cnct_skt);
      return False;
    }
    close(cnct_skt);
    return True;
  }
/*
**--------------------------------------------------------------------------
**	    rqst_send_get:  Send a network request and get reply
*/
  int	rqst_send_get (
/*	=============
*/		int			 skt,
		struct req_buff_struct	*rqst_bf,
		int			 rq_len,
		struct rply_buff_struct	*rply_bf,
		int			 rp_size,
		int			*out_cntr,
		int			*in_cntr,
		char			*tsk_name) {

    int	     status, bytes_to_come, nbytes, n_bytes_got;
    char     recd[80], *p_addr;
		/*
		** Send the request to the server
		*/
    status = send (skt, (char *) rqst_bf, rq_len, 0);
    if (status == -1) {
      perror (StrJoin (recd, sizeof (recd),
		tsk_name, "/rqst_send_get: send error"));
      return False;
    }
    if (status != rq_len) {
      printf ("\n%s/rqst_send_get: wrong number of bytes sent: %d %d\n",
			tsk_name, status, rq_len);
      return False;
    }
    *out_cntr += rq_len;
/*
**		    Wait for the response.
*/
    bytes_to_come = rp_size;
    p_addr = (char *) rply_bf;
    while (bytes_to_come > 0) {
      n_bytes_got = recv (skt, p_addr, bytes_to_come, 0);
      if (n_bytes_got <= 0) break;
      *in_cntr += n_bytes_got;
      bytes_to_come -= n_bytes_got;
      p_addr += n_bytes_got;
    }
    if (n_bytes_got < 0) {
      perror (StrJoin (recd, sizeof (recd),
		tsk_name, "/rqst_send_get: recv error"));
      return False;
    }else if (n_bytes_got == 0) {
      printf ("\n%s/rqst_send_get: zero bytes received!\n", tsk_name);
      return False;
    }else if (ntohl (rply_bf->bigend) != 0x12345678) {
      printf ("\n%s/rqst_send_get: big-endian/little-endian problem!\n",
			    tsk_name);
      return False;
    }
    return True;
  }
/*
**--------------------------------------------------------------------------
**	    setup_host:	Setup Internet structures for a named host
*/
  int	setup_host (
/*	==========
*/		    char		*host,
		    struct sockaddr_in	*sockname,
		    int			 port,
		    int			 verbose) {

    int		     i, j, k, l, m;
    char	     my_host[64], my_addr[32];
    struct in_addr   my_inet_addr;

    if (host == NULL) {
      my_inet_addr.s_addr = 0;
    }else {
      if (strlen (host) >= sizeof (my_host)) return False;
      for (i = 0; i <= strlen (host); i++) my_host[i] = tolower (host[i]);
		/*
		** Try to convert the Internet address. First assume it is dot
		** notation. If this fails, see if we can recognise the name.
		*/
      my_inet_addr.s_addr = inet_addr (my_host);
      if (my_inet_addr.s_addr == ERROR) {
	if (strcmp (my_host, "localhost") == 0) {
	  my_inet_addr.s_addr = inet_addr ("127.0.0.1");
	}else {
	  i = sscanf (my_host, "lnse%d%n", &j, &k);
	  if ((i == 1) && (k == 6)) {
	    if (strcmp (&my_host[k], ".vme") == 0) {
	      sprintf (my_addr, "192.168.11.%d", j);	    /* "lnse??.vme" */
	    }else {
	      sprintf (my_addr, "129.129.62.%d", (100+j));    /* "lnse??" */
	    }
	    my_inet_addr.s_addr = inet_addr (my_addr);
	  }else {
	    i = sscanf (my_host, "psds%d%n", &j, &k);
	    if ((i == 1) && (k == 6) && (my_host[k] == NIL)) {
	      sprintf (my_addr, "129.129.62.%d", j);    /* "psds??" */
	      my_inet_addr.s_addr = inet_addr (my_addr);
	    }
	  }
	}
      }
    }
    if (my_inet_addr.s_addr == ERROR) {
      printf ("\nsetup_host: Node \"%s\" is unknown.\n", host);
      return False;
    }
    if (verbose) {
      printf ("Host is %s ", host);
      inet_ntoa_b (my_inet_addr, my_addr);
      printf ("(%s),", my_addr);
      printf (" Port %d.\n", port);
    }
    sockname->sin_family      = AF_INET;
    sockname->sin_port	      = htons (port);
    sockname->sin_addr.s_addr = my_inet_addr.s_addr;
  }
/*
**--------------------------------------------------------------------------
**	    socket_bind:    Setup an Internet socket and bind it to a port.
*/
  int	socket_bind (
/*	===========
*/		    int	     port,
		    char    *tsk_name) {

    int			status, skt;
    struct sockaddr_in	sockname;
    char		recd[80];

    skt = socket (AF_INET, SOCK_STREAM, 0);
    if (skt == -1) {
      perror (StrJoin (recd, sizeof (recd), tsk_name,
			" -- socket error in socket_bind"));
      return skt;
    }
    status = 1;
    setsockopt(skt,SOL_SOCKET, SO_REUSEADDR, &status, sizeof(int));

    setup_host (NULL, &sockname, port, False);
    status = bind (skt, (struct sockaddr *) &sockname, sizeof (sockname));
    if (status != 0) {
      close (skt);
      perror (StrJoin (recd, sizeof (recd), tsk_name,
			" -- bind error in socket_bind"));
      return -1;
    }
    return skt;
  }
/*
**==============================================================================
**  Main line program
**  ------------------
**============================================================================*/
  int	FOCUS_main (
/*	==========
*/	    char *hostM, int ndetM,
	    char *hostO, int ndetO,
	    char *hostU, int ndetU,
	    int c_port,				/* Our port # as client */
	    int s_port,				/* Our port # for serving */
	    int arg9, int suspend) {
/*============================================================================*/
    struct req_buff_struct	    req_buff;
    struct rply_buff_struct	    rply_buff;

    int			i, j, is, status, cntr;
    int			keep_going = True;
    int			bytes_to_come, n_bytes_got;
    char		*p_addr;
    int			cl_port;
    struct sockaddr_in	lcl_sockname;
    struct sockaddr_in	rmt_sockname;
    int			rmt_sockname_len;
    int			pkt_size;
    time_t		timer;
    char		buff[132];

    sigset_t		proc_sigmask;
    struct sigaction	sig_action;

/*============================================================================
*/
    printf ("\n");
    printf ("hostM = \"%s\" %d cntrs\n", hostM, ndetM);
    printf ("hostO = \"%s\" %d cntrs\n", hostO, ndetO);
    printf ("hostU = \"%s\" %d cntrs\n", hostU, ndetU);
    printf ("Client port = %d\n", c_port);
    printf ("Server port = %d\n", s_port);

    if (suspend != 0) {
      printf ("\nFOCUS_srv: Suspending ...\n");
      taskSuspend (0);	    /* We've been told to suspend ourself, ..
			    **  .. presumably for debug reasons.
			    */
      printf ("\nFOCUS_srv: Suspension ended!\n");
    }
/*============================================================================
**	Perform the initialisation of global variables ...
*/
    StrJoin (FS_inst, sizeof (FS_inst), INST, "");     /* Save the instr.
							     ** name in a global
							     */
    StrJoin (FS_def_ident, sizeof (FS_def_ident), SINQHM_DEF_ID, "");
    StrJoin (FS_main_ident, sizeof (FS_main_ident), IDENT, "");
    StrJoin (FS_main_date,  sizeof (FS_main_date),  __DATE__, ", ");
    StrJoin (FS_main_date,  sizeof (FS_main_date),  FS_main_date, __TIME__);
    time (&FS_start_time);	/* Initialise the start time */
    FS_serv_ident[0] = NIL;
    FS_serv_date[0]  = NIL;
    FS_rout_ident[0] = NIL;
    FS_rout_date[0]  = NIL;

    FS_cfgn_done = False; /* Force a configuration before we can do anything. */

    FS_bytes_got = 0; FS_bytes_put = 0;
    FS_dbg_mask = FS_dbg_lev0 = FS_dbg_lev1 = FS_dbg_lev2 = FS_dbg_lev3 = 0;

    FS_free_memory (NULL);  /* Release memory (possibly) in case ..
			    ** .. of a restart of the program */
    if (FS_cnct_skt != 0) close (FS_cnct_skt);
    if (FS_rw_skt   != 0) close (FS_rw_skt);
    FS_cnct_skt = FS_rw_skt = 0;
    
    for (i = 0; i <= MAX_CLIENTS; i++) {
      FS_pids[i] = 0;
      FS_chld_exit_status[i] = 0;
      if (FS_chld_cnct_skt[i] != 0) close (FS_chld_cnct_skt[i]);
      if (FS_chld_rw_skt[i]   != 0) close (FS_chld_rw_skt[i]);
      FS_chld_cnct_skt[i] = FS_chld_rw_skt[i]   = 0;
      FS_p_names[i] = &FS_name[i][0]; FS_name[i][0] = NIL;
      for (j = 0; j < MAX_SLV; j++) {
	if (FS_skt[i][j] != 0) {close (FS_skt[i][j]); FS_skt[i][j] = 0;}
      }
      FS_srv_masks[i] = (i == 0) ? 0x8000 : 1 << (i - 1);
    }

    if (FS_sem_daq == NULL) {
      FS_sem_daq = semBCreate (SEM_Q_FIFO, SEM_FULL);  /* Create a released sem-
					    ** aphore for guarding access to
					    ** FS_dsbl_mask */
    }
    FS_dsbl_mask = 0;		/* Start up with DAQ enabled */

    FS_pid = get_pid ();			/* Store our pid */
    StrJoin (FS_name[0], sizeof (FS_name[0]),	/* And our task name */
		taskName (FS_pid), "");
/*
**	Debug hint - set FS_use_sem_tmo to False (== 0) to disable sem time-outs
**		     during debug sessions. This will stop things falling off.
*/
    FS_sem_tmo = 5 * sysClkRateGet ();	/* 5 second time-out by default */
    FS_use_sem_tmo = True;
/*
**	    Do all the necessary network orientated setup for our slaves to
**	    make it easier to broadcast commands to them.
*/
/*
**	    Get Internet address of the front-end.
*/
    FS_n_slaves = 3;
    if ((c_port < 128) || (c_port > 32767)) c_port = 2500;

    status = setup_host (hostM, &FS_rmt_socknam[0], c_port, True);
    if (status) FS_slaves[0] = hostM; else FS_slaves[0] = NULL;
    status = setup_host (hostO, &FS_rmt_socknam[1], c_port, True);
    if (status) FS_slaves[1] = hostO; else FS_slaves[1] = NULL;
    status = setup_host (hostU, &FS_rmt_socknam[2], c_port, True);
    if (status) FS_slaves[2] = hostU; else FS_slaves[2] = NULL;

    FS_lo_det[0] = 0;
    FS_hi_det[0] = FS_lo_det[0] + ndetM - 1;
    FS_lo_det[1] = FS_hi_det[0] + 1;
    FS_hi_det[1] = FS_lo_det[1] + ndetO - 1;
    FS_lo_det[2] = FS_hi_det[1] + 1;
    FS_hi_det[2] = FS_lo_det[2] + ndetU - 1;
    if (ndetM == 0) FS_slaves[0] = NULL;
    if (ndetO == 0) FS_slaves[1] = NULL;
    if (ndetU == 0) FS_slaves[2] = NULL;

    for (i = 0; i <= FS_n_slaves; i++) {
      FS_slv_active[i] = False;
    }
/*============================================================================
**	Clear the process signal mask to let in all signals (actually, on
**	PPC VxWorks this seems to cause all signals to get ignored!) and then
**	declare action routine for SIGUSR1. Our children signal with SIGUSR1
**	just before they exit in a more or less controlled manner. If the
**	child gets deleted from the shell, it will not signal.
*/
    FS_cnt_SIGUSR1 = 0;

    status = sigemptyset (&proc_sigmask);
    status = sigprocmask (SIG_SETMASK, &proc_sigmask, NULL);
    status = sigemptyset (&sig_action.sa_mask);
    sig_action.sa_handler = FS_catch_signal;
    sig_action.sa_flags   = 0;

    if (sigaction (SIGUSR1, &sig_action, NULL) == -1) {
      getErrno (&FS_errno);
      perror ("sigaction error:");
      exit (0);
    }
/*============================================================================
**		Get a port number to use. If the argument "port" is not
**		a valid port number (not in range 128 to 32767), use PORT_BASE.
*/
    FS_port = PORT_BASE;
    if ((s_port >= 128) && (s_port < 32768)) FS_port = s_port;
/*============================================================================
**	Create a TCP/IP socket for receiving connection requests, bind it and
**	set it to listen.
*/
    FS_cnct_skt = socket (AF_INET, SOCK_STREAM, 0);
    if (FS_cnct_skt == -1) {
      sprintf (buff, "\n%s -- Cnct-Socket socket error", FS_name[0]);
      failInet (buff);
    }
    status = 1;
    setsockopt(FS_cnct_skt, SOL_SOCKET, SO_REUSEADDR, &status, sizeof(int));
    setup_host (NULL, &lcl_sockname, FS_port, False);
    status = bind (FS_cnct_skt, (struct sockaddr *) &lcl_sockname,
					  sizeof (lcl_sockname));
    if (status != 0) {
      sprintf (buff, "\n%s -- Cnct-Socket bind error", FS_name[0]);
      failInet (buff);
    }
    status = listen (FS_cnct_skt, 5);
    if (status != 0) {
      sprintf (buff, "\n%s -- Cnct-Socket listen error", FS_name[0]);
      failInet (buff);
    }
/*
**	    Clients must now connect to the Connect-port and send either a
**	    connect, configure, deconfigure, status or exit request. A
**	    successful configure request must precede any connection request.
**
**	    When a configure request arrives, the histogram data structures are
**	    initialised, the histogram filler process (FILLER) is spawned and
**	    connection requests are enabled. A status reply is sent to the
**	    client and the connection closed.
**
**	    When a connection request arrives, a child will be spawned to
**	    handle the connection. The child will be told which port to use
**	    and he will release a semaphore when the port is ready. The parent
**	    then sends the client a reply to tell him which port to use. The
**	    connection is then closed to await further connections.
*/
    setup_inet_info (FS_host, sizeof (FS_host),	    /* Find out who we are  */
		     FS_addr, sizeof (FS_addr));
    printf ("\n%s: Program  Ident = \"%s\". Started on %s (%s).\n",
		    FS_name[0], IDENT, FS_host, FS_addr);
    printf ("%s: Protocol Ident = \"%s\"\n", FS_name[0], FS_def_ident);

#ifndef INST
    #error  Define the target instrument via the symbol "INST"!
#endif

    if (strcmp (INST, "FOCUS") == 0) {
      printf ("%s: Instrument = \"%s\"\n", FS_name[0], "FOCUS");
    }else {
      printf ("%s: Instrument is not defined\n", FS_name[0]);
    }
/*============================================================================*/
    while (keep_going) {
      rmt_sockname_len = sizeof (rmt_sockname);
      FS_rw_skt = accept (FS_cnct_skt, (struct sockaddr *) &rmt_sockname,
						&rmt_sockname_len);
      if (FS_rw_skt == -1) {
        getErrno (&FS_errno);
	sprintf (buff, "\n%s -- Cnct-Socket accept error", FS_name[0]);
	failInet (buff);	/* No return */
      }

      p_addr = inet_ntoa (rmt_sockname.sin_addr);
      cl_port = ntohs (rmt_sockname.sin_port);
      printf ("\n%s: Connected to Node %s, Port %d.\n",
				FS_name[0], p_addr, cl_port);

      bytes_to_come = sizeof (req_buff);   /* Read a command */
      p_addr = (char *) &req_buff;
      while (bytes_to_come > 0) {
	n_bytes_got = recv (FS_rw_skt, p_addr, bytes_to_come, 0);
	if (n_bytes_got <= 0) break;
	FS_bytes_got += n_bytes_got;
	bytes_to_come -= n_bytes_got;
	p_addr += n_bytes_got;
      }

      if (FS_cnt_SIGUSR1 > 0) {	    /* Have any children exited? */
	if (FS_dbg_lev0) printf ("\n%s: Cleaning up children ...", FS_name[0]);
	FS_cleanup_children (MAX_CLIENTS,   /* Yes, update our database. */
		FS_pids, &FS_cnt_SIGUSR1, FS_dbg_lev0, FS_p_names, "");
	if (FS_dbg_lev0) printf ("\n  ... cleanup of children done.\n");
      }

      if (n_bytes_got < 0) {
	printf ("\n%s -- R/W-Socket recv error\n", FS_name[0]);
	printf ("%s -- Connection to %s will be closed.\n", FS_name[0],
			    inet_ntoa (rmt_sockname.sin_addr));
      }else if (n_bytes_got == 0) {
	printf ("\n%s -- no command received!\n", FS_name[0]);
	printf ("%s -- Connection to %s will be closed.\n", FS_name[0],
			    inet_ntoa (rmt_sockname.sin_addr));
      }else if (bytes_to_come != 0) {
	printf ("\n%s -- command packet has wrong number of bytes:"
		" %d instead of %d\n", FS_name[0],
		n_bytes_got, sizeof (req_buff));
	printf ("%s -- Connection to %s will be closed.\n", FS_name[0],
			    inet_ntoa (rmt_sockname.sin_addr));
      }else if (ntohl (req_buff.bigend) != 0x12345678) {
	printf ("\n%s -- big-endian/little-endian problem!\n"
		"   Buffer received in non-network byte order!\n", FS_name[0]);
      }else {
	FS_do_command (0, FS_rw_skt, 4096, &req_buff, &rply_buff);
      }
      close (FS_rw_skt); FS_rw_skt = 0;
      if (ntohl (req_buff.cmnd) == SQHM_EXIT) keep_going = False;
    }
/*============================================================================*/
    close (FS_cnct_skt); FS_cnct_skt = 0;
    exit (KER__SUCCESS);
  }
/*========================================= End of FOCUS_srv_main.c ========*/