int main (int argc, char **argv)
{
int res;
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
set_blocksig();
gtm_imagetype_init(MUPIP_IMAGE);
invocation_mode = MUMPS_UTILTRIGR;
gtm_wcswidth_fnptr = gtm_wcswidth;
gtm_env_init(); /* read in all environment variables */
err_init(util_base_ch);
UNICODE_ONLY(gtm_strToTitle_ptr = >m_strToTitle);
GTM_ICU_INIT_IF_NEEDED; /* Note: should be invoked after err_init (since it may error out) and before CLI parsing */
sig_init(generic_signal_handler, NULL, suspsigs_handler, continue_handler); /* Note: no ^C handler is defined (yet) */
atexit(mupip_exit_handler);
licensed = TRUE;
in_backup = FALSE;
op_open_ptr = mu_op_open;
mu_get_term_characterstics();
cli_lex_setup(argc,argv);
if (argc < 2) /* Interactive mode */
display_prompt();
/* this call should be after cli_lex_setup() due to S390 A/E conversion */
gtm_chk_dist(argv[0]);
INIT_GBL_ROOT(); /* Needed for GVT initialization */
init_gtm();
while (TRUE)
{ func = 0;
if ((res = parse_cmd()) == EOF)
break;
else if (res)
{
if (1 < argc)
rts_error(VARLSTCNT(4) res, 2, LEN_AND_STR(cli_err_str));
else
gtm_putmsg(VARLSTCNT(4) res, 2, LEN_AND_STR(cli_err_str));
}
if (func)
func();
if (argc > 1) /* Non-interactive mode, exit after command */
break;
display_prompt();
}
mupip_exit(SS_NORMAL);
}
void iosocket_use(io_desc *iod, mval *pp)
{
unsigned char ch, len;
int handled_len, handlea_len, handles_len;
int4 length, width, new_len;
d_socket_struct *dsocketptr;
socket_struct *socketptr, newsocket;
char handlea[MAX_HANDLE_LEN], handles[MAX_HANDLE_LEN], handled[MAX_HANDLE_LEN];
char addr[SA_MAXLITLEN], *errptr, sockaddr[SA_MAXLITLEN],
temp_addr[SA_MAXLITLEN], ioerror;
unsigned char delimiter_buffer[MAX_N_DELIMITER * (MAX_DELIM_LEN + 1)];
unsigned char zff_buffer[MAX_ZFF_LEN];
boolean_t attach_specified = FALSE,
detach_specified = FALSE,
connect_specified = FALSE,
ioerror_specified = FALSE,
listen_specified = FALSE,
socket_specified = FALSE,
delay_specified = FALSE,
nodelay_specified = FALSE,
bfsize_specified = FALSE,
ibfsize_specified = FALSE,
moreread_specified = FALSE,
create_new_socket;
int4 index, n_specified, zff_len, delimiter_len, moreread_timeout;
int fil_type, nodelay, p_offset = 0;
uint4 bfsize = DEFAULT_SOCKET_BUFFER_SIZE, ibfsize;
char *tab;
int save_errno;
size_t d_socket_struct_len;
mstr lcl_zff;
assert(iod->state == dev_open);
assert(iod->type == gtmsocket);
dsocketptr = (d_socket_struct *)(iod->dev_sp);
/* ---------------------------------- parse the command line ------------------------------------ */
n_specified = 0;
zff_len = -1; /* indicates neither ZFF nor ZNOFF specified */
delimiter_len = -1; /* indicates neither DELIM nor NODELIM specified */
/* A read or wait was interrupted for this device. Allow only parmless use in $zinterrupt code for
and interrupted device.
*/
if (iop_eol != *(pp->str.addr + p_offset))
{ /* Parameters were specified */
if (dsocketptr->mupintr)
{ /* And if we are in $zinterrupt code this is not allowed */
if (dollar_zininterrupt)
rts_error(VARLSTCNT(1) ERR_ZINTRECURSEIO);
/* We are not in $zinterrupt code and this device was not resumed properly
so clear its restartability.
*/
io_find_mvstent(iod, TRUE);
dsocketptr->mupintr = FALSE;
}
} else if (dsocketptr->mupintr && !dollar_zininterrupt)
{ /* The interrupted read was not properly resumed so clear it now */
dsocketptr->mupintr = FALSE;
dsocketptr->sock_save_state.who_saved = sockwhich_invalid;
io_find_mvstent(iod, TRUE);
}
while (iop_eol != (ch = *(pp->str.addr + p_offset++)))
{
assert((params)ch < (params)n_iops);
switch (ch)
{
case iop_exception:
iod->error_handler.len = *(pp->str.addr + p_offset);
iod->error_handler.addr = (char *)(pp->str.addr + p_offset + 1);
s2pool(&iod->error_handler);
break;
case iop_filter:
len = *(pp->str.addr + p_offset);
tab = pp->str.addr + p_offset + 1;
if ((fil_type = namelook(filter_index, filter_names, tab, len)) < 0)
{
rts_error(VARLSTCNT(1) ERR_TTINVFILTER);
return;
}
switch (fil_type)
{
case 0:
iod->write_filter |= CHAR_FILTER;
break;
case 1:
iod->write_filter |= ESC1;
break;
case 2:
iod->write_filter &= ~CHAR_FILTER;
break;
case 3:
iod->write_filter &= ~ESC1;
break;
}
break;
case iop_nofilter:
iod->write_filter = 0;
break;
case iop_attach:
n_specified++;
attach_specified = TRUE;
handlea_len = (int)(*(pp->str.addr + p_offset));
memcpy(handlea, (char *)(pp->str.addr + p_offset + 1), handlea_len);
break;
case iop_detach:
n_specified++;
detach_specified = TRUE;
handled_len = (int)(*(pp->str.addr + p_offset));
memcpy(handled, (char *)(pp->str.addr + p_offset + 1), handled_len);
break;
case iop_connect:
n_specified++;
connect_specified = TRUE;
len = *(pp->str.addr + p_offset);
if (len < SA_MAXLITLEN)
{
memcpy(sockaddr, (char *)(pp->str.addr + p_offset + 1), len);
sockaddr[len] = '\0';
} else
rts_error(VARLSTCNT(6) ERR_ADDRTOOLONG,
4, len, pp->str.addr + p_offset + 1, len, SA_MAXLITLEN);
break;
case iop_delimiter:
n_specified++;
delimiter_len = (int4)(unsigned char)*(pp->str.addr + p_offset);
if (((MAX_DELIM_LEN + 1) * MAX_N_DELIMITER) >= delimiter_len)
memcpy(delimiter_buffer, (pp->str.addr + p_offset + 1), delimiter_len);
else
rts_error(VARLSTCNT(1) ERR_DELIMSIZNA);
break;
case iop_nodelimiter:
delimiter_len = 0;
break;
case iop_zdelay:
delay_specified = TRUE;
break;
case iop_znodelay:
nodelay_specified = TRUE;
break;
case iop_zbfsize:
bfsize_specified = TRUE;
GET_ULONG(bfsize, pp->str.addr + p_offset);
if ((0 == bfsize) || (MAX_SOCKET_BUFFER_SIZE < bfsize))
rts_error(VARLSTCNT(3) ERR_ILLESOCKBFSIZE, 1, bfsize);
break;
case iop_zibfsize:
ibfsize_specified = TRUE;
GET_ULONG(ibfsize, pp->str.addr + p_offset);
if ((0 == ibfsize) || (MAX_INTERNAL_SOCBUF_SIZE < ibfsize))
rts_error(VARLSTCNT(3) ERR_ILLESOCKBFSIZE, 1, ibfsize);
break;
case iop_ioerror:
n_specified++;
ioerror_specified = TRUE;
ioerror = *(char *)(pp->str.addr + p_offset + 1);
break;
case iop_zlisten:
n_specified++;
listen_specified = TRUE;
len = *(pp->str.addr + p_offset);
if (len < SA_MAXLITLEN)
{
memcpy(sockaddr, (char *)(pp->str.addr + p_offset + 1), len);
sockaddr[len] = '\0';
} else
rts_error(VARLSTCNT(6) ERR_ADDRTOOLONG,
4, len, pp->str.addr + p_offset + 1, len, SA_MAXLITLEN);
break;
case iop_socket:
n_specified++;
socket_specified = TRUE;
handles_len = (int)(*(pp->str.addr + p_offset));
memcpy(handles, (char *)(pp->str.addr + p_offset + 1), handles_len);
break;
case iop_ipchset:
#if defined(KEEP_zOS_EBCDIC) || defined(VMS)
if ((iconv_t)0 != iod->input_conv_cd)
ICONV_CLOSE_CD(iod->input_conv_cd);
SET_CODE_SET(iod->in_code_set, (char *)(pp->str.addr + p_offset + 1));
if (DEFAULT_CODE_SET != iod->in_code_set)
ICONV_OPEN_CD(iod->input_conv_cd, INSIDE_CH_SET, (char *)(pp->str.addr + p_offset + 1));
#endif
break;
case iop_opchset:
#if defined(KEEP_zOS_EBCDIC) || defined(VMS)
if ((iconv_t)0 != iod->output_conv_cd)
ICONV_CLOSE_CD(iod->output_conv_cd);
SET_CODE_SET(iod->out_code_set, (char *)(pp->str.addr + p_offset + 1));
if (DEFAULT_CODE_SET != iod->out_code_set)
ICONV_OPEN_CD(iod->output_conv_cd, (char *)(pp->str.addr + p_offset + 1), INSIDE_CH_SET);
#endif
break;
case iop_zff:
if (MAX_ZFF_LEN >= (zff_len = (int4)(unsigned char)*(pp->str.addr + p_offset)))
memcpy(zff_buffer, (char *)(pp->str.addr + p_offset + 1), zff_len);
else
rts_error(VARLSTCNT(4) ERR_ZFF2MANY, 2, zff_len, MAX_ZFF_LEN);
break;
case iop_znoff:
zff_len = 0;
break;
case iop_length:
GET_LONG(length, pp->str.addr + p_offset);
if (length < 0)
rts_error(VARLSTCNT(1) ERR_DEVPARMNEG);
iod->length = length;
break;
case iop_width:
/* SOCKET WIDTH is handled the same way as TERMINAL WIDTH */
GET_LONG(width, pp->str.addr + p_offset);
if (width < 0)
rts_error(VARLSTCNT(1) ERR_DEVPARMNEG);
if (0 == width)
{
iod->width = TCPDEF_WIDTH;
iod->wrap = FALSE;
} else
{
iod->width = width;
iod->wrap = TRUE;
}
break;
case iop_wrap:
iod->wrap = TRUE;
break;
case iop_nowrap:
iod->wrap = FALSE;
break;
case iop_morereadtime:
/* Time in milliseconds socket read will wait for more data before returning */
GET_LONG(moreread_timeout, pp->str.addr + p_offset);
if (-1 == moreread_timeout)
moreread_timeout = DEFAULT_MOREREAD_TIMEOUT;
else if (-1 > moreread_timeout)
rts_error(VARLSTCNT(1) ERR_DEVPARMNEG);
else if (MAX_MOREREAD_TIMEOUT < moreread_timeout)
rts_error(VARLSTCNT(3) ERR_MRTMAXEXCEEDED, 1, MAX_MOREREAD_TIMEOUT);
moreread_specified = TRUE;
break;
default:
/* ignore deviceparm */
break;
}
p_offset += ((io_params_size[ch] == IOP_VAR_SIZE) ?
(unsigned char)*(pp->str.addr + p_offset) + 1 : io_params_size[ch]);
}
/* ------ return immediately if no flag, worth a check because it is mostly true ------------ */
if (1 == p_offset)
return;
/* ------------------------------ compatibility verification -------------------------------- */
if ((socket_specified) && ((n_specified > 2) || ((2 == n_specified) && (0 >= delimiter_len))))
{
rts_error(VARLSTCNT(8) ERR_ACOMPTBINC, 6, LEN_AND_LIT("SOCKET"), LEN_AND_LIT("DELIMITER"), LEN_AND_LIT("USE"));
return;
}
if (connect_specified && listen_specified)
{
rts_error(VARLSTCNT(8) ERR_ABNCOMPTINC, 6, LEN_AND_LIT("CONNECT"), LEN_AND_LIT("ZLISTEN"), LEN_AND_LIT("USE"));
return;
}
if (delay_specified && nodelay_specified)
{
rts_error(VARLSTCNT(8) ERR_ABNCOMPTINC, 6, LEN_AND_LIT("DELAY"), LEN_AND_LIT("NODELAY"), LEN_AND_LIT("OPEN"));
return;
}
/* ------------------ make a local copy of device structure to play with -------------------- */
d_socket_struct_len = SIZEOF(d_socket_struct) + (SIZEOF(socket_struct) * (gtm_max_sockets - 1));
memcpy(newdsocket, dsocketptr, d_socket_struct_len);
/* --------------- handle the two special cases attach/detach first ------------------------- */
if (detach_specified)
{
if (1 < n_specified)
{
rts_error(VARLSTCNT(6) ERR_ANCOMPTINC, 4, LEN_AND_LIT("DETACH"), LEN_AND_LIT("USE"));
return;
}
if (NULL == socket_pool)
iosocket_poolinit();
iosocket_switch(handled, handled_len, newdsocket, socket_pool);
memcpy(dsocketptr, newdsocket, d_socket_struct_len);
if (0 > dsocketptr->current_socket)
{
io_curr_device.in = io_std_device.in;
io_curr_device.out = io_std_device.out;
}
return; /* detach can only be specified by itself */
}
if (attach_specified)
{ /* NOTE: A socket could be moved from one device to another using DETACH/ATTACH. A socket does not carry I[O]CHSET with
* it while being moved. Such a socket will use the I[O]CHSET of the device it is ATTACHed to. If there is input still
* buffered, this may cause unintentional consequences in the application if I[O]CHSET changes. GT.M does not detect
* (or report) a change in I[O]CHSET due to DETACH/ATTACH.
*/
if (1 < n_specified)
{
rts_error(VARLSTCNT(6) ERR_ANCOMPTINC, 4, LEN_AND_LIT("ATTACH"), LEN_AND_LIT("USE"));
return;
}
if (NULL == socket_pool)
{
rts_error(VARLSTCNT(4) ERR_SOCKNOTFND, 2, handlea_len, handlea);
return;
}
iosocket_switch(handlea, handlea_len, socket_pool, newdsocket);
memcpy(dsocketptr, newdsocket, d_socket_struct_len);
return; /* attach can only be specified by itself */
}
/* ------------ create/identify the socket to work on and make a local copy ----------------- */
if (create_new_socket = (listen_specified || connect_specified)) /* real "=" */
{
/* allocate the structure for a new socket */
if (NULL == (socketptr = iosocket_create(sockaddr, bfsize, -1)))
return;
/* give the new socket a handle */
iosocket_handle(handles, &handles_len, TRUE, dsocketptr);
socketptr->handle_len = handles_len;
memcpy(socketptr->handle, handles, handles_len);
socketptr->dev = newdsocket; /* use newdsocket temporarily for the sake of bind/connect */
} else
{
if (socket_specified)
{
/* use the socket flag to identify which socket to apply changes */
if (0 > (index = iosocket_handle(handles, &handles_len, FALSE, newdsocket)))
{
rts_error(VARLSTCNT(4) ERR_SOCKNOTFND, 2, handles_len, handles);
return;
}
newdsocket->current_socket = index;
socketptr = newdsocket->socket[index];
} else
{
socketptr = newdsocket->socket[newdsocket->current_socket];
if (newdsocket->n_socket <= newdsocket->current_socket)
{
assert(FALSE);
rts_error(VARLSTCNT(4) ERR_CURRSOCKOFR, 2, newdsocket->current_socket, newdsocket->n_socket);
return;
}
}
}
newsocket = *socketptr;
/* ---------------------- apply changes to the local copy of the socket --------------------- */
if (0 <= delimiter_len)
{
iosocket_delimiter(delimiter_buffer, delimiter_len, &newsocket, (0 == delimiter_len));
/* The delimiter has changed. The iosocket_readfl/write routine won't notice so we have to do
the UTF16xx conversion since we changed it.
*/
DBGSOCK2((stdout, "socuse: Delimiter(s) replaced - num delims: %d delimiter_len: %d ichset: %d ochset: %d\n",
newsocket.n_delimiter, delimiter_len, iod->ichset, iod->ochset));
if (0 < delimiter_len)
{
if (!newsocket.first_read && (CHSET_UTF16BE == iod->ichset || CHSET_UTF16LE == iod->ichset))
{ /* We have been reading with this socket so convert this new delimiter set */
DBGSOCK2((stdout, "socuse: Converting new delimiters for input\n"));
iosocket_delim_conv(&newsocket, iod->ichset);
}
if (!newsocket.first_write && (CHSET_UTF16BE == iod->ochset || CHSET_UTF16LE == iod->ochset))
{ /* We have been writing with this socket so convert the new default output delimiter */
DBGSOCK2((stdout, "socuse: Converting new delimiters for output\n"));
if (newsocket.first_read || (CHSET_UTF16BE != iod->ichset && CHSET_UTF16LE != iod->ichset))
{ /* Need to do conversion as iosocket_delim_conv above didn't do it for us */
DBGSOCK2((stdout, "socuse: running convert for write since input didn't do it\n"));
new_len = gtm_conv(chset_desc[CHSET_UTF8], chset_desc[iod->ochset],
&newsocket.delimiter[0], NULL, NULL);
if (MAX_DELIM_LEN < new_len)
{
rts_error(VARLSTCNT(1) ERR_DELIMSIZNA);
return;
}
} else
{
DBGSOCK2((stdout, "socuse: using previous length from read conversion\n"));
new_len = newsocket.idelimiter[0].len;
}
newsocket.odelimiter0.len = new_len;
UNICODE_ONLY(newsocket.odelimiter0.char_len = newsocket.delimiter[0].char_len);
newsocket.odelimiter0.addr = malloc(new_len);
memcpy(newsocket.odelimiter0.addr,
(newsocket.first_read ? (char *)stringpool.free : newsocket.idelimiter[0].addr),
new_len);
}
}
}
if (iod->wrap && 0 != newsocket.n_delimiter && iod->width < newsocket.delimiter[0].len)
rts_error(VARLSTCNT(4) ERR_DELIMWIDTH, 2, iod->width, newsocket.delimiter[0].len);
if (0 <= zff_len && /* ZFF or ZNOFF specified */
0 < (newsocket.zff.len = zff_len)) /* assign the new ZFF len, might be 0 from ZNOFF, or ZFF="" */
{ /* ZFF="non-zero-len-string" specified */
if (CHSET_UTF16BE == iod->ochset || CHSET_UTF16LE == iod->ochset) /* need conversion of ZFF */
{
DBGSOCK2((stdout, "socuse: Converting zff\n"));
lcl_zff.addr = (char *)zff_buffer;
lcl_zff.len = zff_len;
new_len = gtm_conv(chset_desc[CHSET_UTF8], chset_desc[iod->ochset], &lcl_zff, NULL, NULL);
if (MAX_ZFF_LEN < new_len)
rts_error(VARLSTCNT(4) ERR_ZFF2MANY, 2, new_len, MAX_ZFF_LEN);
if (NULL == newsocket.zff.addr) /* we rely on newsocket.zff.addr being set to 0 in iosocket_create() */
newsocket.zff.addr = (char *)malloc(MAX_ZFF_LEN);
newsocket.zff.len = new_len;
UNICODE_ONLY(newsocket.zff.char_len = 0); /* don't care */
memcpy(newsocket.zff.addr, stringpool.free, new_len);
} else
{ /* Store parm without conversion */
if (gtm_utf8_mode) /* Check if ZFF has any invalid UTF-8 character */
{ /* Note: the ZFF string originates from the source program, so is in UTF-8 mode or M mode
regardless of OCHSET of this device. ZFF is output on WRITE # command, and MUST contain
valid UTF-8 sequence. This validation is handled by gtm_conv in the path above.
*/
utf8_len_strict(zff_buffer, zff_len);
}
if (NULL == newsocket.zff.addr) /* we rely on newsocket.zff.addr being set to 0 in iosocket_create() */
newsocket.zff.addr = (char *)malloc(MAX_ZFF_LEN);
memcpy(newsocket.zff.addr, zff_buffer, zff_len);
}
}
if (ioerror_specified)
newsocket.ioerror = ('T' == ioerror || 't' == ioerror);
if (nodelay_specified || delay_specified)
newsocket.nodelay = nodelay_specified; /* defaults to DELAY */
if (ibfsize_specified)
newsocket.bufsiz = ibfsize;
if (moreread_specified)
{
newsocket.moreread_timeout = moreread_timeout;
newsocket.def_moreread_timeout = TRUE; /* need to know this was user-defined in iosocket_readfl.c */
}
if (!create_new_socket)
{
/* these changes apply to only pre-existing sockets */
if (bfsize_specified)
newsocket.buffer_size = bfsize;
#ifdef TCP_NODELAY
nodelay = newsocket.nodelay ? 1 : 0;
if ((socketptr->nodelay != newsocket.nodelay) &&
(-1 == tcp_routines.aa_setsockopt(newsocket.sd, IPPROTO_TCP,
TCP_NODELAY, &nodelay, SIZEOF(nodelay))))
{
save_errno = errno;
errptr = (char *)STRERROR(save_errno);
rts_error(VARLSTCNT(7) ERR_SETSOCKOPTERR, 5, LEN_AND_LIT("TCP_NODELAY"), save_errno, LEN_AND_STR(errptr));
return;
}
#endif
if ((socketptr->bufsiz != newsocket.bufsiz) &&
(-1 == tcp_routines.aa_setsockopt(newsocket.sd, SOL_SOCKET,
SO_RCVBUF, &newsocket.bufsiz, SIZEOF(newsocket.bufsiz))))
{
save_errno = errno;
errptr = (char *)STRERROR(save_errno);
rts_error(VARLSTCNT(7) ERR_SETSOCKOPTERR, 5, LEN_AND_LIT("SO_RCVBUF"), save_errno, LEN_AND_STR(errptr));
return;
}
if (socketptr->buffer_size != newsocket.buffer_size)
{
if (socketptr->buffered_length > bfsize)
rts_error(VARLSTCNT(4) ERR_SOCKBFNOTEMPTY, 2, bfsize, socketptr->buffered_length);
newsocket.buffer = (char *)malloc(bfsize);
if (0 < socketptr->buffered_length)
{
memcpy(newsocket.buffer, socketptr->buffer + socketptr->buffered_offset,
socketptr->buffered_length);
newsocket.buffered_offset = 0;
}
}
}
/* -------------------------------------- action -------------------------------------------- */
if ((listen_specified && (!iosocket_bind(&newsocket, NO_M_TIMEOUT, ibfsize_specified))) ||
(connect_specified && (!iosocket_connect(&newsocket, 0, ibfsize_specified))))
{ /* error message should be printed from bind/connect */
if (socketptr->sd > 0)
(void)tcp_routines.aa_close(socketptr->sd);
iosocket_delimiter((unsigned char *)NULL, 0, &newsocket, TRUE);
if (NULL != socketptr->zff.addr)
free(socketptr->zff.addr);
if (NULL != socketptr->buffer)
free(socketptr->buffer);
free(socketptr);
return;
}
/* ------------------------------------ commit changes -------------------------------------- */
if (create_new_socket)
{
if (gtm_max_sockets <= newdsocket->n_socket)
{
rts_error(VARLSTCNT(3) ERR_SOCKMAX, 1, gtm_max_sockets);
return;
}
/* a new socket is created. so add to the list */
newsocket.dev = dsocketptr;
newdsocket->socket[newdsocket->n_socket++] = socketptr;
newdsocket->current_socket = newdsocket->n_socket - 1;
}
else if (socketptr->buffer_size != newsocket.buffer_size)
free(socketptr->buffer);
*socketptr = newsocket;
memcpy(dsocketptr, newdsocket, d_socket_struct_len);
return;
}
void op_fnzdate(mval *src, mval *fmt, mval *mo_str, mval *day_str, mval *dst)
{
unsigned char ch, *fmtptr, *fmttop, *i, *outptr, *outtop, *outpt1;
int cent, day, dow, month, nlen, outlen, time, year;
unsigned int n;
mval temp_mval;
static readonly unsigned char montab[] = {31,28,31,30,31,30,31,31,30,31,30,31};
static readonly unsigned char default1[] = DEFAULT1;
static readonly unsigned char default2[] = DEFAULT2;
static readonly unsigned char default3[] = DEFAULT3;
static readonly unsigned char defmonlst[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
static readonly unsigned char defdaylst[] = "SUNMONTUEWEDTHUFRISAT";
#if defined(BIGENDIAN)
static readonly int comma = (((int)',') << 24);
#else
static readonly int comma = ',';
#endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
MV_FORCE_NUM(src);
MV_FORCE_STR(fmt);
MV_FORCE_STR(mo_str);
MV_FORCE_STR(day_str);
ENSURE_STP_FREE_SPACE(ZDATE_MAX_LEN);
time = 0;
outlen = src->str.len;
if ((src->mvtype & MV_STR) && (src->mvtype & MV_NUM_APPROX))
{
for (outptr = (unsigned char *)src->str.addr, outtop = outptr + outlen; outptr < outtop; )
{
if (',' == *outptr++)
{
outlen = outptr - (unsigned char *)src->str.addr - 1;
temp_mval.mvtype = MV_STR;
temp_mval.str.addr = (char *)outptr;
temp_mval.str.len = INTCAST(outtop - outptr);
s2n(&temp_mval);
time = MV_FORCE_INTD(&temp_mval);
if ((0 > time) || (MAX_TIME < time))
rts_error(VARLSTCNT(4) ERR_ZDATEBADTIME, 2, temp_mval.str.len, temp_mval.str.addr);
break;
}
}
}
day = (int)MV_FORCE_INTD(src);
if ((MAX_DATE < day) || (MIN_DATE > day))
{
MV_FORCE_STR(src);
rts_error(VARLSTCNT(4) ERR_ZDATEBADDATE, 2, outlen, src->str.addr);
}
day += DAYS_MOST_YEARS;
dow = ((day + ADJUST_TO_1900) % DAYS_IN_WEEK) + 1;
for (cent = DAYS_BASE_TO_1900, n = ADJUST_TO_1900; cent < day; cent += DAYS_IN_CENTURY, n++)
day += (0 < (n % COMMON_LEAP_CYCLE));
year = day / DAYS_IN_FOUR_YEARS;
day = day - (year * DAYS_IN_FOUR_YEARS);
year = (year * COMMON_LEAP_CYCLE) + BASE_YEAR;
if (DAYS_BEFORE_LEAP == day)
{
day = MIN_DAYS_IN_MONTH + 1;
month = 2;
} else
{
if (DAYS_BEFORE_LEAP < day)
day--;
month = day / DAYS_MOST_YEARS;
year += month;
day -= (month * DAYS_MOST_YEARS);
for (i = montab; day >= *i; day -= *i++)
;
month = (int)((i - montab)) + 1;
day++;
assert((0 < month) && (MONTHS_IN_YEAR >= month));
}
if ((0 == fmt->str.len) || ((1 == fmt->str.len) && ('1' == *fmt->str.addr)))
{
if (!TREF(zdate_form) || ((1 == TREF(zdate_form)) && (PIVOT_MILLENIUM > year)))
{
fmtptr = default1;
fmttop = fmtptr + STR_LIT_LEN(DEFAULT1);
} else
{
fmtptr = default3;
fmttop = fmtptr + STR_LIT_LEN(DEFAULT3);
}
} else if ((1 == fmt->str.len) && ('2' == *fmt->str.addr))
{
fmtptr = default2;
fmttop = fmtptr + STR_LIT_LEN(DEFAULT2);
} else
{
fmtptr = (unsigned char *)fmt->str.addr;
fmttop = fmtptr + fmt->str.len;
}
outlen = (int)(fmttop - fmtptr);
if (outlen >= ZDATE_MAX_LEN)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
outptr = stringpool.free;
outtop = outptr + ZDATE_MAX_LEN;
temp_mval.mvtype = MV_STR;
assert(0 <= time);
nlen = 0;
while (fmtptr < fmttop)
{
switch (ch = *fmtptr++) /* NOTE assignment */
{
case '/':
case ':':
case '.':
case ',':
case '-':
case ' ':
case '*':
case '+':
case ';':
*outptr++ = ch;
continue;
case 'M':
ch = *fmtptr++;
if ('M' == ch)
{
n = month;
nlen = 2;
break;
}
if (('O' != ch) || ('N' != *fmtptr++))
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
if (0 == mo_str->str.len)
{
temp_mval.str.addr = (char *)&defmonlst[(month - 1) * LEN_OF_3_CHAR_ABBREV];
temp_mval.str.len = LEN_OF_3_CHAR_ABBREV;
nlen = -LEN_OF_3_CHAR_ABBREV;
} else
{
UNICODE_ONLY(gtm_utf8_mode ? op_fnp1(mo_str, comma, month, &temp_mval) :
op_fnzp1(mo_str, comma, month, &temp_mval));
VMS_ONLY(op_fnzp1(mo_str, comma, month, &temp_mval, TRUE));
nlen = -temp_mval.str.len;
outlen += - LEN_OF_3_CHAR_ABBREV - nlen;
if (outlen >= ZDATE_MAX_LEN)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
}
break;
case 'D':
ch = *fmtptr++;
if ('D' == ch)
{
n = day;
nlen = 2;
break;
}
if (('A' != ch) || ('Y' != *fmtptr++))
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
if (0 == day_str->str.len)
{
temp_mval.str.addr = (char *)&defdaylst[(dow - 1) * LEN_OF_3_CHAR_ABBREV];
temp_mval.str.len = LEN_OF_3_CHAR_ABBREV;
nlen = -LEN_OF_3_CHAR_ABBREV;
} else
{
UNICODE_ONLY(gtm_utf8_mode ? op_fnp1(day_str, comma, dow, &temp_mval)
: op_fnzp1(day_str, comma, dow, &temp_mval));
VMS_ONLY(op_fnzp1(day_str, comma, dow, &temp_mval, TRUE));
nlen = -temp_mval.str.len;
outlen += - LEN_OF_3_CHAR_ABBREV - nlen;
if (outlen >= ZDATE_MAX_LEN)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
}
break;
case 'Y':
ch = *fmtptr++;
n = year;
if ('Y' == ch)
{
for (nlen = 2; (MAX_YEAR_DIGITS >=nlen) && fmtptr < fmttop; ++nlen, fmtptr++)
if ('Y' != *fmtptr)
break;
} else
{
if (('E' != ch) || ('A' != *fmtptr++) || ('R' != *fmtptr++))
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 4;
}
break;
case '1':
if ('2' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 2;
n = time / SECONDS_PER_HOUR;
n = ((n + HOURS_PER_AM_OR_PM - 1) % HOURS_PER_AM_OR_PM) + 1;
break;
case '2':
if ('4' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 2;
n = time / SECONDS_PER_HOUR;
break;
case '6':
if ('0' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 2;
n = time;
n /= MINUTES_PER_HOUR;
n %= MINUTES_PER_HOUR;
break;
case 'S':
if ('S' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 2;
n = time % SECONDS_PER_MINUTE;
break;
case 'A':
if ('M' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
*outptr++ = (time < (HOURS_PER_AM_OR_PM * SECONDS_PER_HOUR)) ? 'A' : 'P';
*outptr++ = 'M';
continue;
default:
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
}
if (nlen > 0)
{
outptr += nlen;
outpt1 = outptr;
while (nlen-- > 0)
{
*--outpt1 = '0' + (n % 10);
n /= 10;
}
} else
{
outpt1 = (unsigned char *)temp_mval.str.addr;
while (nlen++ < 0)
*outptr++ = *outpt1++;
}
}
if (fmtptr > fmttop)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
dst->mvtype = MV_STR;
dst->str.addr = (char *)stringpool.free;
dst->str.len = INTCAST((char *)outptr - dst->str.addr);
stringpool.free = outptr;
return;
}
int main(int argc, char *argv[])
{
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
common_startup_init(DSE_IMAGE);
licensed = TRUE;
TREF(transform) = TRUE;
TREF(no_spangbls) = TRUE; /* dse operates on a per-region basis irrespective of global mapping in gld */
TREF(skip_file_corrupt_check) = TRUE; /* do not let csd->file_corrupt flag cause errors in dse */
op_open_ptr = op_open;
patch_curr_blk = get_dir_root();
err_init(util_base_ch);
UNICODE_ONLY(gtm_strToTitle_ptr = >m_strToTitle);
GTM_ICU_INIT_IF_NEEDED; /* Note: should be invoked after err_init (since it may error out) and before CLI parsing */
sig_init(generic_signal_handler, dse_ctrlc_handler, suspsigs_handler, continue_handler);
atexit(util_exit_handler);
SET_LATCH_GLOBAL(&defer_latch, LOCK_AVAILABLE);
stp_init(STP_INITSIZE);
rts_stringpool = stringpool;
getjobname();
INVOKE_INIT_SECSHR_ADDRS;
io_init(TRUE);
getzdir();
gtm_chk_dist(argv[0]);
prealloc_gt_timers();
gt_timers_add_safe_hndlrs();
initialize_pattern_table();
gvinit();
region_init(FALSE);
util_out_print("!/File !_!AD", TRUE, DB_LEN_STR(gv_cur_region));
util_out_print("Region!_!AD!/", TRUE, REG_LEN_STR(gv_cur_region));
cli_lex_setup(argc, argv);
/* Since DSE operates on a region-by-region basis (for the most part), do not use a global directory at all from now on */
original_header = gd_header;
gd_header = NULL;
OPERATOR_LOG_MSG;
# ifdef DEBUG
if ((gtm_white_box_test_case_enabled && (WBTEST_SEMTOOLONG_STACK_TRACE == gtm_white_box_test_case_number) ))
{
sgmnt_addrs * csa;
node_local_ptr_t cnl;
csa = &FILE_INFO(gv_cur_region)->s_addrs;
cnl = csa->nl;
cnl->wbox_test_seq_num = 1; /*Signal the first step and wait here*/
/* The signal to the shell. MUPIP must not start BEFORE DSE */
util_out_print("DSE is ready. MUPIP can start. Note: This message is a part of WBTEST_SEMTOOLONG_STACK_TRACE test. "
"It will not appear in PRO version.", TRUE);
while (2 != cnl->wbox_test_seq_num) /*Wait for another process to get hold of the semaphore and signal next step*/
LONG_SLEEP(1);
}
# endif
if (argc < 2)
display_prompt();
while (1)
{
if (!dse_process(argc))
break;
display_prompt();
}
dse_exit();
REVERT;
return 0;
}
int gtm_main (int argc, char **argv, char **envp)
#ifdef __osf__
# pragma pointer_size (restore)
#endif
{
char *ptr, *eq, **p;
int eof, parse_ret;
int gtmcrypt_errno;
# ifdef GTM_SOCKET_SSL_SUPPORT
int status;
char tlsid_env_name[MAX_TLSID_LEN * 2];
# endif
DCL_THREADGBL_ACCESS;
GTM_THREADGBL_INIT;
gtmenvp = envp;
gtm_dist_ok_to_use = TRUE;
common_startup_init(GTM_IMAGE);
GTMTRIG_DBG_ONLY(ch_at_trigger_init = &mdb_condition_handler);
err_init(stop_image_conditional_core);
UNICODE_ONLY(gtm_strToTitle_ptr = >m_strToTitle);
GTM_ICU_INIT_IF_NEEDED; /* Note: should be invoked after err_init (since it may error out) and before CLI parsing */
cli_lex_setup(argc, argv);
/* put the arguments into buffer, then clean up the token buffer
* cli_gettoken() copies all arguments except the first one argv[0]
* into the buffer (cli_lex_in_ptr->in_str).
* i.e. command line: "/usr/library/V990/mumps -run somefile"
* the buffer cli_lex_in_ptr->in_str == "-run somefile"
*/
if (1 < argc)
cli_gettoken(&eof);
/* cli_gettoken() extracts the first token into cli_token_buf (in tok_extract())
* which should be done in parse_cmd(), So, reset the token buffer here to make
* parse_cmd() starts from the first token
*/
cli_token_buf[0] = '\0';
/* insert the "MUMPS " in the parsing buffer the buffer is now:
* cli_lex_in_ptr->in_str == "MUMPS -run somefile"
* we didnot change argv[0]
*/
ptr = cli_lex_in_ptr->in_str;
memmove(strlen("MUMPS ") + ptr, ptr, strlen(ptr) + 1); /* BYPASSOK */
MEMCPY_LIT(ptr, "MUMPS ");
/* reset the argument buffer pointer, it's changed in cli_gettoken() call above
* do NOT reset to 0(NULL) to avoid fetching cmd line args into buffer again
* cli_lex_in_ptr->tp is the pointer to indicate current position in the buffer
* cli_lex_in_ptr->in_str
*/
cli_lex_in_ptr->tp = cli_lex_in_ptr->in_str;
parse_ret = parse_cmd();
if (parse_ret && (EOF != parse_ret))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(4) parse_ret, 2, LEN_AND_STR(cli_err_str));
if (cli_present("DIRECT_MODE"))
invocation_mode = MUMPS_DIRECT;
else if (cli_present("RUN"))
invocation_mode = MUMPS_RUN;
gtm_chk_dist(argv[0]);
/* this should be after cli_lex_setup() due to S390 A/E conversion in cli_lex_setup */
init_gtm();
# ifdef GTM_TLS
if (MUMPS_COMPILE != invocation_mode)
{
if ((NULL != (ptr = (char *)getenv(GTM_PASSWD_ENV))) && (0 == strlen(ptr)))
{
INIT_PROC_ENCRYPTION(NULL, gtmcrypt_errno);
if (0 != gtmcrypt_errno)
{
CLEAR_CRYPTERR_MASK(gtmcrypt_errno);
assert(!IS_REPEAT_MSG_MASK(gtmcrypt_errno));
assert((ERR_CRYPTDLNOOPEN == gtmcrypt_errno) || (ERR_CRYPTINIT == gtmcrypt_errno));
if (ERR_CRYPTDLNOOPEN == gtmcrypt_errno)
gtmcrypt_errno = ERR_CRYPTDLNOOPEN2;
else if (ERR_CRYPTINIT == gtmcrypt_errno)
gtmcrypt_errno = ERR_CRYPTINIT2;
gtmcrypt_errno = SET_CRYPTERR_MASK(gtmcrypt_errno);
GTMCRYPT_REPORT_ERROR(gtmcrypt_errno, rts_error, SIZEOF(GTMCRYPT_ERRLIT) - 1, GTMCRYPT_ERRLIT); /* BYPASSOK */
}
}
# ifdef GTM_SOCKET_SSL_SUPPORT
/* The below logic is for prefetching the password for TLS identifiers that may have been set in the environment.
* But, since SSL support for Socket devices is not yet implemented, this logic need not be enabled as of this
* writing. When SSL support for socket devices is implemented, the surrounding #ifdef can be removed.
*/
if (NULL != getenv("gtmcrypt_config"))
{ /* Environment is configured for SSL/TLS (and/or encryption). Check if any environment variable of the form
* `gtmtls_passwd_*' is set to NULL string. If so, nudge the SSL/TLS library to read password(s) from the
* user.
*/
for (p = envp; *p; p++)
{
ptr = *p;
if (0 == MEMCMP_LIT(ptr, GTMTLS_PASSWD_ENV_PREFIX))
{ /* At least one environment variable of $gtmtls_passwd_* is found. */
eq = strchr(ptr, '=');
if (0 != strlen(eq + 1))
break; /* Set to non-empty string. No need to initialize the library now. */
/* Set to empty string. */
if (NULL == tls_ctx)
{
if (SS_NORMAL != (status = gtm_tls_loadlibrary()))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TLSDLLNOOPEN, 0,
ERR_TEXT, 2, LEN_AND_STR(dl_err));
}
if (NULL == (tls_ctx = gtm_tls_init(GTM_TLS_API_VERSION,
GTMTLS_OP_INTERACTIVE_MODE)))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TLSINIT, 0,
ERR_TEXT, 2, LEN_AND_STR(gtm_tls_get_error()));
}
}
assert(NULL != tls_ctx);
assert((MAX_TLSID_LEN * 2) > (int)(eq - ptr));
memcpy(tlsid_env_name, ptr, (int)(eq - ptr));
tlsid_env_name[(int)(eq - ptr)] = '\0';
gtm_tls_prefetch_passwd(tls_ctx, tlsid_env_name);
}
}
}
# endif
}
# endif
dm_start();
return 0;
}
