257 lines
7.7 KiB
C
257 lines
7.7 KiB
C
static char sccsid[] = "@(#)24 1.10 src/bos/usr/ccs/lib/libsrc/srcsbuf.c, libsrc, bos411, 9428A410j 2/26/91 14:54:47";
|
|
/*
|
|
* COMPONENT_NAME: (cmdsrc) System Resource Controller
|
|
*
|
|
* FUNCTIONS:
|
|
* srcsbuf
|
|
*
|
|
* ORIGINS: 27
|
|
*
|
|
* IBM CONFIDENTIAL -- (IBM Confidential Restricted when
|
|
* combined with the aggregate modules for this product)
|
|
* SOURCE MATERIALS
|
|
* (C) COPYRIGHT International Business Machines Corp. 1984,1989,1991
|
|
* All Rights Reserved
|
|
*
|
|
* US Government Users Restricted Rights - Use, duplication or
|
|
* disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
|
|
*/
|
|
|
|
|
|
/*
|
|
** IDENTIFICATION:
|
|
** Name: srcsbuf
|
|
** Title: SRC Subsystem/Subserver Status handler
|
|
** PURPOSE:
|
|
** Srcsbufs will allocate memory for the status reply from SRC or
|
|
** subsystem send a status request to SRC for short subsystem status
|
|
** or a sends a packet requesting status to the subsystem for
|
|
** all other status
|
|
**
|
|
** SYNTAX:
|
|
** srcsbuf(host,type,name,subname,svr_pid,stattype,where,shellptr,cont)
|
|
** Parameters:
|
|
** i char *host - host that we wish status on subsystem/subserver
|
|
** i short type - SUBSYSTEM or subserver code point
|
|
** i char *name - subsystem name status is requested for
|
|
** i char *subname - subserver object status is requested for
|
|
** i int svr_pid - subsystem pid that status is desired on
|
|
** on long subsystem status/or subserver status
|
|
** needed when multipule instances
|
|
** of the subsystem is running
|
|
** i short stattype - long or short status
|
|
** i int where - are error msgs to be displayed or logged
|
|
** o char *shellptr[1] - return pointer to storage for formated status
|
|
** u int *cont - continuation indicator
|
|
** when NEWREQUEST will send new request to src
|
|
** otherwise will just get the next responce packet
|
|
**
|
|
**
|
|
** INPUT/OUTPUT SECTION:
|
|
** UDP Socket
|
|
**
|
|
** PROCESSING:
|
|
** Send new status request to (SRC/subsystem) when this is a new request.
|
|
** Wait for a return packet from (SRC/subsystem)
|
|
** Format the status packet received.
|
|
**
|
|
** PROGRAMS/FUNCTIONS CALLED:
|
|
** srcsrqt
|
|
** srcstat
|
|
** srcstattxt
|
|
** srcerr
|
|
**
|
|
** OTHER:
|
|
** Three responces to contionuation can be returned by a subsystem
|
|
** 1. Reply continuation packet, another packet will follow
|
|
** 2. End packet, no more packets follow
|
|
** There are three vaild responces from SRC or the subsystem
|
|
** Short error packet (SRC error code)
|
|
** Srvreply error packet (text message included)
|
|
** Srvreply response packet
|
|
**
|
|
** RETURNS:
|
|
** size of printable text
|
|
** Error code on failure
|
|
**
|
|
**/
|
|
|
|
#include "src.h"
|
|
#include "src10.h"
|
|
/*--------------------------*/
|
|
/* External Functions Used */
|
|
/*--------------------------*/
|
|
extern int srcstat(); /* src status subsys routine*/
|
|
extern int srcsrqt(); /* src send request */
|
|
extern char *srcstattxt();
|
|
|
|
int srcsbuf(host, type, name, subname, svr_pid, stattype, where, shellptr, cont)
|
|
char *host;
|
|
short type;
|
|
char *name;
|
|
char *subname;
|
|
int svr_pid;
|
|
short stattype;
|
|
int where;
|
|
char *shellptr[1];
|
|
int *cont;
|
|
{
|
|
int rc; /* return code */
|
|
short replen; /* length of status reply */
|
|
short reqlen; /* length of request to RTL */
|
|
unsigned osize; /* length total text buffer */
|
|
unsigned msgsize; /* length total text buffer */
|
|
|
|
char *malloc();
|
|
|
|
struct statcode *statptr;
|
|
|
|
static struct srcrep *reqptr; /* pointer to request buffer*/
|
|
char *textptr;
|
|
struct subreq subreq; /* subserver request to RTL */
|
|
|
|
/* when a new status request arrives (non continued request)
|
|
** we must allocate buffer space for the returned status response
|
|
**/
|
|
if (*cont == NEWREQUEST)
|
|
{
|
|
/* allocate maximum buffer size for a packet */
|
|
reqptr = (struct srcrep *) malloc ((unsigned) SRCPKTMAX);
|
|
if (reqptr == NULL) {
|
|
if (where == SSHELL)
|
|
srcerr(SRC_BASE, SRC_MMRY, where, 0, 0, 0, 0);
|
|
return(SRC_MMRY);
|
|
}
|
|
}
|
|
|
|
replen = (short) SRCPKTMAX;
|
|
|
|
/* initialize return packet buffer to zero */
|
|
memset((void *)reqptr, 0, (size_t)SRCPKTMAX);
|
|
|
|
/* get short status of for subsystem
|
|
** allways goes to SRC for processing
|
|
**/
|
|
if (type == SUBSYSTEM && stattype == SHORTSTAT)
|
|
{
|
|
/* send status request to SRC to get status short by:
|
|
** subsystem name, subsystem pid, group name, all subsys
|
|
**/
|
|
rc = srcstat(host, name, svr_pid, &replen, reqptr, cont);
|
|
}
|
|
else
|
|
/* status long and subserver status will be passed through SRC
|
|
** to the subsystem, status returns directly from the subsystem
|
|
** with no SRC envolvment after the pass
|
|
*/
|
|
{
|
|
/* tell SRC that this is a status request and what type
|
|
** short or long status
|
|
**/
|
|
subreq.action=STATUS;
|
|
|
|
/* place SUBSYSTEM object id or code point for a subserver
|
|
** so the subsystem knows what the status is for
|
|
**/
|
|
subreq.object=type;
|
|
subreq.parm1=stattype;
|
|
subreq.parm2=replen;
|
|
|
|
/* status of a subsystem needs to have objname set to the
|
|
** name of the subsystem
|
|
**/
|
|
if (type == SUBSYSTEM)
|
|
(void) strcpy((char *) subreq.objname, name);
|
|
else
|
|
/* status of a subserver needs to have objname set to
|
|
** subserver object or subserver pid (subname is either
|
|
** subserver object or subserver pid)
|
|
**/
|
|
(void) strcpy((char *) subreq.objname, subname);
|
|
|
|
/* size of the packet to be send to the subsystem by SRC */
|
|
reqlen = (short) sizeof(struct subreq);
|
|
|
|
/* set up our status continuation factor */
|
|
reqptr->srchdr.cont = *cont;
|
|
|
|
/* pass request to SRC for forwarding to the subsystem
|
|
** indicate that the subsystem is not to be started if
|
|
** the subsystem has not already been started
|
|
*/
|
|
rc = srcsrqt(host,name,svr_pid,reqlen,&subreq,&replen,reqptr,SRCNO,cont);
|
|
}
|
|
|
|
/* did we successfuly receive our status packet? */
|
|
if (rc == SRC_OK)
|
|
{
|
|
/* have we finished receiving packets of status? */
|
|
if (*cont == END) {
|
|
/* free space that was allocated for status */
|
|
(void) free ((char *) reqptr);
|
|
/* indicate to caller that nothing is to be printed */
|
|
shellptr[0] = 0;
|
|
return(rc);
|
|
}
|
|
|
|
/* remove the srchdr size from the size of the reply length */
|
|
replen=replen-(sizeof(struct srchdr));
|
|
|
|
/* setup index into arrary of status structures returned by
|
|
** SRC or the subsystem itself
|
|
**/
|
|
statptr = (struct statcode *) &reqptr->svrreply;
|
|
|
|
/* how much mem do we need to format the status response */
|
|
osize = (unsigned) ((replen/sizeof(struct statcode)) * TEXTSIZE);
|
|
/* allocate buffer for formated status text */
|
|
textptr = malloc (osize);
|
|
if (textptr == NULL)
|
|
{
|
|
if (where == SSHELL)
|
|
srcerr(SRC_BASE, SRC_MMRY, where, 0, 0, 0, 0);
|
|
return(SRC_MMRY);
|
|
}
|
|
|
|
/* let caller know about the formated text */
|
|
shellptr[0] = (char *) textptr;
|
|
|
|
/* format each element in the array that was sent to us */
|
|
for(;osize > (unsigned) 0;osize=osize-TEXTSIZE)
|
|
{
|
|
textptr=textptr+sprintf(textptr,"%s %s %s\n", statptr->objname, statptr->objtext, srcstattxt(statptr->status));
|
|
statptr++;
|
|
}
|
|
|
|
/* return size of the formatted buffer */
|
|
msgsize = textptr-shellptr[0];
|
|
}
|
|
else
|
|
{
|
|
/* error code was retunred to us */
|
|
if (where != SSHELL)
|
|
{
|
|
/* error on status returning from SRC has no error
|
|
** message associated with it
|
|
**/
|
|
if(type == SUBSYSTEM && stattype==SHORTSTAT)
|
|
{
|
|
free((char *)reqptr);
|
|
shellptr[0]=0;
|
|
return(rc);
|
|
}
|
|
/* error message came back from the subsystem */
|
|
memcpy((void *)reqptr,(void *)reqptr->svrreply.rtnmsg,(size_t)sizeof(*reqptr->svrreply.rtnmsg));
|
|
shellptr[0] = (char *) reqptr;
|
|
return(rc);
|
|
}
|
|
|
|
srcerr(SUBSYS_BASE, rc, where, whattoken(rc,SRC_UHOST,host,reqptr->svrreply.objname), 0, 0, reqptr->svrreply.rtnmsg);
|
|
free((char *)reqptr);
|
|
shellptr[0]=0;
|
|
return(rc);
|
|
}
|
|
|
|
return((int)msgsize);
|
|
}
|