/* code fragment used at mq2.c and at mailq.c */
/*
* NOTE: HERE ARE INLINED SPECIAL COMMENTS THAT ARE USED WHEN
* GENERATING mailq-m(5) MAN-PAGE, AND (IN FUTURE) RELEVANT
* PART OF THE ZMAILER MANUAL
*
*/
#define M (*MIBMtaEntry)
/*SHM segment header
Basic SHM segment identifier, and references.
*/
sfprintf(fp,"ZMailer SHM segment dump; Magic=0x%08X\n", M.magic);
/*SHM segment Magic
Magic value used to ensure that active segment,
and programs have matching view of the world.
*/
sfprintf(fp,"Time_now %10lu\n",
(unsigned long)time(NULL));
/*Time_now
Lookup program prints local time(2) value in decimal.
*/
sfprintf(fp,"Block_creation_time %10lu\n",
(unsigned long)M.BlockCreationTimestamp);
/*Block_creation_time
When this current shared memory object was created.
Do note that it may well be from before last system boot,
as this is backed on mmap(2)ed file.
*/
#ifdef HAVE_GETLOADAVG
{
double loadavg[3];
int rc = getloadavg(loadavg, 3);
if (rc > 0)
sfprintf(fp,"SYS.Load-Avg-1-min-G %6.2lf\n",
loadavg[0]);
/*SYS.Load_Avg-1-min-G
At systems with getloadavg(3) API, shows 1 minute load-average
as a fixed point fractional number.
*/
if (rc > 1)
sfprintf(fp,"SYS.Load-Avg-5-min-G %6.2lf\n",
loadavg[1]);
/*SYS.Load_Avg-5-min-G
At systems with getloadavg(3) API, shows 5 minute load-average
as a fixed point fractional number.
*/
}
#endif
sfprintf(fp,"\n");
/*SYS.*
Various top-level things, e.g. process group leader PIDs et.al.
*/
#define PIDTEST(varname, var2) \
i = (M.varname != 0 && \
(kill(M.varname, 0) < 0 && errno == ESRCH)); \
if (i && r) M.varname = M.var2 = i = 0;
PIDTEST(sys.RouterMasterPID, sys.RouterMasterStartTime)
sfprintf(fp,"SYS.RouterMasterPID %10u",
M.sys.RouterMasterPID);
if (i) sfprintf(fp," NOT PRESENT!");
sfprintf(fp,"\n");
/*SYS.RouterMasterPID
Process-id of Router processes group leader, which is also
the queue manager of the router subsystem.
*/
sfprintf(fp,"SYS.RouterMasterStartTime %10lu\n",
(unsigned long)M.sys.RouterMasterStartTime);
/*SYS.RouterMasterStartTime
When the Router process group leader was started.
*/
sfprintf(fp,"SYS.RouterMasterStarts %10u\n",
M.sys.RouterMasterStarts);
/*SYS.RouterMasterStarts
How many times the Router process group leader has been started
in the lifetime of this shared memory block.
*/
PIDTEST(sys.SchedulerMasterPID, sys.SchedulerMasterStartTime)
sfprintf(fp,"SYS.SchedulerMasterPID %10u",
M.sys.SchedulerMasterPID);
if (i) sfprintf(fp," NOT PRESENT!");
sfprintf(fp,"\n");
/*SYS.SchedulerMasterPID
Process-id of Scheduler processes group leader, which is also
the queue manager of the router subsystem.
*/
sfprintf(fp,"SYS.SchedulerMasterStartTime %10lu\n",
(unsigned long)M.sys.SchedulerMasterStartTime);
/*SYS.SchedulerMasterStartTime
When the Scheduler process group leader was started.
*/
sfprintf(fp,"SYS.SchedulerMasterStarts %10u\n",
M.sys.SchedulerMasterStarts);
/*SYS.SchedulerMasterStarts
How many times the Scheduler process group leader has been started
in the lifetime of this shared memory block.
*/
PIDTEST(ts.pid, ts.pid)
sfprintf(fp,"SC.SchedulerTimeserverPID %10u",
M.ts.pid);
if (i) sfprintf(fp," NOT PRESENT!");
sfprintf(fp,"\n");
/*SC.SchedulerTimeserverPID
Separate fork of the Scheduler, which maintains a shared variable
with local time in 1 second resolution.
Originally this was created, when system profiling did show, how
absolutely apalling amounts of time(2) syscalls the scheduler does.
*/
sfprintf(fp,"SC.SchedulerTimeserverTime %10lu\n",
(unsigned long)
#ifdef HAVE_SELECT
M.ts.tv.tv_sec
#else
M.ts.time_sec
#endif
);
/*SC.SchedulerTimeserverTime
Scheduler's timeserver's idea of present time.
If this disagrees with "time now" above, something is seriously wrong
(when the scheduler does not run, this isn't running either, of course.)
*/
sfprintf(fp,"SC.SchedulerTimeserverStarts %10u\n",
M.sc.schedulerTimeserverStarts);
/*SC.SchedulerTimeserverStarts
How many times the Scheduler's Timeserver has been started.
This should match with SYS.SchedulerMasterStarts count.
*/
sfprintf(fp,"SC.SchedulerTimeserverStartTime %10u\n",
M.sc.schedulerTimeserverStartTime);
/*SC.SchedulerTimeserverStartTime
When the Scheduler's Timeserver was started last time.
This should match with SYS.SchedulerMasterStartTime.
*/
PIDTEST(sys.SmtpServerMasterPID, sys.SmtpServerMasterStartTime)
sfprintf(fp,"SYS.SmtpServerMasterPID %10u",
M.sys.SmtpServerMasterPID);
if (i) sfprintf(fp," NOT PRESENT!");
sfprintf(fp,"\n");
/*SYS.SmtpServerMasterPID
PID of SMTP-server's master instance.
This process does listen(2) on defined inbound sockets,
and forks actual receiver instances.
*/
sfprintf(fp,"SYS.SmtpServerMasterStartTime %10lu\n",
(unsigned long)M.sys.SmtpServerMasterStartTime);
/*SYS.SmtpServerMasterStartTime
When the SMTP-server's master instance was started the lattest time.
*/
sfprintf(fp,"SYS.SmtpServerMasterStarts %10u\n",
M.sys.SmtpServerMasterStarts);
/*SYS.SmtpServerMasterStarts
How many times the SMTP-server's master instance has been started
during the existence of this SHM segment.
*/
sfprintf(fp,"SYS.SpoolFreeSpace-kB-G %9d\n",
M.sys.SpoolFreeSpace);
/*SYS.SpoolFreeSpace-kB-G
Amount of free POSTOFFICE filesystem space in the system in kilobytes.
*/
sfprintf(fp,"SYS.SpoolUsedSpace-kB-G %9d\n",
M.sys.SpoolUsedSpace);
/*SYS.SpoolUsedSpace-kB-G
Amount of used POSTOFFICE filesystem space in the system in kilobytes.
*/
sfprintf(fp,"SYS.LogFreeSpace-kB-G %9d\n",
M.sys.LogFreeSpace);
/*SYS.LogFreeSpace-kB-G
Amount of free LOGDIR filesystem space in the system in kilobytes.
*/
sfprintf(fp,"SYS.LogUsedSpace-kB-G %9d\n",
M.sys.LogUsedSpace);
/*SYS.LogUsedSpace-kB-G
Amount of used LOGDIR filesystem space in the system in kilobytes.
*/
sfprintf(fp,"\n");
/*SS.*
SmtpServer counters and gauges.
*/
sfprintf(fp,"SS.Processes-G %4d\n",
M.ss.IncomingSMTPSERVERprocesses);
/*SS.Processes-G
A gauge tracking number of active instances of the smtpserver.
In running system the number one is the master process, all
active inbound sessions add themselves.
*/
sfprintf(fp,"SS.ParallelSMTPconnects-G %4d\n",
M.ss.IncomingParallelSMTPconnects);
/*SS.ParallelSMTPconnects-G
A gauge tracking number of active incoming SMTP socket connections.
*/
sfprintf(fp,"SS.ParallelSMTPSconnects-G %4d\n",
M.ss.IncomingParallelSMTPSconnects);
/*SS.ParallelSMTPconnects-G
A gauge tracking number of active incoming SMTPS socket connections.
*/
sfprintf(fp,"SS.ParallelSUBMITconnects-G %4d\n",
M.ss.IncomingParallelSUBMITconnects);
/*SS.ParallelSMTPconnects-G
A gauge tracking number of active incoming SUBMIT socket connections.
*/
sfprintf(fp,"SS.ProcessForks %10u\n",
M.ss.IncomingSMTPSERVERforks);
/*SS.ProcessForks
Number of started receiving SMTP/SMTPS/SUBMIT socket serving processes
*/
sfprintf(fp,"SS.ProcessForkFailures %10u\n",
M.ss.ForkFailures);
/*SS.ProcessForkFailures
Failures to fork(2) another process - e.g. system badly out of resources ?
*/
sfprintf(fp,"SS.ContentPolicyForkFailures %10u\n",
M.ss.ForkFailures);
/*SS.ContentPolicyForkFailures
Failures to fork(2) a content-policy analysis (interface) process
*/
sfprintf(fp,"SS.SMTPconnects %10u\n",
M.ss.IncomingSMTPconnects);
/*SS.SMTPconnects
Number of received SMTP socket connections (also fork attempts to serve it)
*/
sfprintf(fp,"SS.SMTPSconnects %10u\n",
M.ss.IncomingSMTPSconnects);
/*SS.SMTPSconnects
Number of received SMTPS socket connections (also fork attempts to serve it)
*/
sfprintf(fp,"SS.SUBMITconnects %10u\n",
M.ss.IncomingSUBMITconnects);
/*SS.SUBMITconnects
Number of received SUBMIT socket connections (also fork attempts to serve it)
*/
sfprintf(fp,"SS.MaxSameIpSourceCloses %10u\n",
M.ss.MaxSameIpSourceCloses);
/*SS.MaxSameIpSourceCloses
Number of times, when there have been more connections from any given
single IP address, than what "PARAM MaxSameIpSource" has been configured
to allow.
*/
sfprintf(fp,"SS.MaxParallelConnectionCloses %10u\n",
M.ss.MaxParallelConnections);
/*SS.MaxParallelConnectionCloses
Number of times, when there have been more connections into smtpserver,
than the global "PARAM MaxParallelConnections" parameter has been configured
to allow.
*/
sfprintf(fp,"SS.SMTPcommands %10u\n",
M.ss.IncomingCommands);
/*SS.SMTPcommands
Total number of received SMTP commands. All commands before any analysis.
*/
sfprintf(fp,"SS.SMTPcommands-unknown %10u\n",
M.ss.IncomingCommands_unknown);
/*SS.SMTPcommands-unknown
Number of received SMTP commands which for some reason
or other are considered invalid.
*/
sfprintf(fp,"SS.IncomingClientPipelines %10u\n",
M.ss.IncomingClientPipelines);
/*SS.IncomingClientPipelines
Number of observed cases, where contacing client uses apparent PIPELINING
protocol enhancement, e.g. when (at any commands reception) there are
more data in the input stream right after a command has been read in.
This counts only once per connection in order to see, what share
of incoming sessions are using this feature.
*/
sfprintf(fp,"SS.IncomingSmtpTarpits %10u\n",
M.ss.IncomingSmtpTarpits);
/*SS.IncomingSmtpTarpits
Number of cases, when the TARPIT functionality has been activated in the session.
This counts all instances, which may mean e.g. a dozen or more counts per
connection.
*/
sfprintf(fp,"SS.SMTP_HELO %10u\n",
M.ss.IncomingSMTP_HELO);
/*SS.SMTP_HELO
Number of received HELO greetings.
Raw number without any analysis.
*/
sfprintf(fp,"SS.SMTP_HELO_ok %10u\n",
M.ss.IncomingSMTP_HELO_ok);
/*SS.SMTP_HELO_ok
Number of received HELO greetings which were ok per possibly applied
"strict" rules.
*/
sfprintf(fp,"SS.SMTP_HELO_bad %10u\n",
M.ss.IncomingSMTP_HELO_bad);
/*SS.SMTP_HELO_bad
Number of received HELO greetings which were bad per possibly applied
"strict" rules.
*/
sfprintf(fp,"SS.SMTP_EHLO %10u\n",
M.ss.IncomingSMTP_EHLO);
/*SS.SMTP_EHLO
Number of received EHLO greetings.
Raw number without any analysis.
*/
sfprintf(fp,"SS.SMTP_EHLO_ok %10u\n",
M.ss.IncomingSMTP_EHLO_ok);
/*SS.SMTP_EHLO_ok
Number of received EHLO greetings which were ok per possibly applied
"strict" rules.
*/
sfprintf(fp,"SS.SMTP_EHLO_bad %10u\n",
M.ss.IncomingSMTP_EHLO_bad);
/*SS.SMTP_EHLO_bad
Number of received EHLO greetings which were bad per possibly applied
"strict" rules.
*/
sfprintf(fp,"SS.SMTP_STARTTLS %10u\n",
M.ss.IncomingSMTP_STARTTLS);
/*SS.SMTP_STARTTLS
Number of received STARTTLS commands in SMTP/LMTP/SUBMIT sockets.
(If this has been enabled in the system!)
*/
sfprintf(fp,"SS.SMTPTLSes %10u\n",
M.ss.IncomingSMTP_STARTTLS);
/*SS.SMTPTLSes
Duplicate name/printout of "SS.SMTP_STARTTLS"
*/
sfprintf(fp,"SS.SMTP_STARTTLS_fail %10u\n",
M.ss.IncomingSMTP_STARTTLS_fail);
/*SS.SMTP_STARTTLS_fail
Number of instances, when STARTTLS command has failed for some reason.
*/
sfprintf(fp,"SS.SMTP_NOOP %10u\n",
M.ss.IncomingSMTP_NOOP);
/*SS.SMTP_NOOP
Number of received NOOP verbs.
*/
sfprintf(fp,"SS.SMTP_RSET %10u\n",
M.ss.IncomingSMTP_RSET);
/*SS.SMTP_RSET
Number of received RSET verbs.
*/
sfprintf(fp,"SS.SMTP_HELP %10u\n",
M.ss.IncomingSMTP_HELP);
/*SS.SMTP_HELP
Number of received HELP verbs.
*/
sfprintf(fp,"SS.SMTP_ETRN %10u\n",
M.ss.IncomingSMTP_ETRN);
/*SS.SMTP_ETRN
Number of received ETRN verbs.
(If this has been enabled in the system!)
*/
sfprintf(fp,"SS.SMTP_EXPN %10u\n",
M.ss.IncomingSMTP_EXPN);
/*SS.SMTP_EXPN
Number of received EXPN verbs.
(If this has been enabled in the system!)
*/
sfprintf(fp,"SS.SMTP_VRFY %10u\n",
M.ss.IncomingSMTP_VRFY);
/*SS.SMTP_VRFY
Number of received VRFY verbs.
(If this has been enabled in the system!)
*/
sfprintf(fp,"SS.SMTP_TICK %10u\n",
M.ss.IncomingSMTP_TICK);
/*SS.SMTP_TICK
Number of received TICK verbs.
(An BSMTP environement verb, actually doesn't mean much of anything.)
*/
sfprintf(fp,"SS.SMTP_TURN %10u\n",
M.ss.IncomingSMTP_TURN);
/*SS.SMTP_TURN
Number of received TURN verbs.
(This isn't actually implemented, and leads to an error..)
*/
sfprintf(fp,"SS.SMTP_VERBOSE %10u\n",
M.ss.IncomingSMTP_VERBOSE);
/*SS.SMTP_VERBOSE
Number of received VERBOSE verbs.
(If this has been enabled in the system!)
*/
sfprintf(fp,"SS.SMTP_DEBUG %10u\n",
M.ss.IncomingSMTP_DEBUG);
/*SS.SMTP_DEBUG
Number of received DEBUG verbs.
(If this has been enabled in the system!)
*/
sfprintf(fp,"SS.SMTP_MAIL %10u\n",
M.ss.IncomingSMTP_MAIL);
/*SS.SMTP_MAIL
Total number of received MAIL verbs.
*/
sfprintf(fp,"SS.SMTP_MAIL_ok %10u\n",
M.ss.IncomingSMTP_MAIL_ok);
/*SS.SMTP_MAIL_ok
Total number of acceptably received MAIL verbs.
*/
sfprintf(fp,"SS.SMTP_MAIL_bad %10u\n",
M.ss.IncomingSMTP_MAIL_bad);
/*SS.SMTP_MAIL_bad
Total number of non-acceptably received MAIL verbs.
*/
sfprintf(fp,"SS.SMTP_RCPT %10u\n",
M.ss.IncomingSMTP_RCPT);
/*SS.SMTP_RCPT
Total number of received RCPT verbs.
*/
sfprintf(fp,"SS.SMTP_RCPT_ok %10u\n",
M.ss.IncomingSMTP_RCPT_ok);
/*SS.SMTP_RCPT_ok
Total number of acceptably received RCPT verbs.
*/
sfprintf(fp,"SS.SMTP_RCPT_bad %10u\n",
M.ss.IncomingSMTP_RCPT_bad);
/*SS.SMTP_RCPT_bad
Total number of non-acceptably received RCPT verbs.
*/
sfprintf(fp,"SS.Smtp-Opt-ENVID %10u\n",
M.ss.IncomingSMTP_OPT_ENVID);
/*SS.Smtp-Opt-ENVID
Total number of received ENVID options
*/
sfprintf(fp,"SS.Smtp-Opt-SIZE %10u\n",
M.ss.IncomingSMTP_OPT_SIZE);
/*SS.Smtp-Opt-SIZE
Total number of received SIZE options
*/
sfprintf(fp,"SS.Smtp-Opt-AUTH %10u\n",
M.ss.IncomingSMTP_OPT_AUTH);
/*SS.Smtp-Opt-AUTH
Total number of received AUTH options
*/
sfprintf(fp,"SS.Smtp-Opt-DELIVERBY %10u\n",
M.ss.IncomingSMTP_OPT_DELIVERBY);
/*SS.Smtp-Opt-DELIVERBY
Total number of received DELIVERBY options
*/
sfprintf(fp,"SS.Smtp-Opt-BODY-8BITMIME %10u\n",
M.ss.IncomingSMTP_OPT_BODY_8BITMIME);
/*SS.Smtp-Opt-BODY-8BITMIME
Total number of received BODY=8BITMIME options
*/
sfprintf(fp,"SS.Smtp-Opt-BODY-BINARYMIME %10u\n",
M.ss.IncomingSMTP_OPT_BODY_BINARYMIME);
/*SS.Smtp-Opt-BODY-BINARYMIME
Total number of received BODY=BINARYMIME options
*/
sfprintf(fp,"SS.Smtp-Opt-BODY-7BIT %10u\n",
M.ss.IncomingSMTP_OPT_BODY_7BIT);
/*SS.Smtp-Opt-BODY-7BIT
Total number of received BODY=7BIT options
*/
sfprintf(fp,"SS.Smtp-Opt-RETURN %10u\n",
M.ss.IncomingSMTP_OPT_RET);
/*SS.Smtp-Opt-RETURN
Total number of received RET=.. options
*/
sfprintf(fp,"SS.Smtp-Opt-NOTIFY %10u\n",
M.ss.IncomingSMTP_OPT_NOTIFY);
/*SS.Smtp-Opt-NOTIFY
Total number of received NOTIFY=.. options
*/
sfprintf(fp,"SS.Smtp-Opt-ORCPT %10u\n",
M.ss.IncomingSMTP_OPT_ORCPT);
/*SS.Smtp-Opt-ORCPT
Total number of received ORCPT=.. options
*/
sfprintf(fp,"SS.SMTP_DATA %10u\n",
M.ss.IncomingSMTP_DATA);
/*SS.SMTP_DATA
Total number of received DATA verbs.
*/
sfprintf(fp,"SS.SMTP_DATA_ok %10u\n",
M.ss.IncomingSMTP_DATA_ok);
/*SS.SMTP_DATA_ok
Total number of received messages via DATA verb.
*/
sfprintf(fp,"SS.SMTP_DATA_bad %10u\n",
M.ss.IncomingSMTP_DATA_bad);
/*SS.SMTP_DATA_bad
Total number of failed receptions of DATA verb, or message content.
*/
sfprintf(fp,"SS.SMTP_BDAT %10u\n",
M.ss.IncomingSMTP_BDAT);
/*SS.SMTP_BDAT
Total number of received BDAT verbs.
*/
sfprintf(fp,"SS.SMTP_BDAT_ok %10u\n",
M.ss.IncomingSMTP_BDAT_ok);
/*SS.SMTP_BDAT_ok
Total number of received messages via BDAT verb.
(FIXME: BDAT without LAST parameter ??)
*/
sfprintf(fp,"SS.SMTP_BDAT_bad %10u\n",
M.ss.IncomingSMTP_BDAT_bad);
/*SS.SMTP_BDAT_bad
Total number of failed receptions of BDAT verb, or message content.
*/
sfprintf(fp,"SS.SMTP_DATA-kB %10u\n",
M.ss.IncomingSMTP_DATA_KBYTES);
/*SS.SMTP_DATA-kB
Received message volume via DATA verb.
Each message size rounded up to next 1024 bytes, and divided by 1024.
Finally summed up into this variable.
*/
sfprintf(fp,"SS.SMTP_BDAT-kB %10u\n",
M.ss.IncomingSMTP_BDAT_KBYTES);
/*SS.SMTP_BDAT-kB
Received message volume via BDAT verb.
Each message size rounded up to next 1024 bytes, and divided by 1024.
Finally summed up into this variable.
*/
sfprintf(fp,"SS.SMTP_input_spool-kB %10u\n",
M.ss.IncomingSMTP_spool_KBYTES);
/*SS.SMTP_input_spool-kB
Sum Received message spool sizes rounded up to next 1024 byte, and
divided by 1024, then summed up into this variable.
*/
sfprintf(fp,"SS.ReceivedMessages %10u\n",
M.ss.ReceivedMessagesSs);
/*SS.ReceivedMessages
Cumulative count of received messages by DATA and BDAT verbs.
This includes cases of messages that in the end became rejected!
*/
sfprintf(fp,"SS.ReceivedRecipients %10u\n",
M.ss.ReceivedRecipientsSs);
/*SS.ReceivedRecipients
Cumulative count of received recipients by DATA and BDAT verbs.
This includes cases of messages that in the end became rejected,
but does so with acceptance pre-filtered RCPT addresses.
*/
sfprintf(fp,"SS.TransmittedMessages %10u\n",
M.ss.TransmittedMessagesSs);
/*SS.TransmittedMessages
Cumulative count of messages that have been successfully sent from
smtpserver onwards to the system proper.
*/
sfprintf(fp,"SS.TransmittedRecipients %10u\n",
M.ss.TransmittedRecipientsSs);
/*SS.TransmittedRecipients
Cumulative count of recipients that have been successfully sent from
smtpserver onwards to the system proper.
*/
sfprintf(fp,"\n");
/*RT.*
RouTer counters and gauges.
*/
sfprintf(fp,"RT.RouterProcesses-G %9d\n",
M.rt.RouterProcesses);
/*RT.RouterProcesses-G
Current count of router processes.
The router master (queue-manager) is number one, resource
configuration limits eventually how many there will be, but
there won't be that many running, until there has a burst of high
activity in form of many message to feed to processing.
*/
sfprintf(fp,"RT.RouterProcessForks %10u\n",
M.rt.RouterProcessForks);
/*RT.RouterProcessForks
Count of started active processing instances.
This is zeroed at queue manager startp, and should max out, when
all configured-to-be-used resources are in use.
It is possible, that there is some problem in the system, and
the processing router processes keep crashing. Then you will
see this count keep counting up, while the RouterProcesses-G
stays stable, or perhaps jumps up and down a bit.
*/
sfprintf(fp,"RT.RouterProcessFaults %10u\n",
M.rt.RouterProcessFaults);
/*RT.RouterProcessFaults
Count of active router subprocesses closing by anything else than
"exit(0)".
This should always stay zero!
*/
sfprintf(fp,"RT.ReceivedMessages %10u\n",
M.rt.ReceivedMessages);
/*RT.ReceivedMessages
Number of messages received into router queue-manager input queue.
*/
sfprintf(fp,"RT.ReceivedRecipients %10u\n",
M.rt.ReceivedRecipients);
/*RT.ReceivedRecipients
Number of parsed recipients in processed messages.
Where RT.ReceivedMessages is kept with router input queue manager, this
count is known only when a message is actually processed.
Essentially same problem, as with RT.StoredRecipients-G.
*/
sfprintf(fp,"RT.TransmittedMessages %10u\n",
M.rt.TransmittedMessages);
/*RT.TransmittedMessages
Number of messages that have completed processing in router, and
have been moved onwards to scheduler.
*/
sfprintf(fp,"RT.TransmittedRecipients %10u\n",
M.rt.TransmittedRecipients);
/*RT.TransmittedRecipients
Number of recipient addresses (specifications) in the messages
moved onwards to scheduler. (Router internal alias expansion
shows up with this count being slightly higher, than the received
recipient count.)
*/
sfprintf(fp,"RT.ReceivedVolume-kB %10u\n",
M.rt.ReceivedVolume);
/*RT.ReceivedVolume-kB
Message volume received into router input queue, counted as kilobytes
after rounding each received message file size up to next 1024 byte level.
*/
sfprintf(fp,"RT.TransmittedVolume-kB %10u\n",
M.rt.TransmittedVolume);
/*RT.TransmittedVolume-kB
Message volume sent onwards from the router to the scheduler's "queue" directory.
These are the original incoming files!
(The usual round up to next kilobyte...)
*/
sfprintf(fp,"RT.TransmittedVolume2-kB %10u\n",
M.rt.TransmittedVolume2);
/*RT.TransmittedVolume2-kB
Message volume sent onwards from the router to the scheduler's "transport" directory.
These are transport-specification entries with rewritten headers, etc.
(The usual round up to next kilobyte...)
*/
sfprintf(fp,"RT.StoredMessages-G %9d\n",
M.rt.StoredMessages);
/*RT.StoredMessages-G
Number of messages presently in the routing queue, including those
not quite yet sent onwards.
*/
sfprintf(fp,"RT.StoredVolume-kB-G %9d\n",
M.rt.StoredVolume);
/*RT.StoredVolume-kB-G
Total size of messages in router input queue.
(The usual round up to next kilobyte...)
*/
sfprintf(fp,"\n");
/*SC.*
SCheduler counters and gauges.
*/
sfprintf(fp,"SC.ReceivedMessages %10u\n",
M.sc.ReceivedMessagesSc);
/*SC.ReceivedMessages
Number of messages inserted in Scheduler's pre-digestion queue.
From there they are assimilated into processing in rate-limited
manner in order to limit the effect of queue assimilation into
system functionality..
*/
sfprintf(fp,"SC.ReceivedRecipients %10u\n",
M.sc.ReceivedRecipientsSc);
/*SC.ReceivedRecipients
Number of assimilated recipient descriptors.
*/
sfprintf(fp,"SC.TransmittedMessages %10u\n",
M.sc.TransmittedMessagesSc);
/*SC.TransmittedMessages
Number of messages that have all their recipients completed
(successes and failures together) out from the internal state.
*/
sfprintf(fp,"SC.TransmittedRecipients %10u\n",
M.sc.TransmittedRecipientsSc);
/*SC.TransmittedRecipients
Number of recipient addresses that have been completed
(successes and failures together) out from the internal state.
*/
sfprintf(fp,"SC.StoredMessages-G %9d\n",
M.sc.StoredMessagesSc);
/*SC.StoredMessages-G
Gauge of message files in the queue.
*/
sfprintf(fp,"SC.StoredThreads-G %9d\n",
M.sc.StoredThreadsSc);
/*SC.StoredThreads-G
Gauge of different channel/host pairs total in the queue state.
*/
sfprintf(fp,"SC.StoredVertices-G %9d\n",
M.sc.StoredVerticesSc);
/*SC.StoredVertices-G
Sum of number of messages in each thread.
*/
sfprintf(fp,"SC.StoredRecipients-G %9d\n",
M.sc.StoredRecipientsSc);
/*SC.StoredRecipients-G
Sum of actual recipients in each message in each thread.
*/
sfprintf(fp,"SC.ReceivedVolume-kB %10u\n",
M.sc.ReceivedVolumeSc);
/*SC.ReceivedVolume-kB
Received messages spool file(s) size sum in kilobytes.
*/
sfprintf(fp,"SC.StoredVolume-kB-G %9d\n",
M.sc.StoredVolumeSc);
/*SC.StoredVolume-kB
Still in queue messages spool file(s) size sum in kilobytes.
*/
sfprintf(fp,"SC.TransmittedVolume-kB %10u\n",
M.sc.TransmittedVolumeSc);
/*SC.TransmittedVolume-kB
Sum of message spool file(s) sizes completed so far.
*/
sfprintf(fp,"SC.TransportAgentForks %10u\n",
M.sc.TransportAgentForksSc);
/*SC.TransportAgentForks
Number of times the scheduler has started a new transport-agent process.
*/
sfprintf(fp,"SC.TransportAgentProcesses-G %9d\n",
M.sc.TransportAgentProcessesSc);
/*SC.TransportAgentProcesses-G
Number of transport agent processes currently running under the scheduler.
*/
sfprintf(fp,"SC.TransportAgentsActive-G %9d\n",
M.sc.TransportAgentsActiveSc);
/*SC.TransportAgentsActive-G
Number of transport agent processes currently considered actively
working on something.
*/
sfprintf(fp,"SC.TransportAgentsIdle-G %9d\n",
M.sc.TransportAgentsIdleSc);
/*SC.TransportAgentsIdle-G
Number of transport agent processes currently placed into "idle"
state in toder to be recycled to some other job.
(Forking is so expensive thing...)
*/
sfprintf(fp,"SC.MQ2Parallel-G %9d\n",
M.sc.MQ2sockParallel);
/*SC.MQ2Parallel-G
Gauge of currently active "mailq" (in protocol version 2 mode) connections.
*/
sfprintf(fp,"SC.MQ2Connects %10u\n",
M.sc.MQ2sockConnects);
/*SC.MQ2Connects
Count of received connects to "mailq" (in protocol version 2 mode) socket.
*/
sfprintf(fp,"SC.MQ2TcpWrapRej %10u\n",
M.sc.MQ2sockTcpWrapRej);
/*SC.MQ2TcpWrapRej
Number of times that tcp-wrapper has rejected the connection to
the mailq-v2 socket.
*/
sfprintf(fp,"SC.MQ2AuthRej %10u\n",
M.sc.MQ2sockAuthRej);
/*SC.MQ2AuthRej
Number of times that mailq-v2 socket authentication has failed.
*/
sfprintf(fp,"SC.MQ2TimedOut %10u\n",
M.sc.MQ2sockTimedOut);
/*SC.MQ2TimedOut
Count of cases, where MQ2 socket has become too old, and has been killed due to it.
*/
sfprintf(fp,"SC.MQ2ReadEOF %10u\n",
M.sc.MQ2sockReadEOF);
/*SC.MQ2ReadEOF
Count of cases, where the MQ2 socket has been closed by the remote end
without doing proper "QUIT" command.
*/
sfprintf(fp,"SC.MQ2ReadFails %10u\n",
M.sc.MQ2sockReadFails);
/*SC.MQ2ReadFails
Very odd internal error in code logic. Should see "timed out", or
"Read EOF" cases, only.
*/
sfprintf(fp,"SC.MQ2WriteFails %10u\n",
M.sc.MQ2sockWriteFails);
/*SC.MQ2WriteFails
Write to MQ2 socket has failed for other than EAGAIN/EINTR reason.
*/
sfprintf(fp,"SC.MQ2Commands %10u\n",
M.sc.MQ2sockCommands);
/*SC.MQ2Commands
Count of command lines received in MQ2 sockets.
*/
sfprintf(fp,"SC.MQ2CommandsRej %10u\n",
M.sc.MQ2sockCommandsRej);
/*SC.MQ2CommandsRej
Count of rejected command lines received in MQ2 sockets.
*/
sfprintf(fp,"SC.MQ2CommandAUTH %10u\n",
M.sc.MQ2sockCommandAUTH);
/*SC.MQ2CommandAUTH
Count of received AUTH commands.
Should match count of MQ2 sockets (unless somebody tries to break in..)
*/
sfprintf(fp,"SC.MQ2CommandQUIT %10u\n",
M.sc.MQ2sockCommandQUIT);
/*SC.MQ2CommandQUIT
Count of received QUIT commands.
Should match count of MQ2 sockets.
*/
sfprintf(fp,"SC.MQ2CommandETRN %10u\n",
M.sc.MQ2sockCommandETRN);
/*SC.MQ2CommandETRN
Count of received ETRN commands.
*/
sfprintf(fp,"SC.MQ2CommandKillThr %10u\n",
M.sc.MQ2sockCommandKillThr);
/*SC.MQ2CommandKillThr
Count of received KILL THR commands.
*/
sfprintf(fp,"SC.MQ2CommandKillMsg %10u\n",
M.sc.MQ2sockCommandKillMsg);
/*SC.MQ2CommandKillMsg
Count of received KILL MSG commands.
*/
sfprintf(fp,"SC.MQ2CommandKillProcess %10u\n",
M.sc.MQ2sockCommandKillProcess);
/*SC.MQ2CommandKillProcess
Count of received KILL PROC commands.
*/
sfprintf(fp,"SC.MQ2CommandRerouteThr %10u\n",
M.sc.MQ2sockCommandRerouteThr);
/*SC.MQ2CommandRerouteThr
Count of received REROUTE THR commands.
*/
sfprintf(fp,"SC.MQ2CommandRerouteMsg %10u\n",
M.sc.MQ2sockCommandRerouteMsg);
/*SC.MQ2CommandRerouteMsg
Count of received REROUTE MSG commands.
*/
sfprintf(fp,"SC.MQ2CommandShowQueueThreads %10u\n",
M.sc.MQ2sockCommandShowQueueThreads);
/*SC.MQ2CommandShowQueueThreads
Count of received SHOW QUEUE THREADS commands.
*/
sfprintf(fp,"SC.MQ2CommandShowQueueThreads2 %10u\n",
M.sc.MQ2sockCommandShowQueueThreads2);
/*SC.MQ2CommandShowQueueThreads2
Count of received SHOW QUEUE THREADS2 commands.
*/
sfprintf(fp,"SC.MQ2CommandShowQueueShort %10u\n",
M.sc.MQ2sockCommandShowQueueShort);
/*SC.MQ2CommandShowQueueShort
Count of received SHOW QUEUE SHORT commands.
*/
sfprintf(fp,"SC.MQ2CommandShowQueueVeryShort %10u\n",
M.sc.MQ2sockCommandShowQueueVeryShort);
/*SC.MQ2CommandShowQueueVeryShort
Count of received SHOW SNMP commands.
These are merely two last lines of "mailq -Q" output.
*/
sfprintf(fp,"SC.MQ2CommandShowThread %10u\n",
M.sc.MQ2sockCommandShowThread);
/*SC.MQ2CommandShowThread
Count of received SHOW THREAD 'channel' 'host' commands.
*/
sfprintf(fp,"SC.MQ2CommandShowCounters %10u\n",
M.sc.MQ2sockCommandShowCounters);
/*SC.MQ2CommandShowCounters
Count of received SHOW COUNTERS commands.
(e.g. MQ2 way of asking these counters now being described.)
*/
sfprintf(fp,"\n");
/*TA-SMTP.*
SMTP transpor agent counters and gauges.
*/
sfprintf(fp,"TA-SMTP.TaProcessStarts %10u\n",
M.tasmtp.TaProcessStarts);
/*TA-SMTP.TaProcessStarts
Number of times that this transport agent processes type have been
started in this system during this SHM blocks lifetime.
*/
sfprintf(fp,"TA-SMTP.TaProcCount-G %9d\n",
M.tasmtp.TaProcCountG);
/*TA-SMTP.TaProcCount-G
Gauge of presently running transport agent processes of this type.
*/
sfprintf(fp,"TA-SMTP.TaIdleStates %10u\n",
M.tasmtp.TaIdleStates);
/*TA-SMTP.TaIdleStates
Number of times this transport agent process type has been placed
into "idle" state by the scheduler.
*/
sfprintf(fp,"TA-SMTP.TaMessages %10u\n",
M.tasmtp.TaMessages);
/*TA-SMTP.TaMessages
Number of tasks fed to this transport agent process type by the scheduler.
*/
sfprintf(fp,"TA-SMTP.TaDeliveryStarts %10u\n",
M.tasmtp.TaDeliveryStarts);
/*TA-SMTP.TaDeliveryStarts
Number of times that this transport agent type has started a delivery on
given tasks. This might be lower count, than TaMessages.
*/
sfprintf(fp,"TA-SMTP.SmtpStarts %10u\n",
M.tasmtp.SmtpStarts);
/*TA-SMTP.SmtpStarts
Number of times that the SMTP transport agent is beginning
connecting to remote system.
*/
sfprintf(fp,"TA-SMTP.SmtpConnects %10u\n",
M.tasmtp.SmtpConnects);
/*TA-SMTP.SmtpConnects
Number of times that the SMTP transport agent has successfully
made SMTP connection at the socket level.
This doesn't yet know about possible "500 go away" greeting...
*/
sfprintf(fp,"TA-SMTP.SmtpConnectFails %10u\n",
M.tasmtp.SmtpConnectFails);
/*TA-SMTP.SmtpConnectFails
Number of times that the connection formation has failed at socket level.
*/
sfprintf(fp,"TA-SMTP.SmtpConnectsCnt-G %9d\n",
M.tasmtp.SmtpConnectsCnt);
/*TA-SMTP.SmtpConnectsCnt-G
Gauge of successfully formed SFIO streams presently talking to SMTP or
LMTP destinations.
*/
sfprintf(fp,"TA-SMTP.LmtpConnects %10u\n",
M.tasmtp.LmtpConnects);
/*TA-SMTP.LmtpConnects
Number of times that the SMTP transport agent has successfully
made LMTP connection, and remote end has accepted the socket.
This doesn't yet know about possible "500 go away" greeting...
*/
sfprintf(fp,"TA-SMTP.SmtpPIPELINING %10u\n",
M.tasmtp.SmtpPIPELINING);
/*TA-SMTP.SmtpPIPELINING
Number of sessions, where remote end has published PIPELINING
capability, and we are taking advantage of it.
*/
sfprintf(fp,"TA-SMTP.SmtpSTARTTLS %10u\n",
M.tasmtp.SmtpSTARTTLS);
/*TA-SMTP.SmtpSTARTTLS
Number of sessions, where remote end has published STARTTLS
capability, and we are taking advantage of it.
*/
sfprintf(fp,"TA-SMTP.SmtpSTARTTLSok %10u\n",
M.tasmtp.SmtpSTARTTLSok);
/*TA-SMTP.SmtpSTARTTLSok
Number of sessions, where we succeeded at starting the TLS encapsulation
of the stream. (Relative to SmtpSTARTTLS.)
*/
sfprintf(fp,"TA-SMTP.SmtpSTARTTLSfail %10u\n",
M.tasmtp.SmtpSTARTTLSfail);
/*TA-SMTP.SmtpSTARTTLSfail
Number of sessions, where we failed at starting the TLS encapsulation
of the stream. (Relative to SmtpSTARTTLS.)
*/
sfprintf(fp,"TA-SMTP.SmtpEHLO %10u\n",
M.tasmtp.SmtpEHLO);
/*TA-SMTP.SmtpEHLO
Number of sent EHLO greetings.
(Sometimes we may be running in a mode forbidding EHLO, e.g. "smtp-77".)
*/
sfprintf(fp,"TA-SMTP.SmtpEHLOok %10u\n",
M.tasmtp.SmtpEHLOok);
/*TA-SMTP.SmtpEHLOok
Number of EHLO greetings yielding successfull result (and capability sets.)
*/
sfprintf(fp,"TA-SMTP.SmtpEHLOfail %10u\n",
M.tasmtp.SmtpEHLOfail);
/*TA-SMTP.SmtpEHLOfail
Number of EHLO greetings yielding failure.
*/
sfprintf(fp,"TA-SMTP.SmtpHELO %10u\n",
M.tasmtp.SmtpHELO);
/*TA-SMTP.SmtpHELO
Number of sent HELO greetings (e.g. fallback from EHLO due to
moronic firewalls, and/or due to configuration forbidding
sending of "EHLO", e.g. "smtp-77" mode.)
*/
sfprintf(fp,"TA-SMTP.SmtpHELOok %10u\n",
M.tasmtp.SmtpHELOok);
/*TA-SMTP.SmtpHELOok
Number of HELO greetings yielding successfull result.
*/
sfprintf(fp,"TA-SMTP.SmtpHELOfail %10u\n",
M.tasmtp.SmtpHELOfail);
/*TA-SMTP.SmtpHELOfail
Number of HELO greetings yielding failure result.
*/
sfprintf(fp,"TA-SMTP.SmtpLHLO %10u\n",
M.tasmtp.SmtpLHLO);
/*TA-SMTP.SmtpLHLO
Number of sent LHLO greetings, e.g. while talking to remotes
that are actually LMTP speaking message stores into which
we are doing "local delivery".
*/
sfprintf(fp,"TA-SMTP.SmtpLHLOok %10u\n",
M.tasmtp.SmtpLHLOok);
/*TA-SMTP.SmtpLHLOok
Number of LHLO greetings yielding successfull result (and capability sets)
*/
sfprintf(fp,"TA-SMTP.SmtpLHLOfail %10u\n",
M.tasmtp.SmtpLHLOfail);
/*TA-SMTP.SmtpLHLOfail
Number of LHLO greetings yielding failure result.
*/
sfprintf(fp,"TA-SMTP.capa8BITMIME %10u\n",
M.tasmtp.EHLOcapability8BITMIME);
/*TA-SMTP.capa8BITMIME
Number of times that EHLO (and LHLO) greeting capability sets
have contained "8BITMIME".
*/
sfprintf(fp,"TA-SMTP.capaAUTH %10u\n",
M.tasmtp.EHLOcapabilityAUTH);
/*TA-SMTP.capaAUTH
Number of times that EHLO (and LHLO) greeting capability sets
have contained "AUTH".
*/
sfprintf(fp,"TA-SMTP.capaDSN %10u\n",
M.tasmtp.EHLOcapabilityDSN);
/*TA-SMTP.capaDSN
Number of times that EHLO (and LHLO) greeting capability sets
have contained "DSN".
*/
sfprintf(fp,"TA-SMTP.capaCHUNKING %10u\n",
M.tasmtp.EHLOcapabilityCHUNKING);
/*TA-SMTP.capaCHUNKING
Number of times that EHLO (and LHLO) greeting capability sets
have contained "CHUNKING".
*/
sfprintf(fp,"TA-SMTP.capaDELIVERBY %10u\n",
M.tasmtp.EHLOcapabilityDELIVERBY);
/*TA-SMTP.capaDELIVERBY
Number of times that EHLO (and LHLO) greeting capability sets
have contained "DELIVERBY".
*/
sfprintf(fp,"TA-SMTP.capaENHANCEDSTATUSCODES %10u\n",
M.tasmtp.EHLOcapabilityENHANCEDSTATUSCODES);
/*TA-SMTP.capaENHANCEDSTATUSCODES
Number of times that EHLO (and LHLO) greeting capability sets
have contained "ENHANCEDSTATUSCODES".
*/
sfprintf(fp,"TA-SMTP.capaPIPELINING %10u\n",
M.tasmtp.EHLOcapabilityPIPELINING);
/*TA-SMTP.capaPIPELINING
Number of times that EHLO (and LHLO) greeting capability sets
have contained "PIPELINING".
*/
sfprintf(fp,"TA-SMTP.capaSIZE %10u\n",
M.tasmtp.EHLOcapabilitySIZE);
/*TA-SMTP.capaSIZE
Number of times that EHLO (and LHLO) greeting capability sets
have contained "SIZE".
*/
sfprintf(fp,"TA-SMTP.capaSTARTTLS %10u\n",
M.tasmtp.EHLOcapabilitySTARTTLS);
/*TA-SMTP.capaSTARTTLS
Number of times that EHLO (and LHLO) greeting capability sets
have contained "STARTTLS".
*/
sfprintf(fp,"TA-SMTP.sent-option-ENVID %10u\n",
M.tasmtp.SmtpOPT_ENVID);
/*TA-SMTP.sent-option-ENVID
Number of times that these transport agents have sent
out the "ENVID=" option.
*/
sfprintf(fp,"TA-SMTP.sent-option-SIZE %10u\n",
M.tasmtp.SmtpOPT_SIZE);
/*TA-SMTP.sent-option-SIZE
Number of times that these transport agents have sent
out the "SIZE=" option.
*/
sfprintf(fp,"TA-SMTP.sent-option-RET %10u\n",
M.tasmtp.SmtpOPT_RET);
/*TA-SMTP.sent-option-RET
Number of times that these transport agents have sent
out the "RET=" option.
*/
sfprintf(fp,"TA-SMTP.sent-option-NOTIFY %10u\n",
M.tasmtp.SmtpOPT_NOTIFY);
/*TA-SMTP.sent-option-NOTIFY
Number of times that these transport agents have sent
out the "NOTIFY=" option.
*/
sfprintf(fp,"TA-SMTP.sent-option-ORCPT %10u\n",
M.tasmtp.SmtpOPT_ORCPT);
/*TA-SMTP.sent-option-ORCPT
Number of times that these transport agents have sent
out the "ORCPT=" option.
*/
sfprintf(fp,"TA-SMTP.SmtpMAIL %10u\n",
M.tasmtp.SmtpMAIL);
/*TA-SMTP.SmtpMAIL
Number of times that "MAIL" verb has been sent (or at least tried to.)
*/
sfprintf(fp,"TA-SMTP.SmtpMAILok %10u\n",
M.tasmtp.SmtpMAILok);
/*TA-SMTP.SmtpMAILok
Number of times that "MAIL" verb got "ok" result back.
*/
sfprintf(fp,"TA-SMTP.SmtpRCPT %10u\n",
M.tasmtp.SmtpRCPT);
/*TA-SMTP.SmtpRCPT
Number of times that "RCPT" verb has been sent (or at least tried to.)
*/
sfprintf(fp,"TA-SMTP.SmtpRCPTok %10u\n",
M.tasmtp.SmtpRCPTok);
/*TA-SMTP.SmtpRCPTok
Number of times that "RCPT" verb got "ok" result back.
*/
sfprintf(fp,"TA-SMTP.SmtpDATA %10u\n",
M.tasmtp.SmtpDATA);
/*TA-SMTP.SmtpDATA
Number of times that "DATA" verb has been sent (or at least tried to.)
*/
sfprintf(fp,"TA-SMTP.SmtpDATAok %10u\n",
M.tasmtp.SmtpDATAok);
/*TA-SMTP.SmtpDATAok
Number of times that "DATA" verb got "ok" result back.
*/
sfprintf(fp,"TA-SMTP.SmtpBDAT %10u\n",
M.tasmtp.SmtpBDAT);
/*TA-SMTP.SmtpBDAT
Number of times that "BDAT" verb has been sent (or at least tried to.)
*/
sfprintf(fp,"TA-SMTP.SmtpBDATok %10u\n",
M.tasmtp.SmtpBDATok);
/*TA-SMTP.SmtpBDATok
Number of times that "BDAT" verb got "ok" result back.
*/
sfprintf(fp,"TA-SMTP.SmtpDATAvolume-kB %10u\n",
M.tasmtp.SmtpDATAvolume);
/*TA-SMTP.SmtpDATAvolume-kB
Number of kilobytes written to remote systems within DATA transaction.
*/
sfprintf(fp,"TA-SMTP.SmtpBDATvolume-kB %10u\n",
M.tasmtp.SmtpBDATvolume);
/*TA-SMTP.SmtpBDATvolume-kB
Number of kilobytes written to remote systems within BDAT transaction.
*/
sfprintf(fp,"TA-SMTP.RcptsOk %10u\n",
M.tasmtp.TaRcptsOk);
/*TA-SMTP.RcptsOk
Number of recipient addresses that have been diagnosed as successfully processed.
*/
sfprintf(fp,"TA-SMTP.RcptsRetry %10u\n",
M.tasmtp.TaRcptsRetry);
/*TA-SMTP.RcptsRetry
Number of recipient addresses that have been diagnosed as needing to be retried.
*/
sfprintf(fp,"TA-SMTP.RcptsFail %10u\n",
M.tasmtp.TaRcptsFail);
/*TA-SMTP.RcptsFail
Number of recipient addresses that have been diagnosed as unsuccessfully processed.
*/
#if 0
sfprintf(fp,"mtaSuccessfulConvertedMessages %10u\n",
M.tasmtp.SuccessfulConvertedMessages);
sfprintf(fp,"mtaFailedConvertedMessages %10u\n",
M.tasmtp.FailedConvertedMessages);
sfprintf(fp,"mtaLoopsDetected %10u\n",
M.tasmtp.LoopsDetected);
#endif
/* SM: */
sfprintf(fp,"\n");
/*TA-SMCM.*
SendMail Compatible Mailer transport agent counters and gauges.
*/
sfprintf(fp,"TA-SMCM.TaProcessStarts %10u\n",
M.tasmcm.TaProcessStarts);
/*TA-SMCM.TaProcessStarts
Number of times that this transport agent processes type have been
started in this system during this SHM blocks lifetime.
*/
sfprintf(fp,"TA-SMCM.TaProcCount-G %9d\n",
M.tasmcm.TaProcCountG);
/*TA-SMCM.TaProcCount-G
Gauge of presently running transport agent processes of this type.
*/
sfprintf(fp,"TA-SMCM.TaIdleStates %10u\n",
M.tasmcm.TaIdleStates);
/*TA-SMCM.TaIdleStates
Number of times this transport agent process type has been placed
into "idle" state by the scheduler.
*/
sfprintf(fp,"TA-SMCM.TaMessages %10u\n",
M.tasmcm.TaMessages);
/*TA-SMCM.TaMessages
Number of tasks fed to this transport agent process type by the scheduler.
*/
sfprintf(fp,"TA-SMCM.TaDeliveryStarts %10u\n",
M.tasmcm.TaDeliveryStarts);
/*TA-SMCM.TaDeliveryStarts
Number of times that this transport agent type has started a delivery on
given tasks. This might be lower count, than TaMessages.
*/
sfprintf(fp,"TA-SMCM.RcptsOk %10u\n",
M.tasmcm.TaRcptsOk);
/*TA-SMCM.RcptsOk
Number of recipient addresses that have been diagnosed as successfully processed.
*/
sfprintf(fp,"TA-SMCM.RcptsRetry %10u\n",
M.tasmcm.TaRcptsRetry);
/*TA-SMCM.RcptsRetry
Number of recipient addresses that have been diagnosed as needing to be retried.
*/
sfprintf(fp,"TA-SMCM.RcptsFail %10u\n",
M.tasmcm.TaRcptsFail);
/*TA-SMCM.RcptsFail
Number of recipient addresses that have been diagnosed as unsuccessfully processed.
*/
sfprintf(fp,"\n");
/*TA-MBOX.*
MailBOX transport agent counters and gauges.
*/
sfprintf(fp,"TA-MBOX.TaProcessStarts %10u\n",
M.tambox.TaProcessStarts);
/*TA-MBOX.TaProcessStarts
Number of times that this transport agent processes type have been
started in this system during this SHM blocks lifetime.
*/
sfprintf(fp,"TA-MBOX.TaProcCount-G %9d\n",
M.tambox.TaProcCountG);
/*TA-MBOX.TaProcCount-G
Gauge of presently running transport agent processes of this type.
*/
sfprintf(fp,"TA-MBOX.TaIdleStates %10u\n",
M.tambox.TaIdleStates);
/*TA-MBOX.TaIdleStates
Number of times this transport agent process type has been placed
into "idle" state by the scheduler.
*/
sfprintf(fp,"TA-MBOX.TaMessages %10u\n",
M.tambox.TaMessages);
/*TA-MBOX.TaMessages
Number of tasks fed to this transport agent process type by the scheduler.
*/
sfprintf(fp,"TA-MBOX.TaDeliveryStarts %10u\n",
M.tambox.TaDeliveryStarts);
/*TA-MBOX.TaDeliveryStarts
Number of times that this transport agent type has started a delivery on
given tasks. This might be lower count, than TaMessages.
*/
sfprintf(fp,"TA-MBOX.RcptsOk %10u\n",
M.tambox.TaRcptsOk);
/*TA-MBOX.RcptsOk
Number of recipient addresses that have been diagnosed as successfully processed.
*/
sfprintf(fp,"TA-MBOX.RcptsRetry %10u\n",
M.tambox.TaRcptsRetry);
/*TA-MBOX.RcptsRetry
Number of recipient addresses that have been diagnosed as needing to be retried.
*/
sfprintf(fp,"TA-MBOX.RcptsFail %10u\n",
M.tambox.TaRcptsFail);
/*TA-MBOX.RcptsFail
Number of recipient addresses that have been diagnosed as unsuccessfully processed.
*/
sfprintf(fp,"\n");
/*TA-HOLD.*
HOLD transport agent counters and gauges.
*/
sfprintf(fp,"TA-HOLD.TaProcessStarts %10u\n",
M.tahold.TaProcessStarts);
/*TA-HOLD.TaProcessStarts
Number of times that this transport agent processes type have been
started in this system during this SHM blocks lifetime.
*/
sfprintf(fp,"TA-HOLD.TaProcCount-G %9d\n",
M.tahold.TaProcCountG);
/*TA-HOLD.TaProcCount-G
Gauge of presently running transport agent processes of this type.
*/
sfprintf(fp,"TA-HOLD.TaIdleStates %10u\n",
M.tahold.TaIdleStates);
/*TA-HOLD.TaIdleStates
Number of times this transport agent process type has been placed
into "idle" state by the scheduler.
*/
sfprintf(fp,"TA-HOLD.TaMessages %10u\n",
M.tahold.TaMessages);
/*TA-HOLD.TaMessages
Number of tasks fed to this transport agent process type by the scheduler.
*/
sfprintf(fp,"TA-HOLD.TaDeliveryStarts %10u\n",
M.tahold.TaDeliveryStarts);
/*TA-HOLD.TaDeliveryStarts
Number of times that this transport agent type has started a delivery on
given tasks. This might be lower count, than TaMessages.
*/
sfprintf(fp,"TA-HOLD.RcptsOk %10u\n",
M.tahold.TaRcptsOk);
/*TA-HOLD.RcptsOk
Number of recipient addresses that have been diagnosed as successfully processed.
*/
sfprintf(fp,"TA-HOLD.RcptsRetry %10u\n",
M.tahold.TaRcptsRetry);
/*TA-HOLD.RcptsRetry
Number of recipient addresses that have been diagnosed as needing to be retried.
*/
sfprintf(fp,"TA-HOLD.RcptsFail %10u\n",
M.tahold.TaRcptsFail);
/*TA-HOLD.RcptsFail
Number of recipient addresses that have been diagnosed as unsuccessfully processed.
*/
sfprintf(fp,"\n");
/*TA-ERRM.*
ERRorMail transport agent counters and gauges.
*/
sfprintf(fp,"TA-ERRM.TaProcessStarts %10u\n",
M.taerrm.TaProcessStarts);
/*TA-ERRM.TaProcessStarts
Number of times that this transport agent processes type have been
started in this system during this SHM blocks lifetime.
*/
sfprintf(fp,"TA-ERRM.TaProcCount-G %9d\n",
M.taerrm.TaProcCountG);
/*TA-ERRM.TaProcCount-G
Gauge of presently running transport agent processes of this type.
*/
sfprintf(fp,"TA-ERRM.TaIdleStates %10u\n",
M.taerrm.TaIdleStates);
/*TA-ERRM.TaIdleStates
Number of times this transport agent process type has been placed
into "idle" state by the scheduler.
*/
sfprintf(fp,"TA-ERRM.TaMessages %10u\n",
M.taerrm.TaMessages);
/*TA-ERRM.TaMessages
Number of tasks fed to this transport agent process type by the scheduler.
*/
sfprintf(fp,"TA-ERRM.TaDeliveryStarts %10u\n",
M.taerrm.TaDeliveryStarts);
/*TA-ERRM.TaDeliveryStarts
Number of times that this transport agent type has started a delivery on
given tasks. This might be lower count, than TaMessages.
*/
sfprintf(fp,"TA-ERRM.RcptsOk %10u\n",
M.taerrm.TaRcptsOk);
/*TA-ERRM.RcptsOk
Number of recipient addresses that have been diagnosed as successfully processed.
*/
sfprintf(fp,"TA-ERRM.RcptsRetry %10u\n",
M.taerrm.TaRcptsRetry);
/*TA-ERRM.RcptsRetry
Number of recipient addresses that have been diagnosed as needing to be retried.
*/
sfprintf(fp,"TA-ERRM.RcptsFail %10u\n",
M.taerrm.TaRcptsFail);
/*TA-ERRM.RcptsFail
Number of recipient addresses that have been diagnosed as unsuccessfully processed.
*/
sfprintf(fp,"\n");
/*TA-EXPI.*
EXPIrer transport agent counters and gauges.
*/
sfprintf(fp,"TA-EXPI.TaProcessStarts %10u\n",
M.taexpi.TaProcessStarts);
/*TA-EXPI.TaProcessStarts
Number of times that this transport agent processes type have been
started in this system during this SHM blocks lifetime.
*/
sfprintf(fp,"TA-EXPI.TaProcCount-G %9d\n",
M.taexpi.TaProcCountG);
/*TA-EXPI.TaProcCount-G
Gauge of presently running transport agent processes of this type.
*/
sfprintf(fp,"TA-EXPI.TaIdleStates %10u\n",
M.taexpi.TaIdleStates);
/*TA-EXPI.TaIdleStates
Number of times this transport agent process type has been placed
into "idle" state by the scheduler.
*/
sfprintf(fp,"TA-EXPI.TaMessages %10u\n",
M.taexpi.TaMessages);
/*TA-EXPI.TaMessages
Number of tasks fed to this transport agent process type by the scheduler.
*/
sfprintf(fp,"TA-EXPI.TaDeliveryStarts %10u\n",
M.taexpi.TaDeliveryStarts);
/*TA-EXPI.TaDeliveryStarts
Number of times that this transport agent type has started a delivery on
given tasks. This might be lower count, than TaMessages.
*/
sfprintf(fp,"TA-EXPI.RcptsOk %10u\n",
M.taexpi.TaRcptsOk);
/*TA-EXPI.RcptsOk
Number of recipient addresses that have been diagnosed as successfully processed.
*/
sfprintf(fp,"TA-EXPI.RcptsRetry %10u\n",
M.taexpi.TaRcptsRetry);
/*TA-EXPI.RcptsRetry
Number of recipient addresses that have been diagnosed as needing to be retried.
*/
sfprintf(fp,"TA-EXPI.RcptsFail %10u\n",
M.taexpi.TaRcptsFail);
/*TA-EXPI.RcptsFail
Number of recipient addresses that have been diagnosed as unsuccessfully processed.
*/
sfprintf(fp,"\n");
/*TA-RERT.*
RERouTer transport agent counters and gauges.
*/
sfprintf(fp,"TA-RERT.TaProcessStarts %10u\n",
M.tarert.TaProcessStarts);
/*TA-RERT.TaProcessStarts
Number of times that this transport agent processes type have been
started in this system during this SHM blocks lifetime.
*/
sfprintf(fp,"TA-RERT.TaProcCount-G %9d\n",
M.tarert.TaProcCountG);
/*TA-RERT.TaProcCount-G
Gauge of presently running transport agent processes of this type.
*/
sfprintf(fp,"TA-RERT.TaIdleStates %10u\n",
M.tarert.TaIdleStates);
/*TA-RERT.TaIdleStates
Number of times this transport agent process type has been placed
into "idle" state by the scheduler.
*/
sfprintf(fp,"TA-RERT.TaMessages %10u\n",
M.tarert.TaMessages);
/*TA-RERT.TaMessages
Number of tasks fed to this transport agent process type by the scheduler.
*/
sfprintf(fp,"TA-RERT.TaDeliveryStarts %10u\n",
M.tarert.TaDeliveryStarts);
/*TA-RERT.TaDeliveryStarts
Number of times that this transport agent type has started a delivery on
given tasks. This might be lower count, than TaMessages.
*/
sfprintf(fp,"TA-RERT.RcptsOk %10u\n",
M.tarert.TaRcptsOk);
/*TA-RERT.RcptsOk
Number of recipient addresses that have been diagnosed as successfully processed.
*/
sfprintf(fp,"TA-RERT.RcptsRetry %10u\n",
M.tarert.TaRcptsRetry);
/*TA-RERT.RcptsRetry
Number of recipient addresses that have been diagnosed as needing to be retried.
*/
sfprintf(fp,"TA-RERT.RcptsFail %10u\n",
M.tarert.TaRcptsFail);
/*TA-RERT.RcptsFail
Number of recipient addresses that have been diagnosed as unsuccessfully processed.
*/