/*-------------------------------------------------------------------*/
int http_command(int argc, char *argv[])
{
int rc = 0;
if ( !http_struct_init )
{
memset(&http_serv,0,sizeof(HTTP_SERV));
initialize_condition( &http_serv.http_wait_shutdown );
initialize_lock( &http_serv.http_lock_shutdown );
initialize_lock( &http_lock_root );
http_struct_init = TRUE;
}
http_serv.httpstmtold = FALSE;
if ( argc == 2 && CMD(argv[0],rootx,4) &&
( ( strlen(argv[0]) == 5 && argv[2] != NULL && strcmp(argv[2],"httproot") == 0 ) ||
( strlen(argv[0]) == 4 ) ) )
{
if ( strlen(argv[0]) == 5 )
{
http_serv.httpstmtold = TRUE;
}
obtain_lock( &http_lock_root );
if (http_serv.httproot)
{
free(http_serv.httproot);
http_serv.httproot = NULL;
}
if ( strlen(argv[1]) > 0 )
{
char pathname[MAX_PATH];
hostpath(pathname, argv[1], sizeof(pathname));
if ( pathname[strlen(pathname)-1] != PATHSEPC )
strlcat( pathname, PATHSEPS, sizeof(pathname) );
http_serv.httproot = strdup(pathname);
}
release_lock( &http_lock_root );
http_root();
if ( MLVL(VERBOSE) )
WRMSG(HHC02204, "I", http_serv.httpstmtold ? "httproot": "root",
http_serv.httproot ? http_serv.httproot : "<not specified>");
if ( http_serv.httpstmtold )
http_startup(TRUE);
rc = 0;
}
else if ( (argc == 2 || argc == 3 || argc == 5) && CMD(argv[0],portx,4) &&
( ( strlen(argv[0]) == 5 && argv[5] != NULL && strcmp(argv[5],"httpport") == 0 ) ||
( strlen(argv[0]) == 4 ) ) )
{
if ( strlen(argv[0]) == 5 )
{
http_serv.httpstmtold = TRUE;
}
if ( sysblk.httptid != 0 )
{
WRMSG( HHC01812, "E" );
rc = -1;
}
else
{
char c;
if (sscanf(argv[1], "%hu%c", &http_serv.httpport, &c) != 1
|| http_serv.httpport == 0
|| (http_serv.httpport < 1024 && http_serv.httpport != 80) )
{
rc = -1;
}
if ( rc >= 0 && argc == 3 && CMD(argv[2],noauth,6) )
{
http_serv.httpauth = 0;
}
else if ( rc >=0 && argc == 5 && CMD(argv[2],auth,4) )
{
if ( strlen( argv[3] ) < 1 || strlen( argv[4] ) < 1 )
{
WRMSG( HHC01814, "E" );
rc = -1;
}
else
{
if (http_serv.httpuser)
free(http_serv.httpuser);
http_serv.httpuser = strdup(argv[3]);
if (http_serv.httppass)
free(http_serv.httppass);
http_serv.httppass = strdup(argv[4]);
http_serv.httpauth = 1;
}
}
else if ( argc != 2 || rc < 0 )
{
WRMSG( HHC02299, "E", "http" );
rc = -1;
}
if ( rc >= 0 && MLVL(VERBOSE) )
{
char msgbuf[128];
if ( http_serv.httpauth == 1 )
{
MSGBUF( msgbuf, "port=%hu auth userid<%s> password<%s>",
http_serv.httpport,
( http_serv.httpuser == NULL || strlen(http_serv.httpuser) == 0 ) ?
"" : http_serv.httpuser,
( http_serv.httppass == NULL || strlen(http_serv.httppass) == 0 ) ?
"" : http_serv.httppass );
}
else
MSGBUF( msgbuf, "port=%hu noauth", http_serv.httpport );
WRMSG( HHC02204, "I", http_serv.httpstmtold ? "httpport":"port", msgbuf );
if ( http_serv.httpstmtold )
http_startup(TRUE);
} /* VERBOSE */
}
}
else if ( argc == 1 && CMD(argv[0],start,3) )
{
if ( http_serv.httpport == 0 )
{
WRMSG( HHC01815, "E", "not valid");
rc = -1;
}
else
rc = http_startup(FALSE);
}
else if (argc == 1 && CMD(argv[0],stop,4))
{
if ( sysblk.httptid != 0 )
{
http_shutdown(NULL);
WRMSG( HHC01805, "I" );
rc = 1;
}
else
{
http_serv.httpshutdown = TRUE;
WRMSG( HHC01806, "W", "already stopped" );
rc = 1;
}
}
else if ( argc == 0 )
{
if ( sysblk.httptid != 0 )
{
if ( http_serv.httpbinddone )
{
WRMSG( HHC01809, "I" );
rc = 0;
}
else
{
WRMSG( HHC01813, "I" );
rc = 1;
}
}
else
{
WRMSG( HHC01810, "I" );
rc = 1;
}
WRMSG(HHC01811, "I", http_get_root());
WRMSG(HHC01808, "I", http_get_port(), http_get_portauth());
}
else
{
WRMSG( HHC02299, "E", "http" );
rc = -1;
}
return rc;
}
DLL_EXPORT void strerror_r_init(void)
{
initialize_lock(&strerror_lock);
}
int CTCI_Init( DEVBLK* pDEVBLK, int argc, char *argv[] )
{
PCTCBLK pWrkCTCBLK = NULL; // Working CTCBLK
PCTCBLK pDevCTCBLK = NULL; // Device CTCBLK
int rc = 0; // Return code
int nIFType; // Interface type
int nIFFlags; // Interface flags
char thread_name[32]; // CTCI_ReadThread
nIFType = // Interface type
0
| IFF_TUN // ("TUN", not "tap")
| IFF_NO_PI // (no packet info)
;
nIFFlags = // Interface flags
0
| IFF_UP // (interface is being enabled)
| IFF_BROADCAST // (interface broadcast addr is valid)
;
#if defined( TUNTAP_IFF_RUNNING_NEEDED )
nIFFlags |= // ADDITIONAL Interface flags
0
| IFF_RUNNING // (interface is ALSO operational)
;
#endif /* defined( TUNTAP_IFF_RUNNING_NEEDED ) */
pDEVBLK->devtype = 0x3088;
// CTC is a group device
if(!group_device(pDEVBLK, CTC_DEVICES_IN_GROUP))
return 0;
// Housekeeping
pWrkCTCBLK = malloc( sizeof( CTCBLK ) );
if( !pWrkCTCBLK )
{
logmsg( _("HHCCT037E %4.4X: Unable to allocate CTCBLK\n"),
pDEVBLK->devnum );
return -1;
}
memset( pWrkCTCBLK, 0, sizeof( CTCBLK ) );
// Parse configuration file statement
if( ParseArgs( pDEVBLK, pWrkCTCBLK, argc, (char**)argv ) != 0 )
{
free( pWrkCTCBLK );
pWrkCTCBLK = NULL;
return -1;
}
// Allocate the device CTCBLK and copy parsed information.
pDevCTCBLK = malloc( sizeof( CTCBLK ) );
if( !pDevCTCBLK )
{
logmsg( _("HHCCT038E %4.4X: Unable to allocate CTCBLK\n"),
pDEVBLK->devnum );
free( pWrkCTCBLK );
pWrkCTCBLK = NULL;
return -1;
}
memcpy( pDevCTCBLK, pWrkCTCBLK, sizeof( CTCBLK ) );
// New format has only one device statement for both addresses
// We need to dynamically allocate the read device block
pDevCTCBLK->pDEVBLK[0] = pDEVBLK->group->memdev[0];
pDevCTCBLK->pDEVBLK[1] = pDEVBLK->group->memdev[1];
pDevCTCBLK->pDEVBLK[0]->dev_data = pDevCTCBLK;
pDevCTCBLK->pDEVBLK[1]->dev_data = pDevCTCBLK;
SetSIDInfo( pDevCTCBLK->pDEVBLK[0], 0x3088, 0x08, 0x3088, 0x01 );
SetSIDInfo( pDevCTCBLK->pDEVBLK[1], 0x3088, 0x08, 0x3088, 0x01 );
pDevCTCBLK->pDEVBLK[0]->ctctype = CTC_CTCI;
pDevCTCBLK->pDEVBLK[0]->ctcxmode = 1;
pDevCTCBLK->pDEVBLK[1]->ctctype = CTC_CTCI;
pDevCTCBLK->pDEVBLK[1]->ctcxmode = 1;
pDevCTCBLK->sMTU = atoi( pDevCTCBLK->szMTU );
pDevCTCBLK->iMaxFrameBufferSize = sizeof(pDevCTCBLK->bFrameBuffer);
initialize_lock( &pDevCTCBLK->Lock );
initialize_lock( &pDevCTCBLK->EventLock );
initialize_condition( &pDevCTCBLK->Event );
// Give both Herc devices a reasonable name...
strlcpy( pDevCTCBLK->pDEVBLK[0]->filename,
pDevCTCBLK->szTUNCharName,
sizeof( pDevCTCBLK->pDEVBLK[0]->filename ) );
strlcpy( pDevCTCBLK->pDEVBLK[1]->filename,
pDevCTCBLK->szTUNCharName,
sizeof( pDevCTCBLK->pDEVBLK[1]->filename ) );
rc = TUNTAP_CreateInterface( pDevCTCBLK->szTUNCharName,
IFF_TUN | IFF_NO_PI,
&pDevCTCBLK->fd,
pDevCTCBLK->szTUNDevName );
if( rc < 0 )
{
free( pWrkCTCBLK );
pWrkCTCBLK = NULL;
return -1;
}
else
{
logmsg(_("HHCCT073I %4.4X: TUN device %s opened\n"),
pDevCTCBLK->pDEVBLK[0]->devnum,
pDevCTCBLK->szTUNDevName);
}
#if defined(OPTION_W32_CTCI)
// Set the specified driver/dll i/o buffer sizes..
{
struct tt32ctl tt32ctl;
memset( &tt32ctl, 0, sizeof(tt32ctl) );
strlcpy( tt32ctl.tt32ctl_name, pDevCTCBLK->szTUNDevName, sizeof(tt32ctl.tt32ctl_name) );
tt32ctl.tt32ctl_devbuffsize = pDevCTCBLK->iKernBuff;
if( TUNTAP_IOCtl( pDevCTCBLK->fd, TT32SDEVBUFF, (char*)&tt32ctl ) != 0 )
{
logmsg( _("HHCCT074W TT32SDEVBUFF failed for device %s: %s.\n"),
pDevCTCBLK->szTUNDevName, strerror( errno ) );
}
tt32ctl.tt32ctl_iobuffsize = pDevCTCBLK->iIOBuff;
if( TUNTAP_IOCtl( pDevCTCBLK->fd, TT32SIOBUFF, (char*)&tt32ctl ) != 0 )
{
logmsg( _("HHCCT075W TT32SIOBUFF failed for device %s: %s.\n"),
pDevCTCBLK->szTUNDevName, strerror( errno ) );
}
}
#endif
#ifdef OPTION_TUNTAP_CLRIPADDR
VERIFY( TUNTAP_ClrIPAddr ( pDevCTCBLK->szTUNDevName ) == 0 );
#endif
#ifdef OPTION_TUNTAP_SETMACADDR
if( !pDevCTCBLK->szMACAddress[0] ) // (if MAC address unspecified)
{
in_addr_t wrk_guest_ip_addr;
MAC wrk_guest_mac_addr;
if ((in_addr_t)-1 != (wrk_guest_ip_addr = inet_addr( pDevCTCBLK->szGuestIPAddr )))
{
build_herc_iface_mac ( wrk_guest_mac_addr, (const BYTE*) &wrk_guest_ip_addr );
snprintf
(
pDevCTCBLK->szMACAddress, sizeof( pDevCTCBLK->szMACAddress ),
"%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
,wrk_guest_mac_addr[0]
,wrk_guest_mac_addr[1]
,wrk_guest_mac_addr[2]
,wrk_guest_mac_addr[3]
,wrk_guest_mac_addr[4]
,wrk_guest_mac_addr[5]
);
}
}
TRACE
(
"** CTCI_Init: %4.4X (%s): IP \"%s\" --> default MAC \"%s\"\n"
,pDevCTCBLK->pDEVBLK[0]->devnum
,pDevCTCBLK->szTUNDevName
,pDevCTCBLK->szGuestIPAddr
,pDevCTCBLK->szMACAddress
);
VERIFY( TUNTAP_SetMACAddr ( pDevCTCBLK->szTUNDevName, pDevCTCBLK->szMACAddress ) == 0 );
#endif
VERIFY( TUNTAP_SetIPAddr ( pDevCTCBLK->szTUNDevName, pDevCTCBLK->szDriveIPAddr ) == 0 );
VERIFY( TUNTAP_SetDestAddr( pDevCTCBLK->szTUNDevName, pDevCTCBLK->szGuestIPAddr ) == 0 );
#ifdef OPTION_TUNTAP_SETNETMASK
VERIFY( TUNTAP_SetNetMask ( pDevCTCBLK->szTUNDevName, pDevCTCBLK->szNetMask ) == 0 );
#endif
VERIFY( TUNTAP_SetMTU ( pDevCTCBLK->szTUNDevName, pDevCTCBLK->szMTU ) == 0 );
VERIFY( TUNTAP_SetFlags ( pDevCTCBLK->szTUNDevName, nIFFlags ) == 0 );
// Copy the fd to make panel.c happy
pDevCTCBLK->pDEVBLK[0]->fd =
pDevCTCBLK->pDEVBLK[1]->fd = pDevCTCBLK->fd;
snprintf(thread_name,sizeof(thread_name),"CTCI %4.4X ReadThread",pDEVBLK->devnum);
thread_name[sizeof(thread_name)-1]=0;
create_thread( &pDevCTCBLK->tid, JOINABLE, CTCI_ReadThread, pDevCTCBLK, thread_name );
pDevCTCBLK->pDEVBLK[0]->tid = pDevCTCBLK->tid;
pDevCTCBLK->pDEVBLK[1]->tid = pDevCTCBLK->tid;
free( pWrkCTCBLK );
pWrkCTCBLK = NULL;
return 0;
}
/*-------------------------------------------------------------------*/
DLL_EXPORT int impl(int argc, char *argv[])
{
char *cfgfile; /* -> Configuration filename */
int c; /* Work area for getopt */
int arg_error = 0; /* 1=Invalid arguments */
char *msgbuf; /* */
int msgnum; /* */
int msgcnt; /* */
TID rctid; /* RC file thread identifier */
TID logcbtid; /* RC file thread identifier */
SET_THREAD_NAME("impl");
/* Initialize 'hostinfo' BEFORE display_version is called */
init_hostinfo( &hostinfo );
#ifdef _MSVC_
/* Initialize sockets package */
VERIFY( socket_init() == 0 );
#endif
/* Ensure hdl_shut is called in case of shutdown
hdl_shut will ensure entries are only called once */
atexit(hdl_shut);
set_codepage(NULL);
/* Clear the system configuration block */
memset (&sysblk, 0, sizeof(SYSBLK));
/* Save thread ID of main program */
sysblk.impltid = thread_id();
/* Save TOD of when we were first IMPL'ed */
time( &sysblk.impltime );
#ifdef OPTION_MSGHLD
/* Set the default timeout value */
sysblk.keep_timeout_secs = 120;
#endif
/* Initialize thread creation attributes so all of hercules
can use them at any time when they need to create_thread
*/
initialize_detach_attr (DETACHED);
initialize_join_attr (JOINABLE);
/* Copy length for regs */
sysblk.regs_copy_len = (int)((uintptr_t)&sysblk.dummyregs.regs_copy_end
- (uintptr_t)&sysblk.dummyregs);
/* Set the daemon_mode flag indicating whether we running in
background/daemon mode or not (meaning both stdout/stderr
are redirected to a non-tty device). Note that this flag
needs to be set before logger_init gets called since the
logger_logfile_write function relies on its setting.
*/
sysblk.daemon_mode = !isatty(STDERR_FILENO) && !isatty(STDOUT_FILENO);
/* Initialize the logmsg pipe and associated logger thread.
This causes all subsequent logmsg's to be redirected to
the logger facility for handling by virtue of stdout/stderr
being redirected to the logger facility.
*/
logger_init();
/* Now display the version information again after logger_init
has been called so that either the panel display thread or the
external gui can see the version which was previously possibly
only displayed to the actual physical screen the first time we
did it further above (depending on whether we're running in
daemon_mode (external gui mode) or not). This it the call that
the panel thread or the one the external gui actually "sees".
The first call further above wasn't seen by either since it
was issued before logger_init was called and thus got written
directly to the physical screen whereas this one will be inter-
cepted and handled by the logger facility thereby allowing the
panel thread or external gui to "see" it and thus display it.
*/
display_version (stdout, "Hercules ", TRUE);
#if defined(OPTION_DYNAMIC_LOAD)
/* Initialize the hercules dynamic loader */
hdl_main();
#endif /* defined(OPTION_DYNAMIC_LOAD) */
#ifdef EXTERNALGUI
/* Set GUI flag if specified as final argument */
if (argc >= 1 && strncmp(argv[argc-1],"EXTERNALGUI",11) == 0)
{
#if defined(OPTION_DYNAMIC_LOAD)
if (hdl_load("dyngui",HDL_LOAD_DEFAULT) != 0)
{
usleep(10000); /* (give logger thread time to issue
preceding HHCHD007E message) */
logmsg(_("HHCIN008S DYNGUI.DLL load failed; Hercules terminated.\n"));
delayed_exit(1);
}
#endif /* defined(OPTION_DYNAMIC_LOAD) */
argc--;
}
#endif /*EXTERNALGUI*/
#if !defined(WIN32) && !defined(HAVE_STRERROR_R)
strerror_r_init();
#endif
#if defined(OPTION_SCSI_TAPE)
initialize_lock (&sysblk.stape_lock);
initialize_condition (&sysblk.stape_getstat_cond);
InitializeListHead (&sysblk.stape_mount_link);
InitializeListHead (&sysblk.stape_status_link);
#endif /* defined(OPTION_SCSI_TAPE) */
/* Get name of configuration file or default to hercules.cnf */
if(!(cfgfile = getenv("HERCULES_CNF")))
cfgfile = "hercules.cnf";
/* Process the command line options */
while ((c = getopt(argc, argv, "f:p:l:db:")) != EOF)
{
switch (c) {
case 'f':
cfgfile = optarg;
break;
#if defined(OPTION_DYNAMIC_LOAD)
case 'p':
if(optarg)
hdl_setpath(strdup(optarg));
break;
case 'l':
{
char *dllname, *strtok_str;
for(dllname = strtok_r(optarg,", ",&strtok_str);
dllname;
dllname = strtok_r(NULL,", ",&strtok_str))
hdl_load(dllname, HDL_LOAD_DEFAULT);
}
break;
#endif /* defined(OPTION_DYNAMIC_LOAD) */
case 'b':
sysblk.logofile=optarg;
break;
case 'd':
sysblk.daemon_mode = 1;
break;
default:
arg_error = 1;
} /* end switch(c) */
} /* end while */
if (optind < argc)
arg_error = 1;
/* Terminate if invalid arguments were detected */
if (arg_error)
{
logmsg("usage: %s [-f config-filename] [-d] [-b logo-filename]"
#if defined(OPTION_DYNAMIC_LOAD)
" [-p dyn-load-dir] [[-l dynmod-to-load]...]"
#endif /* defined(OPTION_DYNAMIC_LOAD) */
" [> logfile]\n",
argv[0]);
delayed_exit(1);
}
/* Register the SIGINT handler */
if ( signal (SIGINT, sigint_handler) == SIG_ERR )
{
logmsg(_("HHCIN001S Cannot register SIGINT handler: %s\n"),
strerror(errno));
delayed_exit(1);
}
/* Register the SIGTERM handler */
if ( signal (SIGTERM, sigterm_handler) == SIG_ERR )
{
logmsg(_("HHCIN009S Cannot register SIGTERM handler: %s\n"),
strerror(errno));
delayed_exit(1);
}
#if defined( _MSVC_ )
/* Register the Window console ctrl handlers */
if (SetConsoleCtrlHandler(console_ctrl_handler, TRUE) == FALSE)
{
logmsg(_("HHCIN010S Cannot register ConsoleCtrl handler: %s\n"),
strerror(errno));
delayed_exit(1);
}
#endif
#if defined(HAVE_DECL_SIGPIPE) && HAVE_DECL_SIGPIPE
/* Ignore the SIGPIPE signal, otherwise Hercules may terminate with
Broken Pipe error if the printer driver writes to a closed pipe */
if ( signal (SIGPIPE, SIG_IGN) == SIG_ERR )
{
logmsg(_("HHCIN002E Cannot suppress SIGPIPE signal: %s\n"),
strerror(errno));
}
#endif
#if defined( OPTION_WAKEUP_SELECT_VIA_PIPE )
{
int fds[2];
initialize_lock(&sysblk.cnslpipe_lock);
initialize_lock(&sysblk.sockpipe_lock);
sysblk.cnslpipe_flag=0;
sysblk.sockpipe_flag=0;
VERIFY( create_pipe(fds) >= 0 );
sysblk.cnslwpipe=fds[1];
sysblk.cnslrpipe=fds[0];
VERIFY( create_pipe(fds) >= 0 );
sysblk.sockwpipe=fds[1];
sysblk.sockrpipe=fds[0];
}
#endif // defined( OPTION_WAKEUP_SELECT_VIA_PIPE )
#if !defined(NO_SIGABEND_HANDLER)
{
struct sigaction sa;
sa.sa_sigaction = (void*)&sigabend_handler;
#ifdef SA_NODEFER
sa.sa_flags = SA_NODEFER;
#else
sa.sa_flags = 0;
#endif
/* Explictily initialize sa_mask to its default. @PJJ */
sigemptyset(&sa.sa_mask);
if( sigaction(SIGILL, &sa, NULL)
|| sigaction(SIGFPE, &sa, NULL)
|| sigaction(SIGSEGV, &sa, NULL)
|| sigaction(SIGBUS, &sa, NULL)
|| sigaction(SIGUSR1, &sa, NULL)
|| sigaction(SIGUSR2, &sa, NULL) )
{
logmsg(_("HHCIN003S Cannot register SIGILL/FPE/SEGV/BUS/USR "
"handler: %s\n"),
strerror(errno));
delayed_exit(1);
}
}
#endif /*!defined(NO_SIGABEND_HANDLER)*/
/* Build system configuration */
build_config (cfgfile);
/* System initialisation time */
sysblk.todstart = hw_clock() << 8;
#ifdef OPTION_MIPS_COUNTING
/* Initialize "maxrates" command reporting intervals */
curr_int_start_time = time( NULL );
prev_int_start_time = curr_int_start_time;
#endif
#if !defined(NO_SIGABEND_HANDLER)
/* Start the watchdog */
if ( create_thread (&sysblk.wdtid, DETACHED,
watchdog_thread, NULL, "watchdog_thread") )
{
logmsg(_("HHCIN004S Cannot create watchdog thread: %s\n"),
strerror(errno));
delayed_exit(1);
}
#endif /*!defined(NO_SIGABEND_HANDLER)*/
#ifdef OPTION_SHARED_DEVICES
/* Start the shared server */
if (sysblk.shrdport)
if ( create_thread (&sysblk.shrdtid, DETACHED,
shared_server, NULL, "shared_server") )
{
logmsg(_("HHCIN006S Cannot create shared_server thread: %s\n"),
strerror(errno));
delayed_exit(1);
}
/* Retry pending connections */
{
DEVBLK *dev;
TID tid;
for (dev = sysblk.firstdev; dev != NULL; dev = dev->nextdev)
if (dev->connecting)
if ( create_thread (&tid, DETACHED,
*dev->hnd->init, dev, "device connecting thread")
)
{
logmsg(_("HHCIN007S Cannot create %4.4X connection thread: %s\n"),
dev->devnum, strerror(errno));
delayed_exit(1);
}
}
#endif
/* Start up the RC file processing thread */
create_thread(&rctid,DETACHED,
process_rc_file,NULL,"process_rc_file");
if(log_callback)
{
// 'herclin' called us. IT'S in charge. Create its requested
// logmsg intercept callback function and return back to it.
create_thread(&logcbtid,DETACHED,
log_do_callback,NULL,"log_do_callback");
return(0);
}
//---------------------------------------------------------------
// The below functions will not return until Hercules is shutdown
//---------------------------------------------------------------
/* Activate the control panel */
if(!sysblk.daemon_mode)
panel_display ();
else
{
#if defined(OPTION_DYNAMIC_LOAD)
if(daemon_task)
daemon_task ();
else
#endif /* defined(OPTION_DYNAMIC_LOAD) */
{
/* Tell RC file and HAO threads they may now proceed */
sysblk.panel_init = 1;
/* Retrieve messages from logger and write to stderr */
while (1)
if((msgcnt = log_read(&msgbuf, &msgnum, LOG_BLOCK)))
if(isatty(STDERR_FILENO))
fwrite(msgbuf,msgcnt,1,stderr);
}
}
// -----------------------------------------------------
// *** Hercules has been shutdown (PAST tense) ***
// -----------------------------------------------------
ASSERT( sysblk.shutdown ); // (why else would we be here?!)
#ifdef _MSVC_
SetConsoleCtrlHandler(console_ctrl_handler, FALSE);
socket_deinit();
#endif
#ifdef DEBUG
fprintf(stdout, _("IMPL EXIT\n"));
#endif
fprintf(stdout, _("HHCIN099I Hercules terminated\n"));
fflush(stdout);
usleep(10000);
return 0;
} /* end function main */
