/*{
** Name: CS_map_sys_segment() - Map the system control segment to this process
**
** Description:
** Maps the system control block to this process. This must happen before
** any other action can be taken on shared memory (with the exception of
** CS_create_sys_segment()).
**
** Upon successful exectution of this routine CS may manipulate the system
** control data structure CS_SMCNTRL (taking care to use proper semaphore
** techniques which take into account that the data structure is shared
** across processes).
**
** This call is internal to CS is meant only to be called by CS, and may
** only exist on unix systems supporting shared memory.
**
** Inputs:
** none.
**
** Outputs:
** cssm_segment ptr to the CS_SMCNTRL data structure.
** err_code system dependent error information.
**
** Returns:
** E_DB_OK
**
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 08-Sep-88 (mmm)
** First Version
** 12-jun-89 (rogerk)
** Added allocated_pages argument to MEget_pages calls.
** Changed shared memory key from a LOCATIONN pointer to a character
** string.
** 26-aug-89 (rexl)
** Added calls to protect page allocator.
** 18-oct-1993 (bryanp)
** Issue trace messages in failure cases. Simply returning FAIL doesnt
** help the diagnosis process very much, while the trace messages
** can help (if the caller has done a TRset_file by this point).
** 14-Oct-1998 (jenjo02)
** CS_map_sys_segment(): Don't initialize css_spinlock. That was done
** when the shared segment was created. Reinitializing it may
** effectively destroy a holding process's lock!
** 21-May-2004 (wanfr01)
** INGSRV2835, Bug 112371
** As per the Jon Jensen's last update, removed the invalid initialize
** of css_spinlock.
** 5-Apr-2006 (kschendel)
** Use generated css version instead of constant.
** 12-aug-2008 (stephenb)
** previous change is too strict if programs not shipped with Ingres
** try to connect to the system segment because the checked version
** goes right down to the build number. allow some latitude using
** II_SYSSEG_VERS. If this is set to the current major Ingres
** version we will allow the connection. This is an interim
** solution to Golden Gate's issue.
*/
STATUS
CS_map_sys_segment(CL_ERR_DESC *err_code)
{
STATUS status = OK;
PTR address;
SIZE_TYPE alloc_pages;
/* map segment into first available address and then initialize it */
/* Use "sysseg.mem" as shared memory key. */
address = 0;
status = MEget_pages(ME_SSHARED_MASK, 0, "sysseg.mem", &address,
&alloc_pages, err_code);
if (status)
{
#ifdef xDEBUG
TRdisplay("CS_map_sys_segment: unable to attach to sysseg.mem (%x)\n",
status);
#endif
/* Unable to attach allocated shared memory segment. */
/* status = FAIL; This isn't a useful error return code! */
}
else
{
char *segvers;
i4 segint;
Cs_sm_cb = (CS_SMCNTRL *) address;
/*
** check if segment version has been provided, if so we'll
** deem it O.K. if it matches the current major version
*/
NMgtAt("II_SYSSEG_VERS", &segvers);
if (segvers != (char *)NULL && *segvers != EOS &&
CVal(segvers, &segint) == OK && segint == GV_MAJOR)
status = OK;
else
{
i4 id = make_css_version();
if (Cs_sm_cb->css_version != id)
{
TRdisplay(
"CS_map_sys_segment: sysseg.mem is version %x (%d). We need version %x (%d)\n",
Cs_sm_cb->css_version, Cs_sm_cb->css_version,
id, id);
SETCLERR(err_code, 0, 0);
status = FAIL;
}
}
}
return(status);
}
bool check_uuid_mac()
{
char *uuid_mac=NULL;
NMgtAt("II_UUID_MAC", &uuid_mac);
if ((uuid_mac != (char *)NULL && *uuid_mac != EOS) &&
(STcompare(uuid_mac,"TRUE") == 0))
{
return TRUE;
}
else
{
return FALSE;
}
}
/*{
** Name: get_value() - get value
**
** Description:
** Return value of symbol input. If symbol is not set in the environment
** then return "default_value".
**
** Inputs:
** symbol The string representation of the symbol (ie. "II_SYM")
** default_value An integer default value to be returned if symbol not
** found in the environment.
** Outputs:
** none.
**
**
** Returns:
** value of the symbol if set in environment, else returns
** whatever "default_value" was input.
**
** History:
** 06-apr-92 (mikem)
** Created.
*/
static i4
get_value(char *symbol, i4 default_value)
{
i4 value = default_value;
char *string;
i4 env_value;
NMgtAt(symbol, &string);
if (string &&
*string &&
(!CVal(string, &env_value)))
{
/* user override of default */
value = env_value;
}
return(value);
}
/*
** tcp6_set_trace - sets trace level for TCP.
*/
static VOID
tcp6_set_trace()
{
static bool init_trace=FALSE;
char *trace;
if(init_trace)
return;
init_trace=TRUE;
NMgtAt( "II_TCP_TRACE", &trace );
if ( !( trace && *trace ) && PMget("!.tcp_trace_level", &trace) != OK )
tcp_trace = 0;
else
tcp_trace = atoi(trace);
}
/*{
** Name: aboslver - Initialize the OSL version.
**
** Description:
** Initialize the OSL version. On most OS this is a noop. On VMS
** check to capability settings. If either OSL/QUEL or OSL/SQL are
** enabled, then it is new OSL.
**
** History:
** 19-jun-1987 (Joe)
** Initial Version
*/
aboslver()
{
# ifdef VMS
char *cp;
osNewVersion = 1;
/*
** Some VMS customers may have old version of OSL.
** Want a way to test, so allow a logical name to set.
*/
NMgtAt(ERx("II_OSL_VERSION"), &cp);
if (cp != NULL)
{
CVlower(cp);
osNewVersion = !(*cp == 'o');
}
# else
osNewVersion = 1;
# endif /* VMS */
}
bool
cer_istest(void)
{
char *nambuf;
if (test_state == NOTSET)
{ /* Check the II_MSG_TEST */
NMgtAt("II_MSG_TEST", &nambuf);
if (nambuf && *nambuf &&
( STcasecmp(nambuf, "y" ) == 0
|| STcasecmp(nambuf, "yes" ) == 0
|| STcasecmp(nambuf, "t" ) == 0
|| STcasecmp(nambuf, "true" ) == 0 ) )
{ /* Value is Set */
test_state = SETON;
}
else
{
test_state = SETOFF;
}
}
return ((test_state == SETON) ? TRUE : FALSE);
}
ADF_CB *
FEadfcb ()
{
if (!done)
{
char *cp;
DB_STATUS rval;
PTR srv_cb_ptr;
SIZE_TYPE srv_size;
SIZE_TYPE dbinfo_size;
PTR dbinfoptr;
STATUS tmtz_status;
STATUS date_status;
char date_type_alias[100];
char col[] = "udefault";
STATUS status = OK;
CL_ERR_DESC sys_err;
ADUUCETAB *ucode_ctbl; /* unicode collation information */
PTR ucode_cvtbl;
done = TRUE;
/* first, get the size of the ADF's server control block */
srv_size = adg_srv_size();
/* allocate enough memory for it */
if ((srv_cb_ptr = MEreqmem(0, srv_size, FALSE, (STATUS *)NULL)) == NULL)
{
EXsignal(EXFEBUG, 1, ERx("FEadfcb(alloc)"));
}
/*
** Fix up code so that "now" works properly for frontends.
** Only allocating enough for one (1) dbmsinfo() request.
*/
dbinfo_size = sizeof(ADF_TAB_DBMSINFO);
if ((dbinfoptr = MEreqmem(0, dbinfo_size, TRUE, (STATUS*)NULL)) == NULL)
{
IIUGbmaBadMemoryAllocation(ERx("FEadfcb"));
}
dbinfo = (ADF_TAB_DBMSINFO *) dbinfoptr;
dbinfo->tdbi_next = NULL;
dbinfo->tdbi_prev = NULL;
dbinfo->tdbi_length = dbinfo_size;
dbinfo->tdbi_type = ADTDBI_TYPE;
dbinfo->tdbi_s_reserved = -1;
dbinfo->tdbi_l_reserved = (PTR)-1;
dbinfo->tdbi_owner = (PTR)-1;
dbinfo->tdbi_ascii_id = ADTDBI_ASCII_ID;
dbinfo->tdbi_numreqs = 1;
/*
** Now define request.
*/
dbinfo->tdbi_reqs[0].dbi_func = IIUGnfNowFunc;
dbinfo->tdbi_reqs[0].dbi_num_inputs = 0;
dbinfo->tdbi_reqs[0].dbi_lenspec.adi_lncompute = ADI_FIXED;
STcopy("_BINTIM", dbinfo->tdbi_reqs[0].dbi_reqname);
dbinfo->tdbi_reqs[0].dbi_reqcode = 1;
dbinfo->tdbi_reqs[0].dbi_lenspec.adi_fixedsize = 4;
dbinfo->tdbi_reqs[0].dbi_dtr = DB_INT_TYPE;
/*
** set timezone in ADF cb - Any errors must be reported
** after adg_init() called.
*/
if ( (tmtz_status = TMtz_init(&cb.adf_tzcb)) == OK)
{
tmtz_status = TMtz_year_cutoff(&cb.adf_year_cutoff);
}
/* Always use INGRESDATE by default, and check
** 'ii.<node>.config.date_alias' (kibro01) b118702
*/
cb.adf_date_type_alias = AD_DATE_TYPE_ALIAS_INGRES;
STprintf(date_type_alias,ERx("ii.%s.config.date_alias"),PMhost());
date_status = PMget(date_type_alias, &cp);
if (date_status == OK && cp != NULL && STlength(cp))
{
if (STbcompare(cp, 0, ERx("ansidate"), 0, 1) == 0)
cb.adf_date_type_alias = AD_DATE_TYPE_ALIAS_ANSI;
else if (STbcompare(cp, 0, ERx("ingresdate"), 0, 1) == 0)
cb.adf_date_type_alias = AD_DATE_TYPE_ALIAS_INGRES;
else
cb.adf_date_type_alias = AD_DATE_TYPE_ALIAS_NONE;
}
/* set timezone table to NULL in ADF cb, adg_init() will fill it */
/* cb.adf_tz_table = NULL; - not needed, done in declaration above */
/* Start up ADF */
rval = adg_startup(srv_cb_ptr, srv_size, dbinfo, 0);
if (DB_FAILURE_MACRO(rval))
{
/*
** Before bailing out, try to be helpful. Since the environment
** is likely not set up correctly, write hard coded messages
** since error message fetch will likely fail in this situation.
*/
char *tempchar;
i4 dummy;
LOCATION temploc;
NMgtAt("II_SYSTEM", &tempchar);
if (tempchar && *tempchar)
{
LOfroms(PATH, tempchar, &temploc);
if (LOexist(&temploc))
{
tempchar = ERx("FEadfcb: II_SYSTEM DOES NOT EXIST\n");
SIwrite(STlength(tempchar), tempchar, &dummy, stderr);
}
else
{
NMloc(ADMIN, FILENAME, ERx("config.dat"), &temploc);
if (LOexist(&temploc))
{
tempchar = ERx("FEadfcb: II_SYSTEM IS NOT SET CORRECTLY\n");
SIwrite(STlength(tempchar), tempchar, &dummy, stderr);
}
}
}
else
{
tempchar = ERx("FEadfcb: II_SYSTEM IS NOT SET\n");
SIwrite(STlength(tempchar), tempchar, &dummy, stderr);
}
EXsignal(EXFEBUG, 1, ERx("FEadfcb(start)"));
}
/* put the pointer to ADF's server control block in the ADF_CB */
cb.adf_srv_cb = srv_cb_ptr;
/* set up the error message buffer */
cb.adf_errcb.ad_ebuflen = DB_ERR_SIZE;
cb.adf_errcb.ad_errmsgp = ebuffer;
/* initialize the ADF_CB */
rval = adg_init(&cb);
if (DB_FAILURE_MACRO(rval))
{
EXsignal(EXFEBUG, 1, ERx("FEadfcb(init)"));
}
/* find out which natural language we should speak */
cb.adf_slang = iiuglcd_langcode();
/* Always QUEL; for SQL explictly change this with 'IIAFdsDmlSet()'. */
cb.adf_qlang = DB_QUEL;
/* lets get the multinational info */
/*
** Defaults for all of these are initially set statically, above.
*/
NMgtAt(ERx("II_DATE_FORMAT"), &cp);
if ( cp != NULL && *cp != EOS )
{
FEapply_date_format(&cb,cp);
}
NMgtAt(ERx("II_MONEY_FORMAT"), &cp);
if ( cp != NULL && *cp != EOS )
{
FEapply_money_format(&cb,cp);
}
NMgtAt(ERx("II_MONEY_PREC"), &cp);
if ( cp != NULL && *cp != EOS )
{
FEapply_money_prec(&cb,cp);
}
NMgtAt(ERx("II_DECIMAL"), &cp);
if ( cp != NULL && *cp != EOS )
{
FEapply_decimal(&cb,cp);
}
NMgtAt(ERx("II_UNICODE_SUBS"), &cp);
if ( !cp )
{
cb.adf_unisub_status = AD_UNISUB_OFF;
}
else
{
/* As with SET unicode_substitution take the first char */
cb.adf_unisub_status = AD_UNISUB_ON;
*cb.adf_unisub_char = cp[0];
}
NMgtAt(ERx("II_NULL_STRING"), &cp);
if ( cp != NULL && *cp != EOS )
{
FEapply_null(&cb,cp);
}
/* If there was a Timezone error other than the expected ingbuild
** error TM_PMFILE_OPNERR, then lets report it now. */
if (tmtz_status && (tmtz_status != TM_PMFILE_OPNERR))
{
LOCATION loc_root;
STATUS status = OK;
status = NMloc(FILES, PATH, ERx("zoneinfo"), &loc_root);
#if defined(conf_BUILD_ARCH_32_64) && defined(BUILD_ARCH64)
status = LOfaddpath(&loc_root, ERx("lp64"), &loc_root);
#endif
#if defined(conf_BUILD_ARCH_64_32) && defined(BUILD_ARCH32)
{
/*
** Reverse hybrid support must be available in ALL
** 32bit binaries
*/
char *rhbsup;
NMgtAt("II_LP32_ENABLED", &rhbsup);
if ( (rhbsup && *rhbsup) &&
( !(STbcompare(rhbsup, 0, "ON", 0, TRUE)) ||
!(STbcompare(rhbsup, 0, "TRUE", 0, TRUE))))
status = LOfaddpath(&loc_root, "lp32", &loc_root);
}
#endif /* ! LP64 */
if ( status == OK )
{
status = LOexist(&loc_root);
}
if ( status == OK )
{
IIUGerr(tmtz_status, 0, 0);
/* As this may disappear from the screen quickly,
** let's pause to allow the users to reflect on the
** fact that the timezone info is (probably) wrong.
*/
if (!IIugefa_err_function) PCsleep(5000);
}
}
/* Initialize unicode collation for UTF8 installations */
if (CMischarset_utf8())
{
if (status = aduucolinit(col, MEreqmem,
&ucode_ctbl, &ucode_cvtbl, &sys_err))
{
EXsignal(EXFEBUG, 1, ERx("FEadfcb(alloc)"));
}
cb.adf_ucollation = (PTR) ucode_ctbl;
/* Set unicode normalization to NFC just in case
** Front end will need it.
*/
if ((status = adg_setnfc(&cb)) != E_DB_OK)
EXsignal(EXFEBUG, 1, ERx("FEadfcb(alloc)"));
}
/* lets not do this again! */
}
return &cb;
}
edit()
{
register char *p;
LOCATION t_loc,
loc;
FILE *fp;
char errbuf[ER_MAX_LEN + 1];
char input[MAX_LOC + 1];
char *editfile;
char *ingedit;
i4 rflag;
STATUS status;
i4 c;
#ifdef CMS
i4 Notempty = 1;
#endif /* CMS */
GLOBALREF char *IIMOildInitLnDraw;
FUNC_EXTERN char *getfilenm();
FUNC_EXTERN char *macro();
if (!Newline)
{
q_putc(Qryiop, '\n');
Newline = TRUE;
}
Autoclear = 0;
editfile = getfilenm();
rflag = 0;
if (*editfile == '\0')
{
rflag = 1;
input[0] = EOS;
if ((status = NMloc( TEMP, PATH, (char *)NULL, &t_loc)) ||
(status = LOuniq( ERx( "query" ), ERx( "edt" ), &t_loc)))
{
STcopy( ERx( "queryXXX" ), input );
}
else
{
LOcopy( &t_loc, input, &loc );
}
status = SIfopen( &loc, ERx( "w" ), (i4)SI_TXT,
(i4)SI_MAX_TXT_REC, &fp );
}
else
{
/* use the path and file name the user gave you */
STcopy(editfile, input);
if (!(status = LOfroms(PATH & FILENAME, input, &loc)))
status = SIfopen( &loc, ERx("w"), (i4)SI_TXT,
(i4)SI_MAX_TXT_REC, &fp );
}
if (status)
{
if (status == FAIL)
errbuf[0] = '\0';
else
ERreport(status, errbuf);
putprintf(ERget(F_MO000C_Cant_create_qry_file),
input, errbuf);
cgprompt();
return(0);
}
if (q_ropen(Qryiop, 'r') == (struct qbuf *)NULL)
/* edit: q_ropen 1 */
ipanic(E_MO0044_1500400);
while ((c = (i4)q_getc(Qryiop)) > 0)
SIputc((char)c, fp);
SIclose(fp);
if (Nodayfile >= 0)
{
putprintf(ERget(F_MO000D_editor_prompt));
SIflush(stdout);
}
/*
** macro returns NULL if undefined, UTedit uses
** default editor if passed NULL.
*/
/* Bug 4875 - Use editor defined by environment variable
ING_EDIT. If that is not set then use the macro(editor).
*/
NMgtAt((ERx("ING_EDIT")), &ingedit);
if ( ingedit != NULL && *ingedit != EOS )
p = ingedit;
else
p = macro(ERx("{editor}"));
if (status = UTedit(p, &loc))
{
ERreport(status, errbuf);
putprintf(ERget(F_MO000E_Can_t_start_up_editor), errbuf);
cgprompt();
return(0);
}
if (!rflag)
{
if (q_ropen(Qryiop, 'a') == (struct qbuf *)NULL)
/* edit: q_ropen 2 */
ipanic(E_MO0045_1500401);
}
else
{
if (q_ropen(Qryiop, 'w') == (struct qbuf *)NULL)
/* edit: q_ropen 3 */
ipanic(E_MO0046_1500402);
if (status = SIfopen( &loc, ERx("r"), (i4)SI_TXT,
(i4)SI_MAX_TXT_REC, &fp ))
#ifdef CMS
{
Notempty = 0;
}
#else
{
ERreport(status, errbuf);
/* can't reopen editfile %s: %s\n */
ipanic(E_MO0047_1500403,
editfile, errbuf);
}
#endif /* CMS */
#ifdef CMS
if (Notempty)
{
#endif /* CMS */
Notnull = 0;
while ((c = SIgetc(fp)) != EOF)
{
if (status)
{
ERreport(status, errbuf);
/* Error reading edit file: %s\n */
ipanic(E_MO0048_1500404, errbuf);
}
Notnull = 1;
q_putc(Qryiop, (char)c);
}
SIclose(fp);
if (status = LOpurge(&loc, 0))
{
ERreport(status, errbuf);
putprintf(ERget(F_MO000F_Cant_delete_file), editfile, errbuf);
}
#ifdef CMS
} /* endif Notempty */
#endif /* CMS */
}
#ifndef FT3270
/* Re-Initialize IT line drawing */
{
if (Outisterm && IIMOildInitLnDraw != NULL)
SIprintf(ERx("%s"), IIMOildInitLnDraw);
}
#endif
cgprompt();
return(0);
}
/*
** Name: cpres_mbx_assign - get channel to target process, assign if need
**
** Description:
** This subroutine looks up the channel to the target process. If we have
** not yet assigned a channel to the target process, then we assign one
** and remember it. The resulting channel is returned.
**
** Inputs:
** pid - the target process's pid
**
** Outputs:
** CPchan - Pointer to CP_CHANNEL of process.
**
** Returns:
** OK, !OK
**
** History:
** Summer, 1992 (bryanp)
** Working on the new portable logging and locking system.
** 14-dec-1992 (bryanp)
** ERsend() calls should be ERlog() calls.
** 23-may-1994 (bryanp) B60736
** Added clean_channels() routine and called it periodically to
** ensure that a process doesn't accumulate channels to dead
** processes indefinitely.
** 02-May-2007 (jonj)
** Use of CSp/v_semaphore is prohibited from within an AST as
** it corrupts cs_inkernel and the ready queues. Use CS_ASET/ACLR
** instead.
** 08-Nov-2007 (jonj)
** Changed function to return pointer to CP_CHANNEL instead
** of channel number, initialize IsDead to FALSE.
** 04-Apr-2008 (jonj)
** Remove disabling of ASTs here, caller will have already done
** that.
** Check if PID has been deadified by write AST; if so,
** cancel any pending I/O, deassign channel, mark CPchan
** as unusuable (dead).
*/
static STATUS
cpres_mbx_assign(PID pid, CP_CHANNEL **CPchan)
{
i4 i;
struct dsc$descriptor_s name_desc;
i4 vms_status;
char mbx_name[100];
char *inst_id;
char msg_buf[250];
STATUS status;
STATUS cl_status;
PID my_pid;
CL_ERR_DESC local_sys_err;
CP_CHANNEL *NewCPchan;
/* Loop until we get the sem */
while ( !CS_TAS(&cpres_channels_sem) );
for (i = 0; i < cpres_num_channels_assigned; i++)
{
if (cpres_channels[i].pid == pid)
{
/*
** If write completion AST noticed that
** the reading process has died or gone away,
** mark its PID as dead, cancel any leftover
** I/O and deassign the channel.
*/
if ( cpres_channels[i].state == CPchanIsDying )
{
sys$cancel(cpres_channels[i].chan);
sys$dassgn(cpres_channels[i].chan);
cpres_channels[i].state = CPchanIsDead;
STprintf(msg_buf, "%x PID %x on channel %d is dead, deassigned",
Cs_srv_block.cs_pid,
cpres_channels[i].pid,
cpres_channels[i].chan);
ERlog(msg_buf, STlength(msg_buf), &local_sys_err);
}
/* Return channel, dead or alive */
*CPchan = &cpres_channels[i];
CS_ACLR(&cpres_channels_sem);
return (OK);
}
}
if ( status = clean_channels() )
{
CS_ACLR(&cpres_channels_sem);
return (status);
}
if ( cpres_num_channels_assigned <
(sizeof(cpres_channels)/sizeof(CP_CHANNEL)) )
{
/*
** New process, and room remains in the channel array, so assign a
** channel.
*/
NewCPchan = &cpres_channels[cpres_num_channels_assigned];
NMgtAt("II_INSTALLATION", &inst_id);
if (inst_id && *inst_id)
STprintf(mbx_name, "II_CPRES_%s_%x", inst_id, (i4)pid);
else
STprintf(mbx_name, "II_CPRES_%x", (i4)pid);
name_desc.dsc$a_pointer = mbx_name;
name_desc.dsc$w_length = STlength(mbx_name);
name_desc.dsc$b_dtype = DSC$K_DTYPE_T;
name_desc.dsc$b_class = DSC$K_CLASS_S;
vms_status = sys$assign(&name_desc, /* devname */
&NewCPchan->chan, /* channel */
0, /* access_mode */
0, /* mbxnam */
AGN$M_WRITEONLY); /* flags */
if ( vms_status == SS$_NORMAL )
{
NewCPchan->pid = pid;
NewCPchan->state = CPchanIsAlive;
*CPchan = NewCPchan;
cpres_num_channels_assigned++;
CS_ACLR(&cpres_channels_sem);
return (OK);
}
else
{
STprintf(msg_buf,
"%x cpres_mbx_assign: Error (%x) assigning channel to %s",
Cs_srv_block.cs_pid, vms_status, mbx_name);
ERlog(msg_buf, STlength(msg_buf), &local_sys_err);
}
}
else
{
/*
** No room left in channels array. One possibility is to go through
** the array looking for assigned channels to mailboxes of dead
** processes and clean those up.
*/
STcopy("PANIC! No room left in channels array!", msg_buf);
ERlog(msg_buf, STlength(msg_buf), &local_sys_err);
}
CS_ACLR(&cpres_channels_sem);
return (FAIL);
}
main(int argc, char **argv)
{
char *value = NULL;
char *host, *server_type, *command_line;
char *server_location, *env, *arguments;
u_i4 command_line_length;
char config_string[256];
char iidbms[256];
STARTUPINFO si;
PROCESS_INFORMATION ProcessInfo;
BOOL Status;
SECURITY_ATTRIBUTES sa;
HANDLE hRead, hWrite;
HANDLE hStdout;
char buffer[512];
DWORD bufferl = sizeof(buffer);
DWORD pipe_size = 0; /* Use default buffer size */
DWORD datal = 0;
bool havequote, failed = FALSE;
MEadvise( ME_INGRES_ALLOC );
switch (argc)
{
case 1:
server_type = ERx("dbms");
server_location = ERx("*");
break;
case 2:
server_type = argv[1];
server_location = ERx("*");
break;
default:
server_type = argv[1];
if (STcompare(server_type, "recovery") == 0)
server_location = ERx("*");
else
server_location = argv[2];
break;
}
get_sys_dependencies();
/*
** Get the host name, formally used iipmhost.
*/
host = PMhost();
/*
** Build the string we will search for in the config.dat file.
*/
STprintf( config_string,
ERx("%s.%s.%s.%s.image_name"),
SystemCfgPrefix, host, server_type, server_location );
/*
** Get set up for the PMget call.
*/
PMinit();
if( PMload( NULL, (PM_ERR_FUNC *)NULL ) != OK )
PCexit( FAIL );
/*
** Go search config.dat for a match on the string we just built.
*/
PMget( config_string, &value );
if ( value == NULL )
{
NMgtAt( SystemLocationVariable, &env );
if (STcompare(server_type, "recovery") == 0)
{
STprintf(iidbms, ERx("%s\\%s\\bin\\%sdbms"),
env, SystemLocationSubdirectory, SystemCfgPrefix);
}
else
{
STprintf(iidbms, ERx("%s\\%s\\bin\\%s%s"),
env, SystemLocationSubdirectory, SystemCfgPrefix,
server_type);
}
}
else if ( *value == '/' ||
*value == '\\' ||
(*(value+1) == ':' && *(value+2) == '\\') )
{
/* Must be a qualified path name */
STcopy( value, iidbms );
}
else
{
NMgtAt( SystemLocationVariable, &env );
STprintf( iidbms, ERx("%s\\%s\\bin\\%s"),
env, SystemLocationSubdirectory, value );
}
/*
** Initialize the startinfo structure.
*/
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
/*
** Get the original command line.
*/
arguments = GetCommandLine();
havequote = FALSE;
while (*arguments != '\0' && *arguments != '\n')
{
if ( *arguments == '"' )
havequote = (havequote) ? FALSE : TRUE;
if ( CMwhite(arguments) && havequote == FALSE )
break;
arguments++;
}
/*
** Put together a command line to create a process with.
** - 4 blank separators, quotes, null termination
*/
command_line_length = STlength(arguments) + STlength(iidbms) +
STlength(iirun) + 6 + 1;
if((command_line = (char *)
MEreqmem(0, command_line_length, TRUE, NULL)) == NULL)
{
error(ERx("Request for memory failed"),NULL);
}
STprintf( command_line, "%s \"%s\" %s", iirun, iidbms, arguments );
/*
** Save standard out's handle, to be restored later.
*/
hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
/*
** Initialize the security attributes structure that will
** be used to make the pipe handles inheritable.
*/
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE; /* Make object inheritable */
/*
** Define a anonymous pipe to catch the server's startup message.
*/
if((Status = CreatePipe(&hRead,&hWrite,&sa,pipe_size)) != TRUE)
{
error(ERx("CreatePipe failed"),ERx("error code = "));
}
SetStdHandle(STD_OUTPUT_HANDLE,hWrite);
/*
** Initialize the security attributes structure that will
** be used to make the pipe handles inheritable.
*/
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE; /* Make object inheritable */
/*
** Initialize the startup information structure.
*/
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
/*
** Start it up.
*/
/*
** Start iirun which will start the server.
*/
if ((Status = CreateProcess(NULL,command_line,&sa,NULL,TRUE,
HIGH_PRIORITY_CLASS, NULL,
NULL,&si,&ProcessInfo)) != TRUE)
{
DWORD dwError = GetLastError();
switch(dwError)
{
case ERROR_ACCESS_DENIED:
error(ERROR_REQ_PRIVILEGE, ERx(""));
break;
case ERROR_ELEVATION_REQUIRED:
error(ERROR_DENIED_PRIVILEGE, ERROR_REQ_ELEVATION);
break;
default:
error(ERx("CreateProcess failed"),ERx("error code = "));
break;
}
}
SetStdHandle(STD_OUTPUT_HANDLE,hStdout);
for (;;)
{
char *tmpptr;
if((Status = ReadFile(hRead,&buffer,bufferl,&datal,NULL)) != TRUE)
{
error(ERx("ReadFile failed"),ERx("error code = "));
}
buffer[datal] = '\0';
if ((tmpptr = STstrindex(buffer, "PASS\n", 0, FALSE)))
{
*tmpptr = '\0';
if (STlength(buffer))
SIfprintf(stdout, "%s", buffer);
break;
}
SIfprintf(stdout, "%s", buffer);
if ((tmpptr = STstrindex(buffer, bad_msg, 0, FALSE)))
{
*tmpptr = '\0';
if (STlength(buffer))
SIfprintf(stdout, "%s", buffer);
failed = TRUE;
break;
}
}
/*
** Close handles since we don't need them anymore.
*/
CloseHandle(ProcessInfo.hThread);
CloseHandle(ProcessInfo.hProcess);
CloseHandle(hRead);
CloseHandle(hWrite);
if (failed &&
STscompare(server_type, STlength(server_type), "gcb", 3) != 0 &&
STscompare(server_type, STlength(server_type), "gcc", 3) != 0 &&
STscompare(server_type, STlength(server_type), "jdbc", 4) != 0)
{
SIfprintf( stderr,"\n%s: server would not start.\n",
iirundbms );
SIfprintf(stderr,
" %s must be set in your environment.\n",
SystemLocationVariable );
SIfprintf(stderr,
" Has the csinstall program been run?\n");
SIfprintf(stderr,
" %s_DATABASE, %s_CHECKPOINT, %s_JOURNAL and %s_DUMP\n",
SystemVarPrefix,
SystemVarPrefix,
SystemVarPrefix,
SystemVarPrefix );
SIfprintf(stderr,
" must also be set. See %s_CONFIG\\symbol.tbl.\n",
SystemVarPrefix );
SIfprintf(stderr,
" Check the file '%%%s%%\\%s\\files\\errlog.log'\n",
SystemLocationVariable, SystemLocationSubdirectory );
SIfprintf(stderr,
" for more details concerning internal errors.\n");
SIfprintf(stderr,
" See your Installation and Operation Guide for more\n");
SIfprintf(stderr,
" information concerning server startup.\n");
PCexit(FAIL);
}
else
{
PCexit(OK);
}
}
DB_STATUS
dmc_add_db(
DMC_CB *dmc_cb)
{
DMC_CB *dmc = dmc_cb;
DM_SVCB *svcb = dmf_svcb;
DMC_LOC_ENTRY *location;
i4 loc_count;
i4 flags;
i4 mode;
i4 dm2mode;
i4 error,local_error;
DMM_LOC_LIST *loc_ptr[4];
DB_STATUS status;
DMP_DCB *dcb;
CLRDBERR(&dmc->error);
for (status = E_DB_ERROR;;)
{
/* Verify control block parameters. */
if (dmc->dmc_op_type != DMC_DATABASE_OP)
{
SETDBERR(&dmc->error, 0, E_DM000C_BAD_CB_TYPE);
break;
}
if (dmc->dmc_id != svcb->svcb_id)
{
SETDBERR(&dmc->error, 0, E_DM002D_BAD_SERVER_ID);
break;
}
flags = 0;
if (dmc->dmc_flags_mask &
~(DMC_NOJOURNAL | DMC_JOURNAL | DMC_FSTCOMMIT | DMC_SOLECACHE |
DMC_CNF_LOCKED | DMC_CVCFG | DMC_ADMIN_DB | DMC_DMCM))
{
SETDBERR(&dmc->error, 0, E_DM001A_BAD_FLAG);
break;
}
if (dmc->dmc_flags_mask & DMC_NOJOURNAL)
flags |= DM2D_NOJOURNAL;
if (dmc->dmc_flags_mask & DMC_JOURNAL)
flags |= DM2D_JOURNAL;
if (dmc->dmc_flags_mask & DMC_FSTCOMMIT)
flags |= DM2D_FASTCOMMIT;
if (dmc->dmc_flags_mask & DMC_SOLECACHE)
flags |= DM2D_BMSINGLE;
if (dmc->dmc_flags_mask & DMC_CVCFG)
flags |= DM2D_CVCFG;
/* b97083 - Is the CNF file already locked by caller? */
if (dmc->dmc_flags_mask & DMC_CNF_LOCKED)
flags |= DM2D_CNF_LOCKED;
if (dmc->dmc_s_type & DMC_S_SINGLE)
flags |= DM2D_SINGLE;
if (dmc->dmc_s_type & DMC_S_MULTIPLE)
flags |= DM2D_MULTIPLE;
/*
** (ICL phil.p)
*/
if (dmc->dmc_flags_mask & DMC_DMCM)
flags |= DM2D_DMCM;
if (dmc->dmc_flags_mask2 & DMC2_READONLYDB)
flags |= DM2D_READONLYDB;
/* No MO objects if so requested */
if ( dmc->dmc_flags_mask2 & DMC2_NODBMO ||
mode == DMC_A_CREATE || mode == DMC_A_DESTROY )
{
flags |= DM2D_NODBMO;
}
/*
** It is an error to specify Fast Commit without specifying to
** use a single buffer manager.
** (ICL phil.p) UNLESS running DMCM, which effectively means
** running FastCommit in a Multi-Cache environment.
*/
if (!(flags & DM2D_DMCM))
{
if ((flags & (DM2D_FASTCOMMIT | DM2D_BMSINGLE)) == DM2D_FASTCOMMIT)
{
SETDBERR(&dmc->error, 0, E_DM0115_FCMULTIPLE);
break;
}
}
mode = dmc->dmc_db_access_mode;
if (mode != DMC_A_READ &&
mode != DMC_A_WRITE &&
mode != DMC_A_CREATE &&
mode != DMC_A_DESTROY)
{
SETDBERR(&dmc->error, 0, E_DM000F_BAD_DB_ACCESS_MODE);
break;
}
dm2mode = (mode == DMC_A_READ) ? DM2D_A_READ : DM2D_A_WRITE;
/* Check that at least one location was passed in. */
location = (DMC_LOC_ENTRY *)dmc->dmc_db_location.data_address;
loc_count = dmc->dmc_db_location.data_in_size / sizeof(DMC_LOC_ENTRY);
if (loc_count == 0)
{
SETDBERR(&dmc->error, 0, E_DM002A_BAD_PARAMETER);
break;
}
/* Check if database should be created. */
if (mode == DMC_A_CREATE)
{
SCF_CB scf_cb;
SCF_SCI sci_list[2];
DB_NAME collation;
DB_NAME ucollation;
char *p;
char ucolname[] = "udefault";
i4 dbservice;
scf_cb.scf_length = sizeof(SCF_CB);
scf_cb.scf_type = SCF_CB_TYPE;
scf_cb.scf_facility = DB_DMF_ID;
scf_cb.scf_session = (SCF_SESSION)dmc->dmc_session_id;
scf_cb.scf_ptr_union.scf_sci = (SCI_LIST *)sci_list;
sci_list[0].sci_length = sizeof(dbservice);
sci_list[0].sci_code = SCI_DBSERVICE;
sci_list[0].sci_aresult = (char *)&dbservice;
sci_list[0].sci_rlength = 0;
scf_cb.scf_len_union.scf_ilength = 1;
status = scf_call(SCU_INFORMATION, &scf_cb);
if (status != E_DB_OK)
{
uleFormat(&scf_cb.scf_error, 0, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, (char *)0, (i4)0, (i4 *)0,
&error, 0);
SETDBERR(&dmc->error, 0, E_DM002F_BAD_SESSION_ID);
break;
}
/* Collation for iidbdb can only be the default. */
MEfill(sizeof(collation.db_name), ' ', collation.db_name);
NMgtAt("II_COLLATION", &p);
if (p && *p)
MEmove(STlength(p), p, ' ', sizeof(collation.db_name),
collation.db_name);
MEmove(STlength(ucolname), ucolname, ' ',
sizeof(ucollation.db_name), ucollation.db_name);
loc_ptr[0] = (DMM_LOC_LIST *) &loc_list[0];
loc_ptr[1] = (DMM_LOC_LIST *) &loc_list[1];
loc_ptr[2] = (DMM_LOC_LIST *) &loc_list[2];
loc_ptr[3] = (DMM_LOC_LIST *) &loc_list[3];
/* Even though the iidbdb is not "operative" at this stage, we
** will mark it as operative in the config file now (it will not
** be marked operative in the iidatabase catalog until after it
** is fully created). Although we would like to mark the iidbdb
** "inoperative" in the config file now and update it to operative
** status when creation is successfully completed (as is done for
** all other DBs) the internal procedure "iiqef_alter_db" which
** updates this bit will not work on the iidbdb; see comments in
** createdb regarding this problem.
*/
status = dmm_add_create(0, &dmc->dmc_db_name, &dmc->dmc_db_owner,
1, dbservice, DU_OPERATIVE,
(DB_LOC_NAME *) &dbdb_location, 11, "II_DATABASE", 4,
loc_ptr, collation.db_name, ucollation.db_name, &dmc->error);
if (status != E_DB_OK)
{
if (dmc->error.err_code > E_DM_INTERNAL)
{
uleFormat( &dmc->error, 0, NULL, ULE_LOG , NULL,
(char * )0, 0L, (i4 *)0, &local_error, 0);
SETDBERR(&dmc->error, 0, E_DM0084_ERROR_ADDING_DB);
}
break;
}
}
else if (mode == DMC_A_DESTROY)
{
return (E_DB_OK);
}
/* Call the physical layer to construct a DCB for this database. */
status = dm2d_add_db(flags, &dm2mode, &dmc->dmc_db_name,
&dmc->dmc_db_owner, loc_count, (DM2D_LOC_ENTRY *)location, &dcb,
(i4 *)dmc->dmc_lock_list, &dmc->error);
if (status != E_DB_OK)
{
if (dmc->error.err_code > E_DM_INTERNAL)
{
uleFormat( &dmc->error, 0, NULL, ULE_LOG , NULL,
(char * )0, 0L, (i4 *)0, &local_error, 0);
SETDBERR(&dmc->error, 0, E_DM0084_ERROR_ADDING_DB);
}
break;
}
/* Use the access mode passed back */
dmc->dmc_db_access_mode =
(dm2mode == DM2D_A_READ) ? DMC_A_READ : DMC_A_WRITE;
dmc->dmc_db_id = (char *)dcb;
dmc->dmc_dbservice = dcb->dcb_dbservice;
dmc->dmc_dbcmptlvl = dcb->dcb_dbcmptlvl;
dmc->dmc_1dbcmptminor = dcb->dcb_1dbcmptminor;
return (E_DB_OK);
}
return (status);
}
/*
** Name: GClanman_init
** Description:
** LANMAN inititialization function. This routine is called from
** GCpinit() -- the routine GCC calls to initialize protocol drivers.
**
** This function does initialization specific to the protocol:
** Creates Events and Mutex's for the protocol
** Finds and saves a pointer to it's input event Q.
** Fires up the thread which will do asynch I/O
** History:
** 11-Nov-93 (edg)
** created.
** 15-jul-95 (emmag)
** Use a NULL Discretionary Access Control List (DACL) for
** security, to give implicit access to everyone.
** 23-Feb-1998 (thaal01)
** Make space for port_id, stops gcc crashing on startup, sometimes.
** 13-may-2004 (somsa01)
** Updated config.dat string used to retrieve port information such
** that we do not rely specifically on the GCC port.
** 06-Aug-2009 (Bruce Lunsford) Sir 122426
** Change arglist pointer in _beginthreadex for async_thread from
** uninitialized "dummy" to NULL to eliminate compiler warning
** and possible startup problem.
*/
STATUS
GClanman_init(GCC_PCE * pptr)
{
char *ptr, *host, *server_id, *port_id;
char config_string[256];
char buffer[MAX_COMPUTERNAME_LENGTH + 1];
int real_name_size = MAX_COMPUTERNAME_LENGTH + 1;
i4 i;
int tid;
HANDLE hThread;
int status;
SECURITY_ATTRIBUTES sa;
char port_id_buf[8];
port_id = port_id_buf;
iimksec (&sa);
/*
** Look for trace variable.
*/
NMgtAt( "II_LANMAN_TRACE", &ptr );
if ( !(ptr && *ptr) && PMget("!.lanman_trace_level", &ptr) != OK )
{
GCLANMAN_trace = 0;
}
else
{
GCLANMAN_trace = atoi( ptr );
}
/*
** Create MUTEX and EVENT for the input queue of this protocol
** driver.
*/
if ( ( hMutexThreadInQ = CreateMutex(&sa, FALSE, NULL) ) == NULL )
{
return FAIL;
}
GCTRACE(3)( "GClanman_init: MutexInQ Handle = %d\n", hMutexThreadInQ );
if ( ( hEventThreadInQ = CreateEvent(&sa, FALSE, FALSE, NULL)) == NULL )
{
CloseHandle( hMutexThreadInQ );
return FAIL;
}
GCTRACE(3)( "GClanman_init: EventInQ Handle = %d\n", hEventThreadInQ );
GCTRACE(4)( "Start GClanman_init\n" );
/*
** Get set up for the PMget call.
*/
PMinit();
if( PMload( NULL, (PM_ERR_FUNC *)NULL ) != OK )
PCexit( FAIL );
/*
** Construct the network port identifier.
*/
host = PMhost();
server_id = PMgetDefault(3);
if (!server_id)
server_id = "*" ;
STprintf( config_string, ERx("!.lanman.port"),
SystemCfgPrefix, host, server_id);
/*
** Search config.dat for a match on the string we just built.
** If we don't find it, then use the value for II_INSTALLATION
** failing that, default to II.
*/
PMget( config_string, &port_id );
if (port_id == NULL )
{
NMgtAt("II_INSTALLATION", &ptr);
if (ptr != NULL && *ptr != '\0')
{
STcopy(ptr, port_id);
}
else
{
STcopy(SystemVarPrefix, port_id);
}
}
NMgtAt( "II_NETBIOS_NODE", &ptr );
if ( !ptr || !*ptr )
{
/*
** Get Computer Name into buffer.
*/
*buffer = (char)NULL;
GetComputerName( buffer, &real_name_size );
if ( !*buffer )
STcopy( "NONAME", buffer );
ptr = buffer;
}
/*
** MyName holds ID for outgoing connections.
*/
STpolycat( 2, ptr, "_", MyName );
/*
** Create listen port ID.
*/
STpolycat( 3, ptr, "_", port_id, GCc_listen_port );
CVupper( MyName );
CVupper( GCc_listen_port );
STcopy( GCc_listen_port, pptr->pce_port );
GCTRACE(2)("GClanman_init: port = %s\n", pptr->pce_port );
/*
** Go thru the the protocol threads event list and find the index
** of the lanman thread. Set the Global Tptr for easy reference
** to the event q's for this protocols thread.
*/
for ( i = 0; i < IIGCc_proto_threads.no_threads; i++ )
{
THREAD_EVENTS *p = &IIGCc_proto_threads.thread[i];
if ( !STcompare( LANMAN_ID, p->thread_name ) )
{
Tptr = p;
break;
}
}
if ( Tptr == NULL )
{
CloseHandle( hEventThreadInQ );
CloseHandle( hMutexThreadInQ );
return FAIL;
}
/*
** Finally we start the asynchronous I/O thread
*/
hThread = (HANDLE)_beginthreadex(&sa,
GC_STACK_SIZE,
(LPTHREAD_START_ROUTINE) GClanman_async_thread,
NULL,
(unsigned long)NULL,
&tid);
if (hThread)
{
CloseHandle(hThread);
}
else
{
status = errno;
GCTRACE(1)("GClanman_init: Couldn't create thread errno = %d '%s'\n",
status, strerror(status) );
return FAIL;
}
return OK;
}
STATUS
ME_alloc_shared(i4 flag,
SIZE_TYPE pages,
char *key,
PTR *memory,
SIZE_TYPE *allocated_pages,
CL_ERR_DESC *err_code)
{
STATUS status;
SIZE_TYPE memsize;
#ifdef LP64
LARGE_INTEGER numbytes;
#endif
HANDLE name;
HANDLE map;
PTR temp;
char map_key[MAX_LOC+1];
char *install_code;
char *ObjectPrefix;
SECURITY_ATTRIBUTES sa;
CLEAR_ERR(err_code);
GVshobj(&ObjectPrefix);
if (key == NULL || *key == '\0') {
return (ME_BAD_PARAM);
}
memsize = pages * ME_MPAGESIZE;
/*
** Moved ME_makekey to be called each time ME_alloc_shared is called
** as this obtains a handle to the file which will be required later
** if this is an attach to shared memory.
** This file handle is closed during an MEshared_free.
*/
if ((name = ME_makekey(key)) == (HANDLE) -1)
{
status = GetLastError();
SETWIN32ERR(err_code, status, ER_alloc);
return (FAIL);
}
/*
** The file mapping key used to be the name of the file.
** This caused problems when Jasmine and Ingres were installed
** on the same machine. Create a unique key name, and use
** that for File Mapping instead.
*/
NMgtAt("II_INSTALLATION", &install_code);
STpolycat(4, ObjectPrefix, SystemVarPrefix, install_code,
key, map_key);
if (flag & ME_CREATE_MASK) {
iimksecdacl( &sa );
FlushFileBuffers(name);
#ifdef LP64
numbytes.QuadPart = Int32x32To64(pages, ME_MPAGESIZE);
map = CreateFileMapping(name,
&sa,
PAGE_READWRITE,
numbytes.HighPart,
numbytes.LowPart,
map_key);
#else
map = CreateFileMapping(name,
&sa,
PAGE_READWRITE,
0,
memsize,
map_key);
#endif /* LP64 */
if (map == NULL) {
status = GetLastError();
SETWIN32ERR(err_code, status, ER_alloc);
FlushFileBuffers(name);
CloseHandle(name);
switch (status) {
case ERROR_ALREADY_EXISTS:
return ME_ALREADY_EXISTS;
case ERROR_NOT_ENOUGH_MEMORY:
return ME_OUT_OF_MEM;
default:
return FAIL;
}
}
if (map != NULL && GetLastError() == ERROR_ALREADY_EXISTS) {
FlushFileBuffers(name);
CloseHandle(map);
CloseHandle(name);
return (ME_ALREADY_EXISTS);
}
} else {
map = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE,
FALSE,
map_key);
if (map == NULL) {
status = GetLastError();
SETWIN32ERR(err_code, status, ER_alloc);
FlushFileBuffers(name);
CloseHandle(name);
switch (status) {
case ERROR_FILE_NOT_FOUND:
return ME_NO_SUCH_SEGMENT;
case ERROR_NOT_ENOUGH_MEMORY:
return ME_OUT_OF_MEM;
default:
return FAIL;
}
}
}
/*
* Finally. Now get a memory address for the sucker.
*
* If ME_ADDR_SPEC is set, we'll attempt to hardwire the address; else
* we'll take whatever the system gives us.
*/
if (flag & ME_ADDR_SPEC) {
temp = MapViewOfFileEx(map,
FILE_MAP_WRITE | FILE_MAP_READ,
0,
0,
0,
*memory);
if ((temp == NULL) || (temp != *memory)) {
status = GetLastError();
SETWIN32ERR(err_code, status, ER_alloc);
return (FAIL);
}
} else {
*memory = MapViewOfFile(map,
FILE_MAP_WRITE | FILE_MAP_READ,
0,
0,
0);
if (*memory == NULL) {
status = GetLastError();
SETWIN32ERR(err_code, status, ER_alloc);
return (FAIL);
}
}
/*
** If this is not an attach to shared memory assume that pages value
** is valid.
*/
if ((flag & ME_CREATE_MASK) ||
!(flag & (ME_SSHARED_MASK | ME_MSHARED_MASK)))
{
pages = (SIZE_TYPE)(memsize / ME_MPAGESIZE);
}
else
{
BY_HANDLE_FILE_INFORMATION sFileInfo;
/*
** If attaching to shared memory ignore the page argument and
** calculate size of shared segment in pages from file size.
** Assume that a single shared memory file will not exceed 4G.
*/
if (GetFileInformationByHandle (name, &sFileInfo) == 0)
{
status = GetLastError();
SETWIN32ERR(err_code, status, ER_alloc);
return (FAIL);
}
else
{
pages = sFileInfo.nFileSizeLow / ME_MPAGESIZE;
}
}
if (allocated_pages)
*allocated_pages = pages;
/*
** if this is an attach where pages is 0 ME_reg_seg will register
** pages calculated from the size of the file.
*/
if (ME_reg_seg(*memory,
pages,
map,
name) != OK) {
UnmapViewOfFile(memory);
*memory = (PTR) NULL;
return (FAIL);
}
return (OK);
}
/*{
** Name: main() - collation compiler
**
** Description:
** Top level of collation compiler.
**
** Inputs:
** argc argument count
** argv argument vector
**
** Outputs:
** none
**
** History:
** 03-may-89 (anton)
** Created.
** 17-Jun-89 (anton)
** Moved to ADU from CL
** 21-Dec-89 (anton)
** Fixed usage message - removed magic number - bug 9193
** 01-jun-92 (andys)
** Correct spelling of 'language'. [bug 44495]
** 21-jun-93 (geri)
** PCexit with FAIL if error encountered; added CMset_attr call
** to intialize CM attribute table; chaged read-in char set
** to use II_CHARSET symbol. These were in the 6.4 version.
** 14-mar-2001 (stephenb)
** Add optional unicode indicator.
** 06-sep-2002 (hanch04)
** The 32 and 64 bit version need to be run so call PCspawnlp64.
** 14-Jun-2004 (schka24)
** Use (safe) canned charmap setting routine.
** 04-Mar-2005 (hanje04)
** SIR 114034
** Add support for reverse hybrid builds, i.e. 64bit exe needs to
** call 32bit version.
** 09-Mar-2007 (gupsh01)
** Add support for upper/lower case operations.
** 20-Jun-2009 (kschendel) SIR 122138
** Hybrid add-on symbol changed, fix here.
*/
main(
int argc,
char *argv[])
{
ADULTABLE *tbl;
ADUUCETAB *utbl;
STATUS stat;
CL_ERR_DESC cl_err;
bool unicode = FALSE;
#if defined(conf_BUILD_ARCH_32_64) && defined(BUILD_ARCH32)
char *lp64enabled;
#endif
_VOID_ MEadvise(ME_INGRES_ALLOC);
#if defined(conf_BUILD_ARCH_32_64) && defined(BUILD_ARCH32)
/*
** Try to exec the 64-bit version
*/
NMgtAt("II_LP64_ENABLED", &lp64enabled);
if ( (lp64enabled && *lp64enabled) &&
( !(STbcompare(lp64enabled, 0, "ON", 0, TRUE)) ||
!(STbcompare(lp64enabled, 0, "TRUE", 0, TRUE))))
{
PCspawnlp64(argc, argv);
}
#endif /* hybrid */
#if defined(conf_BUILD_ARCH_64_32) && defined(BUILD_ARCH64)
{
char *lp32enabled;
/*
** Try to exec the 32-bit version
*/
NMgtAt("II_LP32_ENABLED", &lp32enabled);
if ( (lp32enabled && *lp32enabled) &&
( !(STbcompare(lp32enabled, 0, "ON", 0, TRUE)) ||
!(STbcompare(lp32enabled, 0, "TRUE", 0, TRUE))))
PCspawnlp32(argc, argv);
}
#endif /* reverse hybrid */
/* Set CM character set stuff */
stat = CMset_charset(&cl_err);
if (stat != OK)
{
SIprintf("Error while processing character set attribute file.\n");
PCexit(FAIL);
}
_VOID_ SIeqinit();
if (argc != 3 && argc != 4)
{
SIprintf("Usage: aducompile description-file language-file [-u]\n");
PCexit(FAIL);
}
if (argc == 4)
{
/* must be -u flag for unicode */
if (STbcompare(argv[3], 0, "-u", 0, TRUE))
{
SIprintf("Usage: aducompile description-file language-file [-u]\n");
PCexit(FAIL);
}
unicode = TRUE;
}
if (unicode)
{
utbl = makeutable(argv[1]);
if (!utbl)
{
SIprintf("aducompile: description-file syntax error\n");
PCexit(FAIL);
}
stat = dumputbl(utbl, argv[2]);
if (stat)
SIprintf("aducompile: dumptbl %s failed with %x\n", argv[2], stat);
}
else
{
tbl = maketable(argv[1]);
if (!tbl)
{
SIprintf("aducompile: description-file syntax error\n");
PCexit(FAIL);
}
stat = dumptbl(tbl, argv[2]);
if (stat)
SIprintf("aducompile: dumptbl %s failed with %x\n", argv[2], stat);
}
PCexit(stat ? FAIL : OK);
}
i4
main(
i4 argc,
char * argv[])
{
char c='\0';
char *tz_file=NULL;
char *tz_name=NULL;
char *tz_def;
char tzname[TM_MAX_TZNAME+1];
char tzfile[MAX_LOC+1];
char ioptarg[MAX_LOC + 1];
char tz_pmvalue[MAX_LOC + 1];
char tz_pmname[MAX_LOC + 1];
char *p, *ip, *pm_value;
char *tm_tztype;
char chr='/';
char *out_file;
i4 ioptind=1, i;
char *tm_tztime;
i4 timecnt, tempi, temptype, temptz;
char buf[sizeof(TM_TZ_CB)+TM_MAX_TIMECNT*(sizeof(i4)+1)];
FILE *fid;
LOCATION loc_root, tmp_loc;
STATUS status=OK;
TM_TZ_CB *tm_tz_cb;
struct timevect time_v;
appname = argv[0];
if( TMtz_getopt(argc, argv, "n:name:f:file", &ioptind, ioptarg, &c) == OK)
{
switch (c)
{
case 'f':
tz_file = ioptarg;
break;
case 'n':
tz_name = ioptarg;
break;
default:
break;
}
}
else
{
TMtz_usage();
PCexit(FAIL);
}
if( tz_file == NULL)
{
if( tz_name == NULL)
{
/* Get II_TIMEZONE_NAME value */
NMgtAt(ERx("II_TIMEZONE_NAME"), &tz_def);
if (!tz_def || !(*tz_def))
{
SIprintf("%s: %s_TIMEZONE_NAME is not set\n",
appname, SystemVarPrefix);
PCexit(FAIL);
}
STncpy(tzname, tz_def, TM_MAX_TZNAME);
tzname[ TM_MAX_TZNAME ] = EOS;
}
else
{
STncpy(tzname, tz_name, TM_MAX_TZNAME);
tzname[ TM_MAX_TZNAME ] = EOS;
}
PMinit();
if( PMload( NULL, (PM_ERR_FUNC *)NULL) != OK)
{
SIprintf("%s: Error loading PM %s_CONFIG/config.dat file\n",
appname, SystemVarPrefix);
PCexit(FAIL);
}
/* Get timezone file name */
STprintf( tz_pmname, ERx("%s.*.tz.%s"), SystemCfgPrefix, tzname);
if( PMget( tz_pmname, &pm_value) != OK)
{
SIprintf("%s: Error locating %s in PM config.dat file\n",
appname, tz_pmname);
PCexit(FAIL);
}
do
{
if((status = NMloc(FILES, PATH, ERx("zoneinfo"), &loc_root)) != OK)
break;
#if defined(conf_BUILD_ARCH_32_64) && defined(BUILD_ARCH64)
if((status = LOfaddpath(&loc_root, ERx("lp64"), &loc_root)) != OK)
break;
#endif
#if defined(conf_BUILD_ARCH_64_32) && defined(BUILD_ARCH32)
{
/*
** Reverse hybrid support must be available in ALL
** 32bit binaries
*/
char *rhbsup;
NMgtAt("II_LP32_ENABLED", &rhbsup);
if ( (rhbsup && *rhbsup) &&
( !(STbcompare(rhbsup, 0, "ON", 0, TRUE)) ||
!(STbcompare(rhbsup, 0, "TRUE", 0, TRUE))))
status = LOfaddpath(&loc_root, "lp32", &loc_root);
}
#endif /* reverse hybrid */
STcopy( pm_value, tz_pmvalue);
/*
** Compose the directory path
*/
for( p = tz_pmvalue, ip = tz_pmvalue;
(p = STchr(ip, chr)) != NULL;)
{
*p = EOS;
if((status = LOfaddpath(&loc_root, ip, &loc_root)) != OK)
break;
ip = CMnext(p);
}
/*
** Add file name to the directory path
*/
if((status = LOfroms(FILENAME, ip, &tmp_loc)) != OK)
break;
status = LOstfile( &tmp_loc, &loc_root);
} while( FALSE);
if( status != OK)
{
SIprintf("%s: Error composing timezone file name for %s\n",
appname, tz_pmvalue);
PCexit(FAIL);
}
}
else
{
STcopy("<unknown>", tzname);
STncpy( tzfile, tz_file, MAX_LOC);
tzfile[ MAX_LOC ] = EOS;
if( LOfroms(FILENAME&PATH, tzfile, &loc_root) != OK)
{
SIprintf("%s: Error composing timezone file name for %s\n",
appname, tz_pmvalue);
PCexit(FAIL);
}
}
/*
** Now open the timezone information file
*/
do
{
if((status = SIfopen( &loc_root, ERx("r"), SI_VAR, sizeof buf, &fid))
!= OK)
break;
status = SIread(fid, sizeof buf, &i, buf);
status = SIclose(fid);
} while(FALSE);
if( status != OK)
{
LOtos( &loc_root, &out_file);
SIprintf("%s: Error opening %s for timezone %s\n",
appname, out_file, tzname);
PCexit(FAIL);
}
tm_tz_cb = (TM_TZ_CB *)&buf;
I4ASSIGN_MACRO( tm_tz_cb->timecnt, timecnt);
/* Make sure the input file has correct file size */
if( timecnt > TM_MAX_TIMECNT || timecnt < 0
|| i != sizeof(TM_TZ_CB) + timecnt*(sizeof(i4)+1))
{
LOtos( &loc_root, &out_file);
SIprintf(
"%s: Invalid file format for timezone file %s for timezone %s\n",
appname, out_file, tzname);
SIprintf(
" File size: %d, Expected file size: %d, time periods: %d\n",
i, sizeof(TM_TZ_CB) + timecnt*(sizeof(i4)+1),
timecnt);
PCexit(FAIL);
}
/* Now we are all set to display the content of timezone information file */
LOtos( &loc_root, &out_file);
SIprintf("\n\n");
SIprintf("timezone name: %s\n", tzname);
SIprintf("timezone file: %s\n", out_file);
SIprintf("-------------------------------------");
SIprintf("-------------------------------------\n");
if(timecnt == 0)
{
I4ASSIGN_MACRO( tm_tz_cb->tzinfo[0].gmtoff, tempi);
SIprintf(" Fixed GMT offset (secs): %d\n", tempi);
}
else
{
SIprintf("\tPeriod Begin");
SIprintf("\t\tGMT offset\n");
SIprintf("\t(YYYY_MM_DD HH:MM)");
SIprintf("\t(Minute)\n\n");
tm_tztype = buf + sizeof(TM_TZ_CB);
tm_tztime = tm_tztype + timecnt;
i=0;
while( i < timecnt)
{
I4ASSIGN_MACRO( *tm_tztime, tempi);
/* Adjust for timezone */
if( i == 0)
temptype = (i4)tm_tztype[i+1];
else
temptype = (i4)tm_tztype[i-1];
I4ASSIGN_MACRO( tm_tz_cb->tzinfo[temptype].gmtoff, temptz);
/* Get real timezone */
tempi += temptz;
temptype = (i4)tm_tztype[i];
I4ASSIGN_MACRO( tm_tz_cb->tzinfo[temptype].gmtoff, temptz);
TMtz_cvtime( tempi, &time_v);
SIprintf("\t%04d_%02d_%02d %02d:%02d\t%d\t%s\n",
time_v.tm_year+1900,
time_v.tm_mon+1,
time_v.tm_mday,
time_v.tm_hour,
time_v.tm_min,
temptz/60,
tm_tz_cb->tzlabel + tm_tz_cb->tzinfo[temptype].abbrind);
tm_tztime += sizeof(i4);
i++;
}
}
PCexit(OK);
}
II_EXTERN IIAPI_ENVHNDL *
IIapi_initAPI( II_LONG version, II_LONG timeout )
{
IIAPI_ENVHNDL *envHndl;
IIAPI_ENVHNDL *defEnvHndl;
II_BOOL first_init = FALSE;
STATUS status;
char *env;
if ( ! IIapi_static )
{
/*
** Perform global initializations which are
** environment independent.
*/
first_init = TRUE;
if ( ! ( IIapi_static = (IIAPI_STATIC *)
MEreqmem( 0, sizeof( IIAPI_STATIC ), TRUE, &status ) ) )
return( NULL );
QUinit( &IIapi_static->api_env_q );
if ( MUi_semaphore( &IIapi_static->api_semaphore ) != OK )
goto muiFail;
if ( MEtls_create( &IIapi_static->api_thread ) != OK )
goto metFail;
/*
** Initialize sub-systems.
*/
IIAPI_INITTRACE();
IIAPI_TRACE( IIAPI_TR_TRACE )( "IIapi_initAPI: initializing API.\n" );
/*
** Make sure II_SYSTEM or similar is set to provide useful feedback
** rather than just failing in one of following subsystems.
*/
NMgtAt( SYSTEM_LOCATION_VARIABLE, &env );
if ( env == NULL || *env == EOS )
{
IIAPI_TRACE( IIAPI_TR_FATAL )
( "IIapi_initAPI: error - %s not set.\n",
SYSTEM_LOCATION_VARIABLE );
goto adfFail;
}
IIapi_init_mib();
if ( ! IIapi_initADF() ) goto adfFail;
if ( ! IIapi_initGCA(timeout) ) goto gcaFail;
/* Initialize the unicode collation values */
IIapi_static->api_unicol_init = FALSE;
IIapi_static->api_ucode_ctbl = NULL;
IIapi_static->api_ucode_cvtbl = NULL;
/*
** Create the default environment.
*/
if ( ! (IIapi_static->api_env_default =
(PTR)IIapi_createEnvHndl( IIAPI_VERSION_1 )) )
goto defFail;
/* Spoken Language to use */
if( ( status = ERlangcode( (char *)NULL,
&IIapi_static->api_slang ) != OK) )
{
IIAPI_TRACE( IIAPI_TR_ERROR )
( "IIapi_initAPI: error initializing lang 0x%x\n", status );
return( NULL );
}
/*
** The SQL state machines are used by default prior to
** IIapi_connect() being called, so make sure they are
** initialized.
*/
if ( IIapi_sm_init( IIAPI_SMT_SQL ) != IIAPI_ST_SUCCESS )
goto envFail;
}
/*
** Now do environment specific initialization.
*/
defEnvHndl = IIapi_defaultEnvHndl();
if ( version == IIAPI_VERSION_1 )
{
/*
** Version 1 initializers share the default
** environment. Keep track of the number of
** initializers so that IIapi_termAPI() can
** determine when to do global shutdown.
*/
envHndl = defEnvHndl;
MUp_semaphore( &defEnvHndl->en_semaphore );
defEnvHndl->en_initCount++;
MUv_semaphore( &defEnvHndl->en_semaphore );
}
else
{
/*
** Create a new environment for the initializer.
** These environments are saved on the global
** environment queue. The caller may also make
** API calls using the default environment handle,
** so increment the default environment handle
** initialization count.
*/
if ( (envHndl = IIapi_createEnvHndl( version )) )
{
MUp_semaphore( &IIapi_static->api_semaphore );
QUinsert( (QUEUE *)envHndl, &IIapi_static->api_env_q );
MUv_semaphore( &IIapi_static->api_semaphore );
MUp_semaphore( &defEnvHndl->en_semaphore );
defEnvHndl->en_initCount++;
MUv_semaphore( &defEnvHndl->en_semaphore );
}
else
{
/*
** We may need to undo the global initialization.
** If not, the NULL environment handle will simply
** be returned.
*/
if ( first_init ) goto envFail;
}
}
return( envHndl );
envFail:
IIapi_deleteEnvHndl( (IIAPI_ENVHNDL *)IIapi_static->api_env_default );
defFail:
IIapi_termGCA();
gcaFail:
IIapi_termADF();
adfFail:
IIAPI_TERMTRACE();
MEtls_destroy( &IIapi_static->api_thread, NULL );
metFail:
MUr_semaphore( &IIapi_static->api_semaphore );
muiFail:
MEfree( (PTR)IIapi_static );
IIapi_static = NULL;
return( NULL );
}
/*{
** Name: main
**
** Description:
** Start Replicator (replicat) as an NT Service.
**
** Inputs:
** argc and argv from the command line
** server_no - server number
**
** Outputs:
** none
**
** Returns:
** none
**
** History:
** 14-Aug-97 (fanra01)
** Modified the Query loop for service status give a chance to the
** service control manager to update status.
** 28-jan-2000 (somsa01)
** Services are now keyed off of the installation identifier.
*/
i4
main(
i4 argc,
char *argv[])
{
SC_HANDLE scm;
SC_HANDLE scs;
i4 svc_argc;
char **svc_argv;
SERVICE_STATUS svc_status;
TCHAR svc_name[32];
DWORD ckpt = 0;
BOOL blCheck = TRUE;
char *cptr;
MEfill (sizeof (SERVICE_STATUS), 0, &svc_status);
svc_status.dwWaitHint = 2000; /* default time set after start */
/* service */
if (argc < 2)
{
SIprintf("usage: rpserver <server_no> [args]\n");
PCexit(FAIL);
}
NMgtAt("II_INSTALLATION", &cptr);
STprintf(svc_name, ERx("%s_%s_%s"), SVC_NAME, cptr, argv[1]);
/* connect to the service control manager */
scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
if (scm == NULL)
{
SIprintf("Error %d in OpenSCManager.\n", (i4)GetLastError());
PCexit(FAIL);
}
scs = OpenService(scm, svc_name, SERVICE_START | SERVICE_QUERY_STATUS);
if (scs == NULL)
{
DWORD dwError = GetLastError();
switch(dwError)
{
case ERROR_ACCESS_DENIED:
SIprintf(ERROR_DENIED_PRIVILEGE);
SIprintf(ERROR_REQ_ELEVATION);
CloseServiceHandle(scm);
PCexit(dwError);
default:
SIprintf("Error %d in OpenService.\n", dwError);
CloseServiceHandle(scm);
PCexit(FAIL);
}
}
svc_argc = argc - 2;
svc_argv = (svc_argc == 0 ? NULL : argv + 2);
if (!StartService(scs, svc_argc, svc_argv))
{
SIprintf("Error %d in StartService.\n", (i4)GetLastError());
CloseServiceHandle(scs);
CloseServiceHandle(scm);
PCexit(FAIL);
}
Sleep (svc_status.dwWaitHint);
do
{
ckpt = svc_status.dwCheckPoint; /* update check point */
if (!QueryServiceStatus(scs, &svc_status))
{
SIprintf("Error %d in QueryServiceStatus.\n",
(i4)GetLastError());
CloseServiceHandle(scs);
CloseServiceHandle(scm);
PCexit(FAIL);
}
/*
** if the check point hasn't moved since last
** check stop checking
*/
switch (svc_status.dwCurrentState)
{
case SERVICE_START_PENDING:
case SERVICE_CONTINUE_PENDING:
Sleep(svc_status.dwWaitHint);
break;
case SERVICE_RUNNING:
case SERVICE_STOPPED:
default:
blCheck = FALSE;
break;
}
} while (blCheck);
if (svc_status.dwCurrentState != SERVICE_RUNNING)
{
SIprintf("%s service not started:\n", svc_name);
SIprintf(" Current State: %d\n",
(i4)svc_status.dwCurrentState);
SIprintf(" Exit Code: %d\n",
(i4)svc_status.dwWin32ExitCode);
SIprintf(" Service Specific Exit Code: %d\n",
(i4)svc_status.dwServiceSpecificExitCode);
}
CloseServiceHandle(scs);
CloseServiceHandle(scm);
}
/*{
** Name: LGK_initialize() - initialize the lg/lk shared mem segment.
**
** Description:
** This routine is called by the LGinitialize or LKinitialize routine. IT
** assumes that a previous caller has allocated the shared memory segment.
**
** If it discovers that the shared memory segment has not yet been
** initialized, it calls the LG and LK initialize-memory routines to do so.
**
** Inputs:
** flag - bit mask of:
** LOCK_LGK_MEMORY to lock the shared data segment
** LGK_IS_CSP if process is CSP process this node.
**
** Outputs:
** sys_err - place for system-specific error information.
**
** Returns:
** OK - success
** !OK - failure (CS*() routine failure, segment not mapped, ...)
**
** History:
** Summer, 1992 (bryanp)
** Working on the new portable logging and locking system.
** 19-oct-1992 (bryanp)
** Check memory version number when attaching.
** 22-oct-1992 (bryanp)
** Change LGLKDATA.MEM to lglkdata.mem.
** 23-Oct-1992 (daveb)
** name the semaphore too.
** 13-feb-1993 (keving)
** Remove support for II_LGK_MEMORY_SIZE. If II_LG_MEMSIZE
** is not set then calculate memory size from PM values.
** 24-may-1993 (bryanp)
** If the shared memory is the wrong version, don't install the
** at_exit handlers (the rundown routines won't be able to interpret
** the memory properly).
** 26-jul-1993 (jnash)
** Add 'flag' param lock the LGK data segment.
** 20-sep-1993 (bryanp)
** In addition to calling PCatexit, call (on VMS) sys$dclexh, since
** there are some situations (image death and image rundown without
** process rundown) which are caught neither by PCatexit (since
** PCexit isn't run) nor by check-dead threads (since process
** rundown never happened). This fixes a hole where an access-
** violating ckpdb or auditdb command never got cleaned up.
** 31-jan-1994 (bryanp)
** Back out a few "features" which are proving countereffective:
** 1) Don't bother checking mem_creator_pid to see if the previous
** creator of the shared memory has died. This was an attempt to
** gracefully re-use sticky shared memory following a system crash,
** but it is suspected as being the culprit in a series of system
** failures by re-initializing the shared memory at inopportune
** times.
** 2) Don't complain if the shared memory already exists but is of a
** different size than you expected. Just go ahead and try to use
** it anyway.
** 21-feb-1994 (bryanp)
** Reverse item (1) of the above 31-jan-1994 change and re-enable the
** graceful re-use of shared memory. People weren't happy with
** having to run ipcclean and csinstall all the time.
** 23-may-1994 (bryanp)
** On VMS, disable ^Y for LG/LK-aware processes. We don't want to allow
** ^Y because you might interrupt the process right in the middle
** of an LG or LK operation, while holding the shared memory
** semaphore, and this would then wedge the whole installation.
**
** 17-May-1994 (daveb) 59127
** Attach lgk_mem semaphore if we're attaching to the segment.
** 30-jan-1995 (lawst01) bug 61984
** Use memory needed calculation from the 'lgk_calculate_size'
** function to determine the size of the shared memory pool for
** locking and locking. If the II_LG_MEMSIZE variable is specified
** with a value larger than needed use the supplied value. If
** lgk_calculate_size is unable to calculate a size then use the
** magic number of 400000. In addition issue a warning message
** and continue executing in the event the number of pages
** allocated is less than the number requested.
** 24-apr-1997 (nanpr01)
** Reinstate Bryanp's change. In the process of fixing bug 61984
** by Steve Lawrence and subsequent undo of Steve's fix by Nick
** Ireland on 25-jun-96 (nick) caused the if 0 code removed.
** Part of the Steve's change was not reinstated such as not returning
** the status and exit and continue.
** 1. Don't complain if the shared memory already exists but is of a
** different size than you expected. Just go ahead and try to use
** it.
** 18-aug-1998 (hweho01)
** Reclaim the kernel resource if LG/LK shared memory segment is
** reinitialized. If the shared segment is re-used (the previous creator
** of the shared segment has died), the cross-process semaphores get
** initialized more than once at the same locations. That cause the
** kernel resource leaks on DG/UX (OS release 4.11MU04). To fix the
** problem, CS_cp_sem_cleanup() is called to destroy all the
** semaphores before LG/LK shraed segment get recreated.
** CS_cp_sem_cleanup() is made dependent on xCL_NEED_SEM_CLEANUP and
** OS_THREADS_USED, it returns immediately for most platforms.
** 27-Mar-2000 (jenjo02)
** Added test for crossed thread types, refuse connection
** to LGK memory with E_DMA811_LGK_MT_MISMATCH.
** 18-apr-2001 (devjo01)
** s103715 (Portable cluster support)
** - Add CX mem requirement calculations.
** - Add LGK_IS_CSP flag to indicate that LGK memory is being
** initialized for a CSP process.
** - Add basic CX initialization.
** 19-sep-2002 (devjo01)
** If running NUMA clustered allocate memory out of local RAD.
** 30-Apr-2003 (jenjo02)
** Rearchitected to silence long-tolerated race conditions.
** BUG 110121.
** 27-feb-2004 (devjo01)
** Rework allocation of CX shared memory to be compatible
** with race condition fix introduced for bug 110121.
** 29-Dec-2008 (jonj)
** If lgk_calculate_size() returns FAIL, the total memory
** needed exceeds MAX_SIZE_TYPE and we can't continue, but
** tell what we can about the needs of the various bits of
** memory before quitting.
** 06-Aug-2009 (wanfr01)
** Bug 122418 - Return E_DMA812 if LOCK_LGK_MUST_ATTACH is
** is passed in and memory segment does not exist
** 20-Nov-2009 (maspa05) bug 122642
** In order to synchronize creation of UUIDs across servers added
** a semaphore and a 'last time' variable into LGK memory.
** 14-Dec-2009 (maspa05) bug 122642
** #ifdef out the above change for Windows. The rest of the change
** does not apply to Windows so the variables aren't defined.
*/
STATUS
LGK_initialize(
i4 flag,
CL_ERR_DESC *sys_err,
char *lgk_info)
{
PTR ptr;
SIZE_TYPE memleft;
SIZE_TYPE size;
STATUS ret_val;
STATUS mem_exists;
char mem_name[15];
SIZE_TYPE allocated_pages;
i4 me_flags;
i4 me_locked_flag;
SIZE_TYPE memory_needed;
char *nm_string;
SIZE_TYPE pages;
LGK_MEM *lgk_mem;
i4 err_code;
SIZE_TYPE min_memory;
i4 retries;
i4 i;
i4 attached;
PID *my_pid_slot;
i4 clustered;
u_i4 nodes;
SIZE_TYPE cxmemreq;
PTR pcxmem;
LGLK_INFO lgkcount;
char instid[4];
CL_CLEAR_ERR(sys_err);
/*
** if LGK_base is set then this routine has already been called. It is
** set up so that both LGiniitalize and LKinitialize calls it, but only
** the first call does anything.
*/
if (LGK_base.lgk_mem_ptr)
return(OK);
PCpid( &LGK_my_pid );
memory_needed = 0;
NMgtAt("II_LG_MEMSIZE", &nm_string);
if (nm_string && *nm_string)
#if defined(LP64)
if (CVal8(nm_string, (long*)&memory_needed))
#else
if (CVal(nm_string, (i4 *)&memory_needed))
#endif /* LP64 */
memory_needed = 0;
/* Always calculate memory needed from PM resource settings */
/* and compare with supplied value, if supplied value is less */
/* than minimum then use minimum */
min_memory = 0;
if ( OK == lgk_get_counts(&lgkcount, FALSE))
{
if ( lgk_calculate_size(FALSE, &lgkcount, &min_memory) )
{
/*
** Memory exceeds MAX_SIZE_TYPE, can't continue.
**
** Do calculation again, this time with "wordy"
** so user can see allocation bits, then quit.
*/
lgk_calculate_size(TRUE, &lgkcount, &min_memory);
return (E_DMA802_LGKINIT_ERROR);
}
}
if (min_memory)
memory_needed = (memory_needed < min_memory) ? min_memory
: memory_needed;
else
memory_needed = (memory_needed < 400000 ) ? 400000
: memory_needed;
clustered = (i4)CXcluster_enabled();
cxmemreq = 0;
if ( clustered )
{
if ( OK != CXcluster_nodes( &nodes, NULL ) )
nodes = 0;
cxmemreq = CXshm_required( 0, nodes, lgkcount.lgk_max_xacts,
lgkcount.lgk_max_locks, lgkcount.lgk_max_resources );
if ( MAX_SIZE_TYPE - memory_needed < cxmemreq )
{
/*
** Memory exceeds MAX_SIZE_TYPE, can't continue.
**
** Do calculation again, this time with "wordy"
** so user can see allocation bits, then quit.
*/
SIprintf("Total LG/LK/CX allocation exceeds max of %lu bytes by %lu\n"
"Adjust logging/locking configuration values and try again\n",
MAX_SIZE_TYPE, cxmemreq - (MAX_SIZE_TYPE - memory_needed));
lgk_calculate_size(TRUE, &lgkcount, &min_memory);
return (E_DMA802_LGKINIT_ERROR);
}
memory_needed += cxmemreq;
}
if ( memory_needed < MAX_SIZE_TYPE - ME_MPAGESIZE )
pages = (memory_needed + ME_MPAGESIZE - 1) / ME_MPAGESIZE;
else
pages = memory_needed / ME_MPAGESIZE;
/*
** Lock the LGK segment if requested to do so
*/
if (flag & LOCK_LGK_MEMORY)
me_locked_flag = ME_LOCKED_MASK;
else
me_locked_flag = 0;
me_flags = (me_locked_flag | ME_MSHARED_MASK | ME_IO_MASK |
ME_CREATE_MASK | ME_NOTPERM_MASK | ME_MZERO_MASK);
if (CXnuma_user_rad())
me_flags |= ME_LOCAL_RAD;
STcopy("lglkdata.mem", mem_name);
/*
** In general, we just want to attach to the shared memory and detect if
** we are the first process to do so. However, there are ugly race
** conditions to consider, as well as complications because the shared
** memory may be left around following a system crash.
**
** First we attempt to create the shared memory. Usually it already exists,
** so we check for and handle the case of "already exists".
*/
/*
** (jenjo02)
**
** Restructured to better handle all those ugly race conditions
** which are easily reproduced by running two scripts, one that
** continuously executes "lockstat" while the other is starting
** and stopping Ingres.
**
** For example,
**
** lockstat A acquires and init's the memory
** RCP attaches to "A" memory
** lockstat A terminates normally
** lockstat B attaches to "A" memory, sees that
** "A"s pid is no longer alive, and
** reinitializes the memory, much to
** the RCP's chagrin.
** or (more commonly)
**
** lockstat A acquires and begins to init the mem
** RCP attaches to "A" memory which is
** still being zero-filled by lockstat,
** checks the version number (zero),
** and fails with a E_DMA434 mismatch.
**
** The fix utilizes the mem_ext_sem to synchronize multiple
** processes; if the semaphore hasn't been initialized or
** if mem_version_no is zero, we'll wait one second and retry,
** up to 60 seconds before giving up. This gives the creating
** process time to complete initialization of the memory.
**
** Up to LGK_MAX_PIDS are allowed to attach to the shared
** memory. When a process attaches it sets its PID in the
** first vacant slot in lgk_mem->mem_pid[]; if there are
** no vacant slots, the attach is refused. When the process
** terminates normally by calling LGK_rundown(), it zeroes
** its PID slot.
**
** When attaching to an existing segment, we check if
** there are any live processes still using the memory;
** if so, we can't destroy it (no matter who created it).
** If there are no live processes attached to the memory,
** we destroy and reallocate it (based on current config.dat
** settings).
*/
for ( retries = 0; ;retries++ )
{
LGK_base.lgk_mem_ptr = (PTR)NULL;
/* Give up if unable to get memory in one minute */
#if defined(conf_CLUSTER_BUILD)
if (retries > 1)
#else
if ( retries )
#endif
{
if ( retries < 60 )
PCsleep(1000);
else
{
/* Another process has it blocked way too long */
uleFormat(NULL, E_DMA800_LGKINIT_GETMEM, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 0);
/* Unable to attach allocated shared memory segment. */
return (E_DMA802_LGKINIT_ERROR);
}
}
ret_val = MEget_pages(me_flags,
pages, mem_name, (PTR*)&lgk_mem,
&allocated_pages, sys_err);
if ( mem_exists = ret_val )
{
if (ret_val == ME_ALREADY_EXISTS)
{
ret_val = MEget_pages((me_locked_flag |
ME_MSHARED_MASK | ME_IO_MASK),
pages, mem_name, (PTR*)&lgk_mem,
&allocated_pages, sys_err);
#if defined(conf_CLUSTER_BUILD)
if (ret_val && !retries)
continue; /* try one more time */
#endif
}
if (ret_val)
{
uleFormat(NULL, ret_val, sys_err,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 0);
uleFormat(NULL, E_DMA800_LGKINIT_GETMEM, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 0);
/* Unable to attach allocated shared memory segment. */
return (E_DMA802_LGKINIT_ERROR);
}
}
else if (flag & LOCK_LGK_MUST_ATTACH)
{
/* Do not use the shared segment you just allocated */
MEfree_pages((PTR)lgk_mem, allocated_pages, sys_err);
return (E_DMA812_LGK_NO_SEGMENT);
}
size = allocated_pages * ME_MPAGESIZE;
/* Expose this process to the memory */
LGK_base.lgk_mem_ptr = (PTR)lgk_mem;
if ( mem_exists )
{
/*
** Memory exists.
**
** Try to acquire the semaphore. If it's
** uninitialzed, retry from the top.
**
** If the version is zero, then another
** process is initializing the memory;
** keep retrying until the version is
** filled in.
**
*/
if ( ret_val = CSp_semaphore(1, &lgk_mem->mem_ext_sem) )
{
if ( ret_val != E_CS000A_NO_SEMAPHORE )
{
uleFormat(NULL, ret_val, sys_err,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 0);
ret_val = E_DMA802_LGKINIT_ERROR;
break;
}
continue;
}
/* Retry if still being init'd by another process */
if ( !lgk_mem->mem_version_no )
{
CSv_semaphore(&lgk_mem->mem_ext_sem);
continue;
}
/*
** Check pids which appear to be attached to
** the memory:
**
** If any process is still alive, then we
** assume the memory is consistent and use it.
**
** If a process is now dead, it terminated
** without going through LGK_rundown
** to zero its PID slot, zero it now.
**
** If there are no live PIDs attached to
** the memory, we destroy and recreate it.
*/
my_pid_slot = (PID*)NULL;
attached = 0;
for ( i = 0; i < LGK_MAX_PIDS; i++ )
{
if ( lgk_mem->mem_pid[i] &&
PCis_alive(lgk_mem->mem_pid[i]) )
{
attached++;
}
else
{
/* Vacate the slot */
if (lgk_mem->mem_pid[i])
{
uleFormat(NULL, E_DMA499_DEAD_PROCESS_INFO, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 2,
0, lgk_mem->mem_pid[i],
0, lgk_mem->mem_info[i].info_txt);
}
lgk_mem->mem_pid[i] = (PID)0;
lgk_mem->mem_info[i].info_txt[0] = EOS;
/* Use first vacant slot for this process */
if ( !my_pid_slot )
{
my_pid_slot = &lgk_mem->mem_pid[i];
LGK_base.lgk_pid_slot = i;
}
}
/* Quit when both questions answered */
if ( attached && my_pid_slot )
break;
}
/* If no living pids attached, destroy/reallocate */
if ( !attached )
{
CSv_semaphore(&lgk_mem->mem_ext_sem);
if ( LGK_destroy(allocated_pages, sys_err) )
{
ret_val = E_DMA802_LGKINIT_ERROR;
break;
}
continue;
}
/* All attached pids alive? */
if ( !my_pid_slot )
{
/* ... then there's no room for this process */
uleFormat(NULL, E_DMA80A_LGK_ATTACH_LIMIT, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 1,
0, attached);
ret_val = E_DMA802_LGKINIT_ERROR;
}
else if (lgk_mem->mem_version_no != LGK_MEM_VERSION_CURRENT)
{
uleFormat(NULL, E_DMA434_LGK_VERSION_MISMATCH, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 2,
0, lgk_mem->mem_version_no, 0, LGK_MEM_VERSION_CURRENT);
ret_val = E_DMA435_WRONG_LGKMEM_VERSION;
}
/*
** Don't allow mixed connections of MT/non-MT processes.
** Among other things, the mutexing mechanisms are
** incompatible!
*/
else if ( (CS_is_mt() && (lgk_mem->mem_status & LGK_IS_MT) == 0) ||
(!CS_is_mt() && lgk_mem->mem_status & LGK_IS_MT) )
{
uleFormat(NULL, E_DMA811_LGK_MT_MISMATCH, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 2,
0, (lgk_mem->mem_status & LGK_IS_MT) ? "OS"
: "INTERNAL",
0, (CS_is_mt()) ? "OS"
: "INTERNAL");
ret_val = E_DMA802_LGKINIT_ERROR;
}
else
{
/*
** CX memory (if any) will lie immediately past LGK header.
*/
pcxmem = (PTR)(lgk_mem + 1);
pcxmem = (PTR)ME_ALIGN_MACRO(pcxmem, sizeof(ALIGN_RESTRICT));
LGK_base.lgk_lkd_ptr = (char *)LGK_base.lgk_mem_ptr +
lgk_mem->mem_lkd;
LGK_base.lgk_lgd_ptr = (char *)LGK_base.lgk_mem_ptr +
lgk_mem->mem_lgd;
/* Stuff our pid in first vacant slot */
*my_pid_slot = LGK_my_pid;
STlcopy(lgk_info, lgk_mem->mem_info[i].info_txt, LGK_INFO_SIZE-1);
}
#if defined(VMS) || defined(UNIX)
/* set up pointers to reference the uuid mutex and last time
* variable */
if (!ID_uuid_sem_ptr)
ID_uuid_sem_ptr=&lgk_mem->id_uuid_sem;
if (!ID_uuid_last_time_ptr)
ID_uuid_last_time_ptr=&lgk_mem->uuid_last_time;
if (!ID_uuid_last_cnt_ptr)
ID_uuid_last_cnt_ptr=&lgk_mem->uuid_last_cnt;
#endif
CSv_semaphore(&lgk_mem->mem_ext_sem);
}
else
{
/* Memory did not exist */
/* Zero the version to keep other processes out */
lgk_mem->mem_version_no = 0;
#if defined(VMS) || defined(UNIX)
/* set up the uuid mutex and last time pointers to
* reference the objects in shared memory */
{
STATUS id_stat;
ID_uuid_sem_ptr=&lgk_mem->id_uuid_sem;
ID_uuid_last_time_ptr=&lgk_mem->uuid_last_time;
ID_uuid_last_cnt_ptr=&lgk_mem->uuid_last_cnt;
*ID_uuid_last_cnt_ptr=0;
ID_UUID_SEM_INIT(ID_uuid_sem_ptr,CS_SEM_MULTI,"uuid sem",
&id_stat);
}
#endif
/* ... then initialize the mutex */
CSw_semaphore(&lgk_mem->mem_ext_sem, CS_SEM_MULTI,
"LGK mem ext sem" );
/* Record if memory created for MT or not */
if ( CS_is_mt() )
lgk_mem->mem_status = LGK_IS_MT;
/*
** memory is as follows:
**
** -----------------------------------------------------------|
** | LGK_MEM struct (keep track of this mem) |
** | |
** -----------------------------------------------------------|
** | If a clustered installation memory reserved for CX |
** | |
** ------------------------------------------------------------
** | LKD - database of info for lk system |
** | |
** ------------------------------------------------------------
** | LGD - database of info for lg system |
** | |
** ------------------------------------------------------------
** | memory manipulated by LGKm_* routines for structures used |
** | by both the lk and lg systems. |
** | |
** ------------------------------------------------------------
*/
/* put the LGK_MEM struct at head of segment leaving ptr pointing
** at next aligned piece of memory
*/
/*
** CX memory (if any) will lie immediately past LGK header.
*/
pcxmem = (PTR)(lgk_mem + 1);
pcxmem = (PTR)ME_ALIGN_MACRO(pcxmem, sizeof(ALIGN_RESTRICT));
LGK_base.lgk_lkd_ptr = pcxmem + cxmemreq;
LGK_base.lgk_lkd_ptr = (PTR) ME_ALIGN_MACRO(LGK_base.lgk_lkd_ptr,
sizeof(ALIGN_RESTRICT));
lgk_mem->mem_lkd = (i4)((char *)LGK_base.lgk_lkd_ptr -
(char *)LGK_base.lgk_mem_ptr);
LGK_base.lgk_lgd_ptr = (PTR) ((char *) LGK_base.lgk_lkd_ptr +
sizeof(LKD));
LGK_base.lgk_lgd_ptr = (PTR) ME_ALIGN_MACRO(LGK_base.lgk_lgd_ptr,
sizeof(ALIGN_RESTRICT));
lgk_mem->mem_lgd = (i4)((char *)LGK_base.lgk_lgd_ptr -
(char *)LGK_base.lgk_mem_ptr);
/* now initialize the rest of memory for allocation */
/* how much memory is left? */
ptr = ((char *)LGK_base.lgk_lgd_ptr + sizeof(LGD));
memleft = size - (((char *) ptr) - ((char *) LGK_base.lgk_mem_ptr));
if ( (ret_val = lgkm_initialize_mem(memleft, ptr)) == OK &&
(ret_val = LG_meminit(sys_err)) == OK &&
(ret_val = LK_meminit(sys_err)) == OK )
{
/* Clear array of attached pids and pid info */
for ( i = 0; i < LGK_MAX_PIDS; i++ )
{
lgk_mem->mem_pid[i] = (PID)0;
lgk_mem->mem_info[i].info_txt[0] = EOS;
}
/* Set the creator pid */
LGK_base.lgk_pid_slot = 0;
lgk_mem->mem_creator_pid = LGK_my_pid;
/* Set the version, releasing other processes */
lgk_mem->mem_version_no = LGK_MEM_VERSION_CURRENT;
}
else
{
uleFormat(NULL, ret_val, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 0);
ret_val = E_DMA802_LGKINIT_ERROR;
/* Destroy the shared memory */
LGK_destroy(allocated_pages, sys_err);
}
}
if ( ret_val == OK )
{
PCatexit(LGK_rundown);
if ( clustered )
{
/*
** Perform preliminary cluster connection and CX memory init.
*/
/* Get installation code */
NMgtAt("II_INSTALLATION", &nm_string);
if ( nm_string )
{
instid[0] = *(nm_string);
instid[1] = *(nm_string+1);
}
else
{
instid[0] = 'A';
instid[1] = 'A';
}
instid[2] = '\0';
ret_val = CXinitialize( instid, pcxmem, flag & LGK_IS_CSP );
if ( ret_val )
{
/* Report error returned from CX */
uleFormat(NULL, ret_val, (CL_ERR_DESC *)NULL,
ULE_LOG, NULL, NULL, 0, NULL, &err_code, 0 );
break;
}
}
#ifdef VMS
{
static $EXHDEF exit_block;
i4 ctrl_y_mask = 0x02000000;
/*
** On VMS, programs like the dmfjsp and logstat run as images in
** the shell process. That is, the system doesn't start and stop
** a process for each invocation of the program, it just starts
** and stops an image in the same process. This means that if
** the program should die, the image may be rundown but the process
** will remain, which means that the check-dead threads of other
** processes in the installation will not feel that they need to
** rundown this process, since it's still alive.
**
** By declaring an exit handler, which will get a chance to run
** even if PCexit isn't called, we improve our chances of getting
** to perform rundown processing if we should die unexpectedly.
**
** Furthermore, we ask DCL to disable its ^Y processing, which
** lessens the chance that the user will interrupt us while we
** are holding the semaphore.
*/
exit_block.exh$g_func = LGK_rundown;
exit_block.exh$l_argcount = 1;
exit_block.exh$gl_value = &exit_block.exh$l_status;
if (sys$dclexh(&exit_block) != SS$_NORMAL)
ret_val = FAIL;
lib$disable_ctrl(&ctrl_y_mask, 0);
}
#endif
}
break;
}
if ( ret_val )
LGK_base.lgk_mem_ptr = NULL;
return(ret_val);
}
/*{
** Name: CK_subst - build a CK command from template and requirements
**
** Description:
** This function will search a CK command template file for
** a line meeting the requirements of the inputs and will substitute
** various esacpe sequences with other strings such as file names.
**
** Based on a II_subst of the 5.0 UNIX CL.
**
** Inputs:
** comlen length of cline space
** oper operation - one of 'B'egin, 'E'nd, 'W'ork
** dev device type - one of 'T'ape, 'D'isk
** dir direction - one of 'S'ave, 'R'estore
** type type (device type) 0 for disk, 1 for tape
** locnum location number (sequence or quantity)
** di_l_path length of di path string
** di_path di path string
** ckp_l_path length of checkpoint path string
** ckp_path checkpoint path string
** ckp_l_file length of checkpoint file string
** ckp_file checkpoint file string
**
** Outputs:
** cline space for generated command
**
** Returns:
** CK_FILENOTFOUND template file can't be found
** E_DB_OK
**
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 27-oct-88 (anton)
** Created.
** 16-may-90 (walt)
** Return CK_FILENOTFOUND if the template file (cktmpl.def) can't
** be opened.
** 23-may-1994 (bryanp)
** Modified Walt's 16-may-90 fix to use CK_TEMPLATE_MISSING, rather
** than CK_FILENOTFOUND, since CK_TEMPLATE_MISSING is a more
** specific, and therefore hopefully more useful, error message.
** 03-jan-1995 (dougb)
** Cross-integrate Unix change 415365:
** 02-dec-1994 (andyw)
** Check on granularity for partial backup
*/
STATUS
CK_subst(
char *cline,
i4 comlen,
char oper,
char dev,
char dir,
u_i4 type,
u_i4 locnum,
u_i4 di_l_path,
char *di_path,
u_i4 ckp_l_path,
char *ckp_path,
u_i4 ckp_l_file,
char *ckp_file)
{
STATUS ret_val = OK;
auto LOCATION loc;
auto char *s;
auto FILE *fp;
auto char *cp;
char *command;
command = MEreqmem(0, comlen, TRUE, &ret_val);
if (!ret_val)
{
NMgtAt("II_CKTMPL_FILE", &s);
if (s == NULL || *s == EOS)
{
ret_val = NMf_open("r", "cktmpl.def", &fp);
}
else
{
LOfroms( PATH & FILENAME, s, &loc );
ret_val = SIopen( &loc, "r", &fp);
}
if (ret_val)
{
ret_val = CK_TEMPLATE_MISSING;
}
}
/* find command line - skip comments and blank lines */
if (!ret_val)
{
while ((ret_val = SIgetrec(command, comlen, fp)) == OK)
{
if (*command == '\n')
{
continue;
}
if (command[0] == oper
&& (command[1] == dir || command[1] == 'E')
&& (command[2] == dev || command[2] == 'E')
&& (command[3] == 'D' || command[3] == 'E')
&& command[4] == ':')
{
break;
}
}
}
_VOID_ SIclose(fp);
if (!ret_val)
{
/* found the line - do the substitution */
s = command + 5;
cp = cline;
while (*s != '\n')
{
if (*s == '%')
{
switch (*++s)
{
case '%':
*cp++ = '%';
break;
case 'D':
CK_lfill(&cp, di_l_path, di_path);
break;
case 'C':
CK_lfill(&cp, ckp_l_path, ckp_path);
break;
case 'F':
CK_lfill(&cp, ckp_l_file, ckp_file);
break;
case 'A':
CK_lfill(&cp, ckp_l_path, ckp_path);
# ifdef UNIX
*cp++ = '/';
# endif
CK_lfill(&cp, ckp_l_file, ckp_file);
break;
case 'T':
*cp++ = type ? '1' : '0';
break;
case 'N':
CVna(locnum, cp);
while (*cp)
cp++;
break;
default:
*cp++ = '%';
*cp++ = *s;
}
++s;
}
else
{
*cp++ = *s++;
}
}
*cp = EOS;
}
# ifdef xDEBUG
TRdisplay("CK_subst %c %c %c: %s\n", oper, dir, dev, cline);
# endif
return(ret_val);
}
/* Name: adu_getconverter - Obtains the name of converter mapping file
** to use for unicode coercion.
** Description:
**
** To obtain the mapping file to be used for carrying out unicode-local
** character conversion. The following mechanism is followed:
**
** 1. Check symbol table for user defined converter setting
** II_UNICODE_CONVERTER. If set then return this setting
** 2. If the variable is not set then
** 2.a Get the platform character set
** 2.b Read the aliasmaptbl file.
** 2.c Search the alias file for platform charset.
** 3. If still not found then find the II_CHARSETxx value
** for ingres installation and search the alias file for
** this value.
** 4. If none of these attempts succeed then return default
** with a warning to the errorlog if this happens
**
** Input:
** converter - Place holder for the output string,
** It is assumed that the area is at least MAX_LOC
** chars in size.
** Output:
** converter - Pointer to string where the output
** converter name is stored.
** History:
**
** 22-jan-2004 (gupsh01)
** Added.
** 14-Jun-2004 (schka24)
** Safe charset name handling.
*/
STATUS
adu_getconverter(
char *converter)
{
STATUS stat;
char *tptr;
char *env = 0;
char chset[CM_MAXATTRNAME+1];
char pcs[CM_MAXLOCALE+1]; /* platform character set */
char norm_pcs[CM_MAXLOCALE+1];
CL_ERR_DESC syserr;
char *alias_buffer = NULL;
char *bufptr = NULL;
char *buf = NULL;
ADU_ALIAS_MAPPING *aliasmapping;
ADU_ALIAS_DATA *aliasdata;
char *datasize;
SIZE_TYPE filesize = 0;
SIZE_TYPE sizemap = 0;
SIZE_TYPE sizedata = 0;
i4 bytes_read;
char *abufptr;
i4 i = 0;
i4 index = 0;
/* STEP 1 */
NMgtAt(ERx("II_UNICODE_CONVERTER"), &env);
if (env && *env)
{
STlcopy(env, converter, MAX_LOC-1);
return OK;
}
/* STEP 2 */
stat = CM_getcharset(pcs);
if (CMopen_col("aliasmaptbl", &syserr, CM_UCHARMAPS_LOC) != OK)
{
/* return an ERROR if we are unable to open the file */
return FAIL;
}
/* initialize buf to help read from the aliasmaptbl file */
buf = MEreqmem(0, COL_BLOCK, TRUE, &stat);
if (buf == NULL || stat != OK)
{
CMclose_col(&syserr, CM_UCHARMAPS_LOC);
return (FAIL);
}
/* First file buffer has size information. */
stat = CMread_col(buf, &syserr);
if (stat != OK)
{
MEfree((char *)buf);
CMclose_col(&syserr, CM_UCHARMAPS_LOC);
return (FAIL);
}
tptr = buf;
bytes_read = COL_BLOCK;
/* filesize is the first entry of the map file */
filesize = *(SIZE_TYPE *) buf;
tptr += sizeof(SIZE_TYPE);
tptr = ME_ALIGN_MACRO(tptr, sizeof(PTR));
/* allocate working space for the data */
alias_buffer = (char *)MEreqmem(0, filesize, TRUE, &stat);
if (alias_buffer == NULL || stat != OK)
{
CMclose_col(&syserr, CM_UCHARMAPS_LOC);
return (FAIL);
}
abufptr = alias_buffer;
MEcopy (buf, COL_BLOCK, abufptr);
abufptr += COL_BLOCK;
/* Read the file till it is read completely */
for ( ;bytes_read < filesize;)
{
stat = CMread_col(buf, &syserr);
if (stat != OK)
{
MEfree((char *)buf);
MEfree((char *)alias_buffer);
CMclose_col(&syserr, CM_UCHARMAPS_LOC);
return (FAIL);
}
bytes_read += COL_BLOCK;
MEcopy (buf, COL_BLOCK, abufptr);
abufptr += COL_BLOCK;
}
if (bytes_read < filesize)
{
/* we had to exit for some unknown reason */
MEfree((char *)buf);
MEfree((char *)alias_buffer);
CMclose_col(&syserr, CM_UCHARMAPS_LOC);
return (FAIL);
}
tptr = alias_buffer;
tptr += sizeof(SIZE_TYPE);
tptr = ME_ALIGN_MACRO(tptr, sizeof(PTR));
/* Read the size of the MappingArray nodes */
sizemap = *(SIZE_TYPE *) tptr;
tptr += sizeof(SIZE_TYPE);
tptr = ME_ALIGN_MACRO(tptr, sizeof(PTR));
/* initialize buffer for ADU_ALIAS_MAPPING buffer */
aliasmapping = (ADU_ALIAS_MAPPING *) MEreqmem(0, sizemap, TRUE, &stat);
if (aliasmapping == NULL)
{
MEfree((char *)buf);
MEfree((char *)alias_buffer);
CMclose_col(&syserr, CM_UCHARMAPS_LOC);
return (FAIL);
}
/* Copy data for ADU_ALIAS_MAPPING array */
MEcopy(tptr, sizemap, aliasmapping);
tptr += sizemap;
tptr = ME_ALIGN_MACRO(tptr, sizeof(PTR));
/* Get size for the aliasdata */
sizedata = *(SIZE_TYPE *) tptr;
tptr += sizeof(SIZE_TYPE);
tptr = ME_ALIGN_MACRO(tptr, sizeof(PTR));
/* Initialize buffer for ADU_ALIAS_MAPPING buffer */
aliasdata = (ADU_ALIAS_DATA *) MEreqmem(0, sizedata, TRUE, &stat);
if (aliasdata == NULL)
{
MEfree((char *)buf);
MEfree((char *)alias_buffer);
MEfree((char *)aliasmapping);
CMclose_col(&syserr, CM_UCHARMAPS_LOC);
return (FAIL);
}
/* Copy the ADU_ALIAS_DATA array */
MEcopy(tptr, sizedata, aliasdata);
tptr += sizedata;
tptr = ME_ALIGN_MACRO(tptr, sizeof(PTR));
/* Close the "aliasmaptbl" file */
CMclose_col(&syserr, CM_UCHARMAPS_LOC);
/* Normalize pcs */
adu_csnormalize (pcs, STlength(pcs), norm_pcs);
/* Retrieve the pcs value */
for (i=0; i < sizedata/sizeof(ADU_ALIAS_DATA); i++)
{
if ((STcompare (aliasdata[i].aliasNameNorm, norm_pcs)) == 0)
{
index = aliasdata[i].aliasMapId;
/* found */
STcopy (aliasmapping[index].mapping_id,
converter);
/* cleanup */
MEfree((char *)buf);
MEfree((char *)alias_buffer);
MEfree((char *)aliasmapping);
MEfree((char *)aliasdata);
return (OK);
}
}
/* STEP 3 */
/* Obtain Ingres characterset */
STcopy("default", converter);
CMget_charset_name(&chset[0]);
if (STcasecmp(chset, "UTF8") != 0)
{
/* search maptable for env */
for (i=0; i < sizedata/sizeof(ADU_ALIAS_DATA); i++)
{
if ((STcompare (aliasdata[i].aliasNameNorm, norm_pcs)) == 0)
{
index = aliasdata[i].aliasMapId;
/* found */
STcopy (aliasmapping[index].mapping_id, converter);
break;
}
}
}
/* cleanup */
MEfree((char *)buf);
MEfree((char *)alias_buffer);
MEfree((char *)aliasmapping);
MEfree((char *)aliasdata);
/* FIXME warning or error if still "default" ? */
return (OK);
}
STATUS
ERsend(i4 flag, char *message, i4 msg_length, CL_ERR_DESC *err_code)
{
# ifdef NT_GENERIC
static bool er_init = FALSE;
static bool is_w95 = FALSE;
# else /* !NT_GENERIC */
static int er_ifi = -2;
static int ar_ifi = -2;
# endif /* !NT_GENERIC */
STATUS status;
char tmp_buf[ER_MAX_LEN];
char* logmsg = message;
/* Check for bad paramters. */
CL_CLEAR_ERR( err_code );
if ((message == 0 || msg_length == 0) && flag != ER_AUDIT_MSG)
return (ER_BADPARAM);
if ((flag != ER_ERROR_MSG) && (flag != ER_AUDIT_MSG) &&
( flag != ER_OPER_MSG))
return (ER_BADPARAM);
# ifndef NT_GENERIC
if (flag & ER_AUDIT_MSG)
{
key_t msg_key;
char *ipc_number;
struct
{
long mtype;
char mtext[ER_MAX_LEN];
} msg;
if (ar_ifi == -2)
{
NMgtAt("II_AUDIT_IPC", &ipc_number);
if (ipc_number && ipc_number[0])
{
CVal(ipc_number, &msg_key);
ar_ifi = msgget(msg_key, 0);
if (ar_ifi == -1)
{
SETCLERR(err_code, 0, ER_open);
return(ER_NO_AUDIT);
}
}
else
{
SETCLERR(err_code, 0, ER_open);
return(ER_NO_AUDIT);
}
}
/* Handle special case to connect only but not send message. */
if (msg_length == 0 && message == 0)
return (OK);
MEcopy(message, msg_length, msg.mtext);
msg.mtype = 1;
if (msgsnd(ar_ifi, &msg, msg_length, 0))
{
SETCLERR(err_code, 0, ER_open);
return(ER_BADSEND);
}
return (OK);
}
else
# endif /* ! NT_GENERIC */
if (flag & ER_OPER_MSG)
{
char hostname[GL_MAXNAME];
STATUS status;
message[msg_length] = EOS;
TRdisplay("ER Operator:\"%s\"\n",message);
if (!ERsysinit)
ERinitsyslog();
# ifdef NT_GENERIC
{
wchar_t *wmessage = NULL;
/*
** Update the ReportEvent to report information in the event log.
*/
if ( ReportEvent( EventLog,
(WORD) EVENTLOG_INFORMATION_TYPE,
(WORD) 0, /* event category */
(DWORD) I_ING_INFO, /* event identifier */
(PSID) NULL,
(WORD) 1, /* number of strings */
(DWORD) 0,
&message,
NULL ) == FALSE)
status = GetLastError();
if ( !er_init )
{
char VersionString[256];
FUNC_EXTERN BOOL GVosvers(char *OSVersionString);
GVosvers(VersionString);
is_w95 = ( STstrindex(VersionString, "Microsoft Windows 9",
0, FALSE) != NULL ) ? TRUE : FALSE;
if ( !is_w95 ) /* netapi32 only on NT */
{
HANDLE hDll;
if ((hDll = LoadLibrary(TEXT("netapi32.dll"))) != NULL)
{
pNetMessageNameAdd =
(NET_API_STATUS (*)(LPCWSTR,LPCWSTR))
GetProcAddress(hDll, TEXT("NetMessageNameAdd"));
pNetMessageNameDel =
(NET_API_STATUS (*)(LPCWSTR,LPCWSTR))
GetProcAddress(hDll, TEXT("NetMessageNameDel"));
pNetMessageBufferSend =
(NET_API_STATUS (*)(LPCWSTR,LPCWSTR,LPCWSTR,LPBYTE,DWORD))
GetProcAddress(hDll, TEXT("NetMessageBufferSend"));
}
/* if any problem, pretend we don't support it */
if ( pNetMessageNameAdd == NULL ||
pNetMessageNameDel == NULL ||
pNetMessageBufferSend == NULL )
is_w95 = TRUE;
}
}
if ( !is_w95 )
{
/*
** Now, send the message to the server console,
** putting up a message box (if the messenger service
** is running. Everything must be in Unicode.
*/
if ( whostname[0] == 0 )
{
unsigned int len = sizeof(hostname);
/*
** get the hostname in Unicode format for use
** by messenger service
*/
GetComputerName( (char *)hostname, &len );
MultiByteToWideChar( GetACP(), 0,
hostname, sizeof(hostname),
whostname, sizeof(whostname) );
}
/* initialize the messenger service */
status = (*pNetMessageNameAdd)( whostname, msgname );
if ( status != NERR_Success )
status = GetLastError();
/* Allocate a buffer for the Unicode */
wmessage = (wchar_t *) MEreqmem( 0, msg_length * sizeof(wchar_t),
TRUE, &status );
if ( wmessage )
{
/* copy the message to the Unicode buffer */
MultiByteToWideChar( GetACP(), 0,
message, msg_length,
wmessage, msg_length * sizeof(wchar_t) );
status = (*pNetMessageBufferSend)( whostname,
msgname,
NULL,
(LPBYTE) wmessage,
msg_length*sizeof(wchar_t) );
if ( status != NERR_Success )
status = GetLastError();
MEfree( (PTR)wmessage );
}
/* re-initialize the messenger service */
status = (*pNetMessageNameDel)( whostname, msgname );
if ( status != NERR_Success )
status = GetLastError();
}
}
# elif defined(OS_THREADS_USED) && defined(any_aix)
syslog_r( LOG_ALERT|LOG_ERR, message );
# else
syslog( LOG_ALERT|LOG_ERR, message );
# endif /* NT_GENERIC */
}
if (flag & ER_OPER_MSG)
{
i4 msglen = 0;
char* host = PMhost();
MEfill( ER_MAX_LEN, 0, tmp_buf );
/*
** Format the message string for the event log. As the source is
** not known a fixed string of INGSYSLOG is used.
*/
TRformat( NULL, 0, tmp_buf, ER_MAX_LEN - 1,
"%8.8t::[INGSYSLOG , 00000000]: %@ ", STlength(host),
host );
msglen = STlength(tmp_buf);
STcat( tmp_buf, message ); /* append original message */
msg_length += msglen;
logmsg = tmp_buf;
}
status = ERlog( logmsg, msg_length, err_code );
return( status );
}
int
main( int argc, char **argv )
{
CL_ERR_DESC err;
PTR handle;
PTR handle1;
PTR handle2;
PTR addr;
STATUS status;
int (*int_fcn)();
char *(*str_fcn)();
int int_ret;
char *cp_ret;
LOCATION srcfile;
char srcbuf[MAX_LOC+1];
LOCATION objfile;
char objbuf[MAX_LOC+1];
bool pristine;
LOCATION modloc;
char modbuf[MAX_LOC+1];
LOCATION dlloc;
char dlbuf[MAX_LOC+1];
LOCATION errloc;
char errbuf[MAX_LOC+1];
LOCATION nameloc;
char namebuf[MAX_LOC+1];
char *nameptr;
char *parms[2];
i4 flags;
STATUS mod2status = OK;
/* find the working directory */
NMgtAt( "IIDLDIR", &cp_ret );
if ( cp_ret == NULL || *cp_ret == EOS )
{
SIprintf( "%sDLDIR not set\n", SystemVarPrefix );
PCexit( 1 );
}
/* save the directory name into a larger buffer for LO */
STcopy( cp_ret, srcbuf );
/* initialize a LOCATION with the directory */
LOfroms( PATH, srcbuf, &srcfile );
/* initialize the object file LOCATION with same directory */
LOcopy( &srcfile, objbuf, &objfile );
LOcopy( &srcfile, modbuf, &modloc );
LOcopy( &srcfile, dlbuf, &dlloc );
LOcopy( &srcfile, errbuf, &errloc );
/* add filenames to LOCATION */
LOfstfile( srcs[0], &srcfile );
LOfstfile( objs[0], &objfile );
LOfstfile( erroutput, &errloc );
/* compile with error */
#ifdef NT_GENERIC
parms[0] = "-g";
#else NT_GENERIC
parms[0] = "-Zi";
#endif NT_GENERIC
parms[1] = NULL;
status = UTcompile_ex( &srcfile, &objfile, &errloc, parms, FALSE, &pristine, &err );
if ( status != OK )
{
SIprintf( "Compile error test returns: " );
if ( status == UT_CO_FILE )
SIprintf(
"\n utcom.def file not found or II_COMPILE_DEF not set\n" );
else if ( status == UT_CO_IN_NOT )
SIprintf( "source file not found.\n" );
else
SIprintf( "%d\n", status );
SIprintf( "Contents of error file:\n" );
SIprintf( "------------------------------------------------------\n" );
SIcat( &errloc, stdout );
SIprintf( "------------------------------------------------------\n" );
SIprintf( "\n" );
}
else
{
SIprintf( "Test of compile error returned OK.\n" );
SIprintf( "Contents of error file:\n" );
SIprintf( "------------------------------------------------------\n" );
SIcat( &errloc, stdout );
SIprintf( "------------------------------------------------------\n" );
SIprintf( "\n" );
}
/* add filenames to LOCATION */
LOfstfile( srcs[0], &srcfile );
LOfstfile( objs[0], &objfile );
/* do a good compile */
#ifdef NT_GENERIC
parms[0] = "-Zi";
#else NT_GENERIC
parms[0] = "-g";
#endif NT_GENERIC
status = UTcompile_ex( &srcfile, &objfile, NULL, parms, FALSE, &pristine, &err );
if ( status != OK )
{
SIprintf( "Error compiling module: %d\n", status );
PCexit( 1 );
}
LOfstfile( srcs1[0], &srcfile );
LOfstfile( objs1[0], &objfile );
status = UTcompile( &srcfile, &objfile, NULL, &pristine, &err );
if ( status != OK )
{
SIprintf( "Error compiling module1\n" );
PCexit( 1 );
}
LOfstfile( srcs2[0], &srcfile );
LOfstfile( objs2[0], &objfile );
mod2status = UTcompile( &srcfile, &objfile, NULL, &pristine, &err );
if ( mod2status != OK )
{
SIprintf( "Error compiling module2\n" );
SIprintf( "This is not an error if C++ is not installed.\n" );
SIprintf( "Skipping further processing of this module\n\n" );
}
/* link first module into shared library */
if ( DLcreate( NULL, NULL, module, objs, NULL, lookups, &err) != OK )
{
SIprintf( "Error creating module\n" );
PCexit( 1 );
}
if ( DLcreate_loc( NULL, NULL, module1, objs1, NULL, lookups1,
&dlloc, NULL, &errloc, FALSE, NULL, &err) != OK )
{
SIprintf( "Error creating module1\n" );
PCexit( 1 );
}
SIprintf( "Contents of DLcreate_loc() error file for module1:\n" );
SIprintf( "------------------------------------------------------\n" );
SIcat( &errloc, stdout );
SIprintf( "------------------------------------------------------\n" );
SIprintf( "\n" );
if ( mod2status == OK )
{
if ( DLcreate_loc( NULL, NULL, module2, objs2, NULL, lookups2,
&dlloc, NULL, &errloc, FALSE, "C++", &err) != OK )
{
SIprintf( "Error creating module2\n" );
PCexit( 1 );
}
SIprintf( "Contents of DLcreate_loc() error file for module2:\n" );
SIprintf( "------------------------------------------------------\n" );
SIcat( &errloc, stdout );
SIprintf( "------------------------------------------------------\n" );
SIprintf( "\n" );
}
STcopy( module1, namebuf );
LOfroms( FILENAME, namebuf, &nameloc );
DLconstructloc( &nameloc, namebuf, &nameloc, &err );
LOtos( &nameloc, &nameptr );
SIprintf( "Full path for %s is \"%s\"\n", module1, nameptr );
LOcopy( &dlloc, namebuf, &nameloc );
LOfstfile( module, &nameloc );
DLconstructloc( &nameloc, namebuf, &nameloc, &err);
LOtos( &nameloc, &nameptr );
SIprintf( "Full path for %s is \"%s\"\n", module, nameptr );
/* test an error */
SIprintf( "Testing DLprepare of non-existant module.\n" );
if ( DLprepare((char *)NULL, "XXX", lookups, &handle, &err) == OK )
{
SIprintf( "Error: returned success, should be failure.\n" );
PCexit( 1 );
}
/* load the modules into the executable */
SIprintf( "Now loading the real modules.\n" );
if ( DLprepare((char *)NULL, module, lookups, &handle, &err) != OK )
{
SIprintf( "Error loading module\n" );
PCexit( 1 );
}
if ( mod2status == OK &&
DLprepare((char *)NULL, module2, lookups2, &handle2, &err) != OK )
{
SIprintf( "Error loading module2\n" );
PCexit( 1 );
}
putenv( "IIDLDIR=XXX" );
flags=0;
if ( DLprepare_loc((char *)NULL, module1, lookups1, &dlloc, flags,
&handle1, &err) != OK )
{
SIprintf( "Error loading module1\n" );
PCexit( 1 );
}
/* get the address of a function and test it */
if ( DLbind(handle1, "returns_onehundred", &addr, &err) != OK )
{
/* "returns_onehundred" function isn't there */
DLunload( handle, &err );
PCexit( 1 );
}
int_fcn = (int (*)()) addr;
int_ret = (*int_fcn)();
SIprintf( "\"returns_onehundred\" returns %d\n", int_ret );
if ( int_ret != 100 )
{
/* function didn't correctly return 100 */
PCexit( 1 );
}
if ( mod2status == OK )
{
if ( DLbind(handle2, "returns_ninetynine", &addr, &err) != OK )
{
SIprintf( "Error binding \"returns_ninetynine\"\n" );
/* "returns_ninetynine" function isn't there */
DLunload( handle2, &err );
PCexit( 1 );
}
int_fcn = (int (*)()) addr;
int_ret = (*int_fcn)();
SIprintf( "\"returns_ninetynine\" returns %d\n", int_ret );
if ( int_ret != 99 )
{
/* function didn't correctly return 99 */
PCexit( 1 );
}
}
if ( DLbind(handle, "returns_one", &addr, &err) != OK )
{
/* "returns_one" function isn't there */
DLunload( handle, &err );
PCexit( 1 );
}
int_fcn = (int (*)()) addr;
int_ret = (*int_fcn)();
SIprintf( "\"returns_one\" returns %d\n", int_ret );
if ( int_ret != 1 )
{
/* function didn't correctly return 1 */
PCexit( 1 );
}
if ( DLbind(handle, "returns_zero", &addr, &err) != OK )
{
/* "returns_zero" function isn't there */
DLunload( handle, &err );
PCexit( 1 );
}
int_fcn = (int (*)()) addr;
int_ret = (*int_fcn)();
SIprintf( "\"returns_zero\" returns %d\n", int_ret );
if ( int_ret != 0 )
{
/* function didn't correctly return 0 */
PCexit( 1 );
}
if ( DLbind(handle, "returns_minus_one", &addr, &err) != OK )
{
/* "returns_minus_one" function isn't there */
DLunload( handle, &err );
PCexit( 1 );
}
int_fcn = (int (*)()) addr;
int_ret = (*int_fcn)();
SIprintf( "\"returns_minus_one\" returns %d\n", int_ret );
if ( int_ret != -1 )
{
/* function didn't correctly return -1 */
PCexit( 1 );
}
if ( DLbind(handle, "returns_string", &addr, &err) != OK )
{
/* "returns_string" function isn't there */
DLunload( handle, &err );
PCexit( 1 );
}
str_fcn = (char *(*)()) addr;
cp_ret = (*str_fcn)();
SIprintf( "\"returns_string\" returns \"%s\"\n", cp_ret );
if ( STcompare(cp_ret, "String") != OK )
{
/* function didn't correctly return "String" */
PCexit( 1 );
}
/* functions were called successfully, now unload the modules */
if ( DLunload( handle, &err ) != OK )
{
SIprintf( "Error unloading module.\n" );
PCexit( 1 );
}
if ( DLunload( handle1, &err ) != OK )
{
SIprintf( "Error unloading module.\n" );
PCexit( 1 );
}
if ( mod2status == OK &&
DLunload( handle2, &err ) != OK )
{
SIprintf( "Error unloading module2.\n" );
PCexit( 1 );
}
if ( DLdelete_loc( module1, &dlloc, &err ) != OK )
{
SIprintf( "Error deleting module1.\n" );
PCexit( 1 );
}
SIprintf( "Successfully executed.\n" );
PCexit( 0 );
}
static STATUS
initialize( i4 argc, char **argv )
{
CL_ERR_DESC cl_err;
char *instance = ERx("*");
char *env;
char name[ 16 ];
i4 i;
GCD_global.language = 1;
MHsrand( TMsecs() );
for( i = 1; i < argc; i++ )
if ( ! STbcompare( argv[i], 0, ERx("-instance"), 9, TRUE ) )
{
if ( argv[i][9] == ERx('=') && argv[i][10] != EOS )
instance = &argv[i][10];
else if ( argv[i][9] == EOS && (i + 1) < argc )
instance = argv[++i];
break;
}
NMgtAt( ERx("II_INSTALLATION"), &env );
STprintf( name, ERx("II_CHARSET%s"), (env && *env) ? env : "" );
NMgtAt( name, &env );
if ( ! env || ! *env || STlength(env) > CM_MAXATTRNAME)
{
switch( CMgetDefCS() )
{
#if ( !defined(UNIX) && !defined(VMS) )
case CM_IBM : env = "IBMPC850"; break;
#endif
case CM_DECMULTI : env = "DECMULTI"; break;
default : env = "ISO88591"; break;
}
}
GCD_global.charset = STalloc( env );
CVupper( GCD_global.charset );
gcu_read_cset( gcd_cset_id );
if ( CMset_attr( GCD_global.charset, &cl_err) != OK )
{
gcu_erlog( 0, GCD_global.language,
E_GC0105_GCN_CHAR_INIT, NULL, 0, NULL );
return( E_GC0105_GCN_CHAR_INIT );
}
PMinit();
switch( PMload( (LOCATION *)NULL, (PM_ERR_FUNC *)NULL ) )
{
case OK: break;
case PM_FILE_BAD:
gcu_erlog( 0, GCD_global.language,
E_GC003D_BAD_PMFILE, NULL, 0, NULL );
return( E_GC003D_BAD_PMFILE );
break;
default:
gcu_erlog( 0, GCD_global.language,
E_GC003E_PMLOAD_ERR, NULL, 0, NULL );
return( E_GC003E_PMLOAD_ERR );
break;
}
PMsetDefault( 0, SystemCfgPrefix );
PMsetDefault( 1, PMhost() );
PMsetDefault( 2, ERx("gcd") );
PMsetDefault( 3, instance );
gcd_tl_services[0] = &gcd_dmtl_service;
gcd_tl_services[1] = &gcd_jctl_service;
GCD_global.tl_services = gcd_tl_services;
GCD_global.tl_srvc_cnt = ARR_SIZE( gcd_tl_services );
QUinit( &GCD_global.pib_q );
QUinit( &GCD_global.rcb_q );
QUinit( &GCD_global.ccb_q );
QUinit( &GCD_global.ccb_free );
for( i = 0; i < ARR_SIZE( GCD_global.cib_free ); i++ )
QUinit( &GCD_global.cib_free[ i ] );
env = NULL;
gcu_get_tracesym( NULL, ERx("!.client_max"), &env );
if ( env && *env )
{
i4 count;
if ( CVal( env, &count ) == OK && count > 0 )
GCD_global.client_max = count;
}
env = NULL;
gcu_get_tracesym( NULL, ERx("!.client_timeout"), &env );
if ( env && *env )
{
i4 timeout;
if ( CVal( env, &timeout ) == OK && timeout > 0 )
GCD_global.client_idle_limit = timeout * 60; /* Cnvt to seconds */
}
env = NULL;
gcu_get_tracesym( NULL, ERx("!.connect_pool_status"), &env );
if ( env && *env )
{
if ( ! STbcompare( env, 0, "optional", 0, TRUE ) )
GCD_global.client_pooling = TRUE;
if ( GCD_global.client_pooling ||
! STbcompare( env, 0, "on", 0, TRUE ) )
{
env = NULL;
gcu_get_tracesym( NULL, ERx("!.connect_pool_size"), &env );
if ( env && *env ) CVal( env, &GCD_global.pool_max );
env = NULL;
gcu_get_tracesym( NULL, ERx("!.connect_pool_expire"), &env );
if ( env && *env )
{
i4 limit;
if ( CVal( env, &limit ) == OK && limit > 0 )
GCD_global.pool_idle_limit = limit * 60; /* Seconds */
}
}
}
env = NULL;
gcu_get_tracesym( "II_GCD_TRACE", ERx("!.gcd_trace_level"), &env );
if ( env && *env ) CVal( env, &GCD_global.gcd_trace_level );
env = NULL;
gcu_get_tracesym( "II_GCD_LOG", ERx("!.gcd_trace_log"), &env );
if ( env && *env )
TRset_file( TR_F_OPEN, env, (i4)STlength( env ), &cl_err );
return( OK );
}
/*
** Name: PCexec_suid - Execute a command as the ingres user.
**
** Description:
** This procedure works with the Ingres service to run the given
** command as the ingres user. It mimicks the "setuid" bit in UNIX.
**
** Inputs:
** cmdbuf - command to execute as the ingres user
**
** Outputs:
** none
**
** Returns:
** OK
** FAIL
**
** Side Effects:
** none
**
** History:
** 08-jan-1998 (somsa01)
** Created.
** 19-feb-1998 (somsa01)
** We need to pass to the service the current working directory
** as well. (Bug #89006)
** 25-feb-1998 (somsa01)
** We now have an input file for the process' stdin which
** runs through the OpenIngres service.
** 19-jun-1998 (somsa01)
** Use SYSTEM_PRODUCT_NAME for the name of the service.
** 10-jul-1998 (kitch01)
** Bug 91362. If user is 'system' run through OpenIngres service
** despite having access to server shared memory 'system' does not
** have required privilege to access semaphores/mutexes.
** 11-jun-1999 (somsa01)
** If the command is a startup command, then it is always run through
** the Ingres service.
** 03-nov-1999 (somsa01)
** A failure from ControlService() should be treated as a severe
** error which should not let us continue.
** 22-jan-2000 (somsa01)
** Return the exit code of the spawned process. Also, if the
** files exist, truncate them. The service name is now keyed off
** of II_INSTALLATION.
** 05-jun-2000 (somsa01)
** The Ingres installation may be started as the SYSTEM account,
** in which the 'ingres' user will not automatically have access
** to the shared memory segments. Therefore, even if the real
** user is 'ingres', check to see if he has access.
** 24-oct-2000 (somsa01)
** Removed the check on shared memory access. Access to the shared
** memory segment does not necessarily mean that the user running
** the process does not need to run the specified process as the
** Ingres owner. Also, generalized the check of the user with
** IDname_service().
** 18-dec-2000 (somsa01)
** Modified the cases to run the command "as is" without the Ingres
** service.
** 20-mar-2002 (somsa01)
** If all is well, return the exit code of the child process that
** was executed.
** 29-mar-2002 (somsa01)
** Properly return the child process exit code.
** 11-apr-2003 (somsa01)
** While waiting for "pending" to not be set, give some CPU back
** to the OS.
** 29-Jul-2005 (drivi01)
** Allow user to run the command if he/she owns a shared
** segment and ingres is not running as a service.
** 06-Dec-2006 (drivi01)
** Adding support for Vista, Vista requires "Global\" prefix for
** shared objects as well. Replacing calls to GVosvers with
** GVshobj which returns the prefix to shared objects.
** Added PCadjust_SeDebugPrivilege to allow quering of
** System processes.
** 25-Jul-2007 (drivi01)
** On Vista, PCexec_suid is unable to use SE_DEBUG Privilege
** to query process status and retireve its exit code.
** The routine for monitoring a process and retrieving
** its exit code has been moved to Ingres Service.
** 05-Nov-2009 (wanfr01) b122847
** Don't do a PCsleep unless you are waiting for more input
*/
STATUS
PCexec_suid(char *cmdbuf)
{
EX_CONTEXT context;
SERVICE_STATUS ssServiceStatus;
LPSERVICE_STATUS lpssServiceStatus = &ssServiceStatus;
struct SETUID setuid;
DWORD ProcID;
HANDLE SaveStdout;
SECURITY_ATTRIBUTES sa;
CHAR szRealUserID[25] = "";
CHAR *pszRealUserID = szRealUserID;
CHAR szServiceUserID[25] = "";
CHAR *pszServiceUserID = szServiceUserID;
DWORD BytesWritten, BytesRead = 0;
CHAR *inst_id;
CHAR SetuidShmName[64];
CHAR *temp_loc;
CHAR InBuf[256], OutBuf[256];
static CHAR SetuidPipeName[32];
CL_ERR_DESC err_code;
CHAR ServiceName[255];
DWORD ExitCode = 0;
CHAR tchII_INSTALLATION[3];
BOOL SetuidDbCmd = FALSE, ServiceCommand = FALSE;
int i, cmdlen;
char *ObjectPrefix;
u_i4 drType;
SC_HANDLE schSCManager, OpIngSvcHandle;
BOOL bServiceStarted = FALSE;
if (EXdeclare(ex_handler, &context) != OK)
{
EXdelete();
PCexit(FAIL);
}
NMgtAt("II_INSTALLATION", &inst_id);
STcopy(inst_id, tchII_INSTALLATION);
/*
** See if this is a command that MUST be run through the Ingres
** service.
*/
cmdlen = (i4)STlength(cmdbuf);
for (i = 0; ServiceCommands[i] ; i++)
{
if (STbcompare( cmdbuf, cmdlen, ServiceCommands[i],
(i4)STlength(ServiceCommands[i]), FALSE ) == 0)
{
ServiceCommand = TRUE;
break;
}
}
/*
** If the user is the same as the user who started the Ingres
** service, just spawn the command.
*/
if (!ServiceCommand)
{
IDname(&pszRealUserID);
if (!IDname_service(&pszServiceUserID) &&
STcompare(pszServiceUserID, pszRealUserID) == 0 &&
PCisAdmin())
{
/*
** Attempt to just execute the command.
*/
return( PCcmdline( (LOCATION *) NULL, cmdbuf, PC_WAIT,
(LOCATION *) NULL, &err_code) );
}
else
{
/*
** If current user is not the same as service user and ingres is not
** running as a service, check if shared memory segment is owned
** by current user, if user has access to shared segment allow him
** to run the command.
*/
PTR shmem;
SIZE_TYPE allocated_pages=0;
STATUS status;
if((status = MEget_pages(ME_MSHARED_MASK, 1, "lglkdata.mem",
&shmem, &allocated_pages, &err_code)) == OK)
{
STprintf(ServiceName, "%s_Database_%s", SYSTEM_SERVICE_NAME,
tchII_INSTALLATION);
if ((schSCManager = OpenSCManager(NULL, NULL,
SC_MANAGER_CONNECT)) != NULL)
{
if ((OpIngSvcHandle = OpenService(schSCManager, ServiceName,
SERVICE_QUERY_STATUS)) != NULL)
{
if (QueryServiceStatus(OpIngSvcHandle,lpssServiceStatus))
{
if (ssServiceStatus.dwCurrentState != SERVICE_STOPPED)
bServiceStarted = TRUE;
}
}
}
if (!bServiceStarted)
return(PCcmdline( (LOCATION *) NULL, cmdbuf, PC_WAIT,
(LOCATION *) NULL, &err_code) );
}
}
/*
** See if this command is an Ingres command which needs to interact
** with at least one database.
*/
for (i = 0; validSetuidDbCmds[i] ; i++)
{
if (STbcompare( cmdbuf, cmdlen, validSetuidDbCmds[i],
(i4)STlength(validSetuidDbCmds[i]), FALSE ) == 0)
{
SetuidDbCmd = TRUE;
break;
}
}
/*
** If the user has access to the Ingres shared memory segment,
** just spawn the command provided that it is not in the
** validSetuidDbCmds list.
*/
if (!SetuidDbCmd)
{
PTR shmem;
SIZE_TYPE allocated_pages=0;
STATUS status;
if (((status = MEget_pages(ME_MSHARED_MASK, 1, "lglkdata.mem",
&shmem,
&allocated_pages, &err_code)) == OK) ||
(status == ME_NO_SUCH_SEGMENT))
{
if (status != ME_NO_SUCH_SEGMENT)
MEfree_pages(shmem, allocated_pages, &err_code);
return( PCcmdline( (LOCATION *) NULL, cmdbuf, PC_WAIT,
(LOCATION *) NULL, &err_code) );
}
}
}
/*
** We must run the command through the Ingres service.
*/
if ( STstrindex(cmdbuf, "-silent", 0, FALSE ) )
SilentMode = TRUE;
iimksec(&sa);
GVshobj(&ObjectPrefix);
STprintf(SetuidShmName, "%s%sSetuidShm", ObjectPrefix, tchII_INSTALLATION);
if ( (SetuidShmHandle = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE,
FALSE,
SetuidShmName)) == NULL )
{
error_exit(GetLastError());
return(FAIL);
}
if ( (SetuidShmPtr = MapViewOfFile(SetuidShmHandle,
FILE_MAP_WRITE | FILE_MAP_READ,
0,
0,
sizeof(struct SETUID_SHM))) == NULL )
{
error_exit(GetLastError());
return(FAIL);
}
/* Set up the information to send to the service. */
STcopy(cmdbuf, setuid.cmdline);
GetCurrentDirectory(sizeof(setuid.WorkingDirectory),
setuid.WorkingDirectory);
NMgtAt("II_TEMPORARY", &temp_loc);
drType = GetDriveType(NULL);
if (drType == DRIVE_REMOTE)
{
STcopy(temp_loc, setuid.WorkingDirectory);
}
SaveStdout = GetStdHandle(STD_OUTPUT_HANDLE);
CVla(GetCurrentProcessId(), setuid.ClientProcID);
STprintf(SetuidPipeName, "\\\\.\\PIPE\\INGRES\\%s\\SETUID", inst_id);
/* Set up the stdout file for the command. */
STprintf(OutfileName, "%s\\%sstdout.tmp", temp_loc, setuid.ClientProcID);
if ( (OutFile = CreateFile(OutfileName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
&sa,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL)) == INVALID_HANDLE_VALUE )
{
error_exit(GetLastError());
return(FAIL);
}
/* Set up the stdin file for the command. */
STprintf(InfileName, "%s\\%sstdin.tmp", temp_loc, setuid.ClientProcID);
if ( (InFile = CreateFile(InfileName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
&sa,
CREATE_ALWAYS,
FILE_FLAG_WRITE_THROUGH,
NULL)) == INVALID_HANDLE_VALUE )
{
error_exit(GetLastError());
return(FAIL);
}
/* Wait until the service is ready to process our request. */
while (SetuidShmPtr->pending == TRUE)
PCsleep(100);
SetuidShmPtr->pending = TRUE;
/* Trigger the "setuid" event of the service. */
if ( (schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT)) == NULL)
{
error_exit(GetLastError());
return(FAIL);
}
STprintf(ServiceName, "%s_Database_%s", SYSTEM_SERVICE_NAME,
tchII_INSTALLATION );
OpIngSvcHandle = OpenService(schSCManager, ServiceName,
SERVICE_USER_DEFINED_CONTROL);
if (OpIngSvcHandle == NULL)
{
STprintf(ServiceName, "%s_DBATools_%s", SYSTEM_SERVICE_NAME,
tchII_INSTALLATION );
OpIngSvcHandle = OpenService(schSCManager, ServiceName,
SERVICE_USER_DEFINED_CONTROL);
}
if ( OpIngSvcHandle == NULL)
{
error_exit(GetLastError());
return(FAIL);
}
if (!ControlService(OpIngSvcHandle, RUN_COMMAND_AS_INGRES,
lpssServiceStatus))
{
error_exit(GetLastError());
CloseServiceHandle(schSCManager);
return(FAIL);
}
WaitNamedPipe(SetuidPipeName, NMPWAIT_WAIT_FOREVER);
/* Send the information to the service. */
if ( (Setuid_Handle = CreateFile(SetuidPipeName,
GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_READ|FILE_SHARE_WRITE,
&sa,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL)) == INVALID_HANDLE_VALUE )
{
error_exit(GetLastError());
return(FAIL);
}
if (!WriteFile(Setuid_Handle, &setuid, sizeof(struct SETUID),
&BytesWritten, NULL))
{
error_exit(GetLastError());
return(FAIL);
}
/*
** Retrieve information back from the service, and then
** disconnect from the pipe.
*/
if (!ReadFile(Setuid_Handle, &setuid, sizeof(struct SETUID),
&BytesRead, NULL))
{
error_exit(GetLastError());
return(FAIL);
}
ProcID = setuid.CreatedProcID;
SetuidShmPtr->pending = FALSE;
UnmapViewOfFile(SetuidShmPtr);
SetuidShmPtr = NULL;
CloseHandle(SetuidShmHandle);
if ( (ProcID != -1) && (ProcID != -2) )
{
/*
** Wait for the "spawned" process to exit, reading its output
** from the stdout file.
*/
for (;;)
{
if ( ((!ReadFile(OutFile, OutBuf, sizeof(OutBuf), &BytesRead, NULL)
|| (BytesRead == 0)) && setuid.ExitCode != STILL_ACTIVE ))
break;
if ( BytesRead &&
(!WriteFile(SaveStdout, OutBuf, BytesRead, &BytesWritten,
NULL)) && setuid.ExitCode != STILL_ACTIVE)
break;
else if (BytesRead < sizeof(OutBuf))
PCsleep(200);
/*
** Currently, the only DBA program which can require
** user input is verifydb. Therefore, when it spits out
** the appropriate messages asking for user input, get
** it from the end user and pass it along to the spawned
** process.
*/
if ( (STrstrindex(OutBuf, "S_DU04FF_CONTINUE_PROMPT", 0, FALSE)
!= NULL) ||
(STrstrindex(OutBuf, "S_DU0300_PROMPT", 0, FALSE) != NULL) )
{
SIflush(stdout);
MEfill(sizeof(OutBuf), ' ', &OutBuf);
MEfill(sizeof(InBuf), ' ', &InBuf);
SIgetrec(InBuf, 255, 0);
WriteFile(InFile, InBuf, sizeof(OutBuf), &BytesWritten, NULL);
}
}
ExitCode = setuid.ExitCode;
CloseHandle(Setuid_Handle);
CloseHandle(InFile);
DeleteFile(InfileName);
CloseHandle(OutFile);
DeleteFile(OutfileName);
CloseServiceHandle(OpIngSvcHandle);
CloseServiceHandle(schSCManager);
return(ExitCode);
}
else
{
error_exit(GetLastError());
return(FAIL);
}
}
/*
** Name: sxapo_init_cnf - Initialize SXAPO configuration from the PM file.
**
** Description:
** This routine initializes the SXAPO configuration from the
** PM configuration file.
**
** Inputs:
** None.
**
** Outputs:
** err_code Error code returned to caller.
**
** Returns:
** DB_STATUS
**
** History:
** 6-jan-94 (stephenb)
** Initial creation.
*/
static DB_STATUS
sxapo_init_cnf(
i4 *err_code)
{
DB_STATUS status = E_DB_OK;
STATUS clstat;
i4 local_err;
char *pmfile;
char *pmvalue;
*err_code = E_SX0000_OK;
for (;;)
{
/*
** Allow private override on PM file
*/
NMgtAt("II_SXF_PMFILE", &pmfile);
if (pmfile && *pmfile)
{
LOCATION pmloc;
TRdisplay("Loading SXF-PM file '%s'\n",pmfile);
LOfroms(PATH & FILENAME, pmfile, &pmloc);
if(PMload(&pmloc,NULL)!=OK)
TRdisplay("Error loading PMfile '%s'\n",pmfile);
}
/*
** Get auditing status
*/
if (PMget(SX_C2_MODE,&pmvalue) == OK)
{
if (!STbcompare(pmvalue, 0, SX_C2_MODE_ON, 0, TRUE))
{
/*
** Auditing on
*/
Sxapo_cb->sxapo_status=SXAPO_ACTIVE;
}
else if ((STbcompare(pmvalue, 0, SX_C2_MODE_OFF, 0, TRUE)!=0))
{
/*
** Niether ON nor OFF, Invalid mode
*/
*err_code=E_SX1061_SXAP_BAD_MODE;
break;
}
}
else
{
/*
** No value, this is an error
*/
*err_code=E_SX1061_SXAP_BAD_MODE;
break;
}
/*
** Get action on error
*/
if ((PMget("II.*.C2.ON_ERROR",&pmvalue) == OK))
{
if (!STcasecmp(pmvalue, "STOPAUDIT" ))
{
Sxf_svcb->sxf_act_on_err=SXF_ERR_STOPAUDIT;
}
else if (!STcasecmp(pmvalue, "SHUTDOWN" ))
{
Sxf_svcb->sxf_act_on_err=SXF_ERR_SHUTDOWN;
}
else
{
/*
** Invalid value
*/
*err_code=E_SX1060_SXAP_BAD_ONERROR;
break;
}
}
else
{
/*
** No value, this is an error
*/
*err_code=E_SX1060_SXAP_BAD_ONERROR;
break;
}
break;
}
/* handle errors */
if (*err_code != E_SX0000_OK)
{
_VOID_ ule_format(*err_code, NULL, ULE_LOG, NULL, NULL,
0L, NULL, &local_err, 0);
*err_code = E_SX1020_SXAP_INIT_CNF;
status = E_DB_ERROR;
}
return (status);
}
i4
main (int argc, char **argv)
{
STATUS status=OK;
PTR drvH=NULL;
char **list=NULL;
ATTR_ID **attrList=NULL;
char **defAttr=NULL;
i4 count=0, attrCount = 0, retcount;
i4 i;
bool badCmdLine = FALSE, rmPkg = FALSE, has_default = FALSE, has_alt
= FALSE, isReadOnly = FALSE, mgrSpecified = FALSE, batch = FALSE,
def_or_alt=FALSE;
i4 pathType = OCFG_SYS_PATH;
char altPath[OCFG_MAX_STRLEN] = "\0";
char drvMgr[OCFG_MAX_STRLEN] = "\0";
char line[MAXLINE],prompt[MAXLINE];
char driverPath[OCFG_MAX_STRLEN];
char *dirPath;
char driverName[OCFG_MAX_STRLEN];
char *ii_installation;
char *p = NULL;
char custName[OCFG_MAX_STRLEN];
char etxt[512];
ATTR_ID driverList[6] =
{
{ DRV_ATTR_DRIVER, "\0" },
{ DRV_ATTR_DRIVER_ODBC_VER, DRV_STR_VERSION },
{ DRV_ATTR_DRIVER_READONLY, DRV_STR_N },
{ DRV_ATTR_DRIVER_TYPE, DRV_STR_INGRES },
{ DRV_ATTR_VENDOR, DRV_STR_INGRES_CORP },
{ DRV_ATTR_DONT_DLCLOSE, DRV_STR_ONE }
};
int drvCount = sizeof(driverList) / sizeof(driverList[0]);
ATTR_ID **drvList = (ATTR_ID **)MEreqmem( (u_i2) 0,
(u_i4)drvCount, TRUE, (STATUS *) NULL);
for (i = 0; i < drvCount; i++)
{
drvList[i] = (ATTR_ID *)MEreqmem( (u_i2) 0,
(u_i4)sizeof(ATTR_ID), TRUE, (STATUS *) NULL);
drvList[i]->id = driverList[i].id;
drvList[i]->value = (char *)MEreqmem( (u_i2) 0,
(u_i4)OCFG_MAX_STRLEN, TRUE, (STATUS *) NULL);
STcopy(driverList[i].value, drvList[i]->value);
}
if ( argc > 7 )
badCmdLine = TRUE;
/*
** Parse the command line. Reject invalid arguments.
*/
if ( !badCmdLine && argc > 1 )
{
if (checkArgs("-h", argc, argv, NULL, NULL ) )
{
display_help();
PCexit(0);
}
if (checkArgs("-help", argc, argv, NULL, NULL ) )
{
display_help();
PCexit(0);
}
if ( checkArgs("-batch", argc, argv, NULL, NULL ) )
batch = TRUE;
if ( checkArgs("-rmpkg", argc, argv, NULL, NULL ) )
rmPkg = TRUE;
if (checkArgs("-r", argc, argv, NULL, NULL ) )
isReadOnly = TRUE;
if ( checkArgs("-p", argc, argv, altPath, NULL ) )
pathType = OCFG_ALT_PATH;
if ( checkArgs("-m", argc, argv, NULL, drvMgr ) )
mgrSpecified = TRUE;
}
/*
** Set driver manager according to user input. Default is unixODBC.
*/
if (mgrSpecified && !STbcompare( drvMgr, 0, MGR_STR_CAI_PT, 0, TRUE ) )
driverManager = MGR_VALUE_CAI_PT;
else
driverManager = MGR_VALUE_UNIX_ODBC;
/*
** If none of the arguments are recognized, flag an error.
*/
if ( !batch && !rmPkg && !isReadOnly && pathType != OCFG_ALT_PATH && !mgrSpecified && argc > 1)
badCmdLine = TRUE;
if ( badCmdLine )
{
display_help();
PCexit(FAIL);
}
if ( isReadOnly )
STcopy(DRV_STR_Y, drvList[2]->value);
else
STcopy(DRV_STR_N, drvList[2]->value);
if ( !writeMgrFile( altPath ) )
{
SIprintf("Aborting due to error writing %s/files/%s\n",
SYSTEM_LOCATION_SUBDIRECTORY, MGR_STR_FILE_NAME);
PCexit(FAIL);
}
defAttr = getDefaultInfo();
if (defAttr == NULL)
{
SIprintf("Aborting due to error reading %s/install/%s\n",
SYSTEM_LOCATION_VARIABLE, INFO_STR_FILE_NAME);
PCexit(FAIL);
}
/*
** Get the path of the driver library and create the path/libname string.
*/
NMgtAt(SYSTEM_LOCATION_VARIABLE,&dirPath); /* usually II_SYSTEM */
if (dirPath != NULL && *dirPath)
STlcopy(dirPath,driverPath,sizeof(driverPath)-20-1);
else
{
SIprintf("Error--%s is not defined\n",SYSTEM_LOCATION_VARIABLE);
PCexit(FAIL);
}
# ifdef VMS
STcat(driverPath,"[");
STcat(driverPath,SYSTEM_LOCATION_SUBDIRECTORY); /* usually "ingres" */
STcat(driverPath,".library]");
if ( isReadOnly )
STcat(driverPath,defAttr[INFO_ATTR_RONLY_DRV_FNAME]);
else
STcat(driverPath,defAttr[INFO_ATTR_DRIVER_FILE_NAME]);
# else
STcat(driverPath,"/");
STcat(driverPath,SYSTEM_LOCATION_SUBDIRECTORY); /* usually "ingres" */
STcat(driverPath,"/lib/");
if ( isReadOnly )
STcat(driverPath,defAttr[INFO_ATTR_RONLY_DRV_FNAME]);
else
STcat(driverPath,defAttr[INFO_ATTR_DRIVER_FILE_NAME]);
# endif /* ifdef VMS */
STcopy(driverPath,drvList[0]->value);
/*
** Initialize the cache from the odbcinst.ini file.
*/
openConfig(NULL, pathType, altPath, &drvH, &status);
if (status != OK)
{
STprintf(etxt,"Could not open from path %s.\n",
pathType == OCFG_ALT_PATH ? altPath : "/usr/local/etc");
display_err(etxt,status);
PCexit(FAIL);
}
if (rmPkg)
{
delConfigEntry( drvH, defAttr[INFO_ATTR_DRIVER_NAME], &status );
delConfigEntry( drvH, defAttr[INFO_ATTR_ALT_DRIVER_NAME], &status );
closeConfig(drvH, &status);
PCexit(OK);
}
/*
** Get the driver count.
*/
retcount = listConfig( drvH, count, list, &status );
if (status != OK)
{
STprintf(etxt,"Could not list drivers.\n");
display_err(etxt,status);
PCexit(FAIL);
}
count = retcount;
if (count)
{
/*
** Get the list of recognized drivers.
*/
list = (char **)MEreqmem( (u_i2) 0,
(u_i4)(count * sizeof(char *)), TRUE,
(STATUS *) NULL);
for (i = 0; i < count; i++)
list[i] = (char *)MEreqmem( (u_i2) 0, (u_i4)OCFG_MAX_STRLEN,
TRUE, (STATUS *) NULL);
listConfig( drvH, count, list, &status );
if (status != OK)
{
STprintf(etxt,"Could not list drivers.\n");
display_err(etxt,status);
PCexit(FAIL);
}
}
for (i = 0; i < count; i++)
{
def_or_alt = FALSE;
if (!has_default)
{
has_default = STbcompare( list[i], 0,
defAttr[INFO_ATTR_DRIVER_NAME], 0, TRUE )
== 0 ? TRUE : FALSE;
if (has_default)
def_or_alt = TRUE;
}
if (!has_alt)
{
has_alt = STbcompare( list[i], 0,
defAttr[INFO_ATTR_ALT_DRIVER_NAME], 0,
TRUE ) == 0 ? TRUE : FALSE;
if (has_alt)
def_or_alt = TRUE;
}
if (def_or_alt)
{
if ( !batch )
{
STprintf(prompt,
"\tInstallation has pre-defined version of %s.\n\tOverwrite? (Yes/No)",
list[i]);
if ( line_get( prompt, "", FALSE, line ) == EOF )
{
SIprintf("ODBC driver installation safely aborted\n");
PCexit(OK);
}
STzapblank(line,line);
if ( line[0] != 'y' && line [0] != 'Y' )
{
SIprintf( "%s left untouched\n", list[i] );
continue;
}
} /* if (!batch) */
STcopy(list[i],driverName);
setConfigEntry( drvH, driverName, drvCount, drvList, &status );
if (status != OK)
{
STprintf(etxt,"Could not write driver entry.\n");
display_err(etxt,status);
PCexit(FAIL);
}
} /* if (has_default || has_alt) */
else if ( !batch )
{
STprintf(prompt,
"\tInstallation has custom version of %s.\n\tDelete? (Yes/No)",
list[i]);
if ( line_get( prompt, "", FALSE, line ) == EOF )
{
SIprintf("ODBC driver installation safely aborted\n");
PCexit(OK);
}
STzapblank(line,line);
if ( line[0] != 'y' && line [0] != 'Y' )
{
SIprintf( "%s left untouched\n", list[i] );
continue;
}
STcopy(list[i],driverName);
delConfigEntry( drvH, driverName, &status );
if (status != OK)
{
STprintf(etxt,"Could not write driver entry.\n");
display_err(etxt,status);
PCexit(FAIL);
}
} /* if (!batch) && !has_default */
} /* for (count... */
if (!has_default)
{
setConfigEntry( drvH, defAttr[INFO_ATTR_DRIVER_NAME], drvCount,
drvList, &status );
if (status != OK)
{
STprintf(etxt,"Could not write driver entry.\n");
display_err(etxt,status);
PCexit(FAIL);
}
}
if (!has_alt)
{
setConfigEntry( drvH, defAttr[INFO_ATTR_ALT_DRIVER_NAME], drvCount,
drvList, &status );
if (status != OK)
{
STprintf(etxt,"Could not write driver entry.\n");
display_err(etxt,status);
PCexit(FAIL);
}
}
closeConfig(drvH, &status);
if (status != OK)
{
STprintf(etxt,"Could not close driver info.\n");
display_err(etxt,status);
PCexit(FAIL);
}
if (count)
{
for (i = 0; i < count; i++)
MEfree((PTR)list[i]);
MEfree((PTR)list);
}
for (i = 0; i < drvCount; i++)
{
MEfree((PTR)drvList[i]->value);
MEfree((PTR)drvList[i]);
}
MEfree((PTR)drvList);
PCexit(OK);
}
/*
** Name: check_user
**
** Description:
** Test the characters in the username as returned from
** the operating system.
**
** Inputs:
** None.
**
** Output:
** error_msg pointer to the area where an error message should be
** copied
**
** Returns:
** None.
**
** History:
** 14-Feb-2005 (fanra01)
** Created.
*/
static i4
check_user()
{
i4 result;
char username[UNLEN + 1] = { 0 };
i4 nsize = MAX_COMPNAME;
#if defined(UNIX)
struct passwd *p_pswd, pwd;
char pwuid_buf[BUFSIZ];
int size = BUFSIZ;
#endif
/*
** Get current user name
*/
nsize = UNLEN;
#if defined(UNIX)
MEfill ( sizeof(pwuid_buf), '\0', pwuid_buf );
if( ( p_pswd = iiCLgetpwuid(getuid(), &pwd, pwuid_buf, size) ) != NULL)
{
STcopy( p_pswd->pw_name, username );
#else /* UNIX */
if (GetUserName( username, &nsize ))
{
#endif /* UNIX */
/*
** Check if the username contains unsupported characters
*/
if (!CMvalidusername( username ))
{
result = II_INVALID_USER;
return(result);
}
}
else
{
result = II_GET_USER_FAIL;
return(result);
}
result = II_SUCCESSFUL;
return(result);
}
/*
** Name: check_os_arch - Verify OS and architecture
**
** Description:
** Function verifies the OS version and the operating architecture and
** determines whether the platform should support an installation of
** Ingres.
**
** The following checks are applied:
** a. Verify the minimum OS version
** b. Verfiy execution mode.
** c. Verify architecture.
**
** Inputs:
** None.
**
** Outputs:
** None.
**
** Returns:
** 0 Platform verified successfully
** non-zero Error verifying platform
**
** History:
** 14-Dec-2004 (fanra01)
** Created.
**
*/
# ifdef NT_GENERIC
/*
** Name: OS_ARCH
**
** Description:
** Structure to describe Ingres architecture coupled with actual hardware
** architecture.
**
** inghw Ingres hardware code will run on the processor architecture.
** procarch Processor architecture.
**
** History:
** 15-Dec-2004 (fanra01)
** Created.
*/
typedef struct _os_arch
{
i4 inghw;
i4 procarch;
}OS_ARCH;
static OS_ARCH platform[] =
{
{ II_IA32, PROCESSOR_ARCHITECTURE_INTEL }, /* 32-bit Ingres on IA32 */
{ II_IA32, PROCESSOR_ARCHITECTURE_AMD64 }, /* 32-bit Ingres on AMD64 */
{ II_IA64, PROCESSOR_ARCHITECTURE_IA64 }, /* 64-bit Ingres on IA64 */
{ II_AMD64, PROCESSOR_ARCHITECTURE_AMD64 }, /* 64-bit Ingres on AMD64 */
{ 0x000000, 0 }
};
static i4
check_os_arch( i4 architecture )
{
typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS)(HANDLE hProcess,PBOOL Wow64Process);
typedef VOID (WINAPI *LPFN_GETNATIVESYSTEMINFO)(LPSYSTEM_INFO lpSystemInfo);
BOOL bIsWow64 = FALSE;
BOOL bVersVerified = FALSE;
LPFN_ISWOW64PROCESS fnIsWow64Process;
LPFN_GETNATIVESYSTEMINFO fnGetNativeSystemInfo;
DWORDLONG dwlConditionMask = 0;
i4 result = 0;
i4 i;
SYSTEM_INFO sysinfo;
OSVERSIONINFOEX osvi;
MEfill( sizeof(SYSTEM_INFO), 0, &sysinfo );
MEfill( sizeof(OSVERSIONINFOEX), 0, &osvi );
/*
** Test the processing mode. bIsWow64 is TRUE if this is 32-bit code
** running in a 32-bit execution layer on a 64-bit processor.
*/
if ((fnIsWow64Process =
(LPFN_ISWOW64PROCESS)GetProcAddress( GetModuleHandle("kernel32"),
"IsWow64Process")) != NULL)
{
if((fnGetNativeSystemInfo =
(LPFN_GETNATIVESYSTEMINFO)GetProcAddress(
GetModuleHandle("kernel32"), "GetNativeSystemInfo")) == NULL)
{
result = GetLastError();
}
if (result == 0)
{
if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
{
result = GetLastError();
}
}
}
if (result == 0)
{
/*
** Verify the minimum version requirement.
** This has been set at Windows NT 4 SP3.
*/
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
osvi.dwMajorVersion = 4;
osvi.dwMinorVersion = 0;
osvi.wServicePackMajor = 3;
VER_SET_CONDITION( dwlConditionMask, VER_MAJORVERSION,
VER_GREATER_EQUAL );
VER_SET_CONDITION( dwlConditionMask, VER_MINORVERSION,
VER_GREATER_EQUAL );
VER_SET_CONDITION( dwlConditionMask, VER_SERVICEPACKMAJOR,
VER_GREATER_EQUAL );
bVersVerified = VerifyVersionInfo( &osvi,
VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR,
dwlConditionMask);
if (bVersVerified == FALSE)
{
result = GetLastError();
}
else
{
/*
** Get the system information that includes the processor
** architecture.
*/
if ((bIsWow64 == TRUE) &&
(fnGetNativeSystemInfo != NULL))
{
/*
** Running 32-bit execution layer on a 64-bit platform
** Use function that gets true architecture.
*/
fnGetNativeSystemInfo( &sysinfo );
}
else
{
GetSystemInfo( &sysinfo );
}
if (result == 0)
{
result = FAIL;
for( i=0; platform[i].inghw != 0; i+=1 )
{
if ((architecture == platform[i].inghw) &&
(sysinfo.wProcessorArchitecture == platform[i].procarch))
{
/*
** Return true if and only if the Ingres hardware
** platform is specifically associated with the
** processor architecture.
*/
result = OK;
break;
}
}
}
}
}
return(result);
}
# endif /* NT_GENERIC */
# if defined(UNIX)
/*
** Name: check_os_arch - Verify OS and architecture on UNIX/LINUX
**
** Description:
** Function verifies the hardware architecture and OS system,
** determines whether the platform should support an installation of
** Ingres.
**
**
** Inputs: Ingres architecture ( defined as GV_HW in gv.h )
**
**
** Returns:
** 0 Platform verified successfully
** non-zero Error verifying platform
**
** History:
** 15-Oct-2006 (hweho01)
** Added for Unix/Linux platforms.
**
*/
/*
** Name: OS_ARCH
**
** Description:
** Structure to describe Ingres architecture coupled with actual OS
** system name.
**
** inghw Ingres hardware code will run on the OS system.
** os_name system name.
**
*/
typedef struct _os_arch
{
i4 inghw;
char os_name[20];
}OS_ARCH;
static OS_ARCH platform[] =
{
{ II_IA32, "LINUX" }, /* 32-bit Ingres on IA32 */
{ II_IA32, "LINUX" }, /* 32-bit Ingres on AMD64 */
{ II_IA64, "LINUX" }, /* 64-bit Ingres on IA64 */
{ II_AMD64, "LINUX" }, /* 64-bit Ingres on AMD64 */
{ II_SPARC, "SUNOS" }, /* 32/64 Ingres on Sun Solaris */
{ II_PARISC, "HP-UX" }, /* 32/64 Ingres on HP UNIX */
{ II_POWERPC, "AIX" }, /* 32/64 Ingres on IBM POWERPC */
{ 0x000000, NULL }
};
static i4
check_os_arch( i4 architecture )
{
struct utsname sysinfo;
i4 ret, i ;
i4 result = 0;
/* check the running OS info */
ret = uname( &sysinfo );
result = FAIL;
for( i=0; platform[i].inghw != 0; i+=1 )
{
if ((architecture == platform[i].inghw) &&
(STcasecmp( sysinfo.sysname, platform[i].os_name) == 0))
{
result = OK;
break;
}
}
return(result);
}
# endif /* UNIX */
/*
** Name: check_platform - Verify software platform
**
** Description:
** Function determines the operating platform and verifies that the
** minimum requirements are fulfilled.
**
** Inputs:
** None.
**
** Outputs:
** None.
**
** Returns:
** 0 architecture verification succeeded
** non-zero architecture failed verification
**
** History:
** 13-Dec-2004 (fanra01)
** Created.
*/
static i4
check_platform( i4 architecture )
{
i4 result = 0;
ING_VERSION ingver;
char* plat_override = NULL;
NMgtAt(ERx("II_RELAX_PLATFORM"), &plat_override);
if (plat_override && *plat_override)
{
return(result);
}
/*
** No architecture has been specified, use the internal compiled one.
*/
if (architecture == II_DEFARCH)
{
MEfill( sizeof(ING_VERSION), 0, &ingver );
/*
** Retrieve the hardware architecture used to build this version
*/
if ((result = GVver( GV_M_HW, &ingver )) == OK)
{
/*
** Reassign the architecture to the retrieved one.
*/
architecture = ingver.hardware;
}
}
if (result == OK)
{
result = check_os_arch( architecture );
}
return(result);
}
/*
** Name: GCwintcp_init
** Description:
** WINTCP inititialization function. This routine is called from
** GCwinsock_init() -- the routine GCC calls to initialize protocol
** drivers.
**
** This function does initialization specific to the protocol:
** Reads any protocol-specific env vars.
** Sets up the winsock protocol-specific control info.
** History:
** 05-Nov-93 (edg)
** created.
** 23-Feb-1998 (thaal01)
** Allow space for port_id, stops GCC crashing on startup sometimes.
** 07-Jul-1998 (macbr01)
** Bug 91972 - jasgcc not receiving incoming communications. This is
** due to incorrect usage of PMget() in function GCwintcp_init().
** Changed to test return code of PMget() instead of testing passed
** in parameter for not equal to NULL.
** 15-jul-1998 (canor01)
** Move assignment of port_id to port_id_buf to prevent possible
** access violation. Clean up comments.
** 09-feb-2004 (somsa01)
** When working with instance identifiers as port IDs, make sure
** we initialize sbprt with the trailing number, if set.
** 13-may-2004 (somsa01)
** Updated config.dat string used to retrieve port information such
** that we do not rely specifically on the GCC port. Also, corrected
** function used to convert subport into a number.
** 26-Jan-2006 (loera01) Bug 115671
** Added GCWINTCP_log_rem_host to allow of gethostbyaddr() to be
** disabled.
** 06-Feb-2007 (Ralph Loen) SIR 117590
** Removed GCWINTCP_log_rem_host, since gethostbyaddr() is no
** longer invoked for network listens.
** 22-Feb-2008 (rajus01) Bug 119987, SD issue 125582
** Bridge server configuration requires listening on a specified
** three character listen address. During protocol initialization
** the bridge server fails to start when three character listen
** address is specified. For example,
** the following configuration entries in config.dat
** ii.<host>.gcb.*.wintcp.port: <xxn>,
** ii.<host>.gcb.*.wintcp.status:<prot_stat>
** are for command line configuration. When these entries are
** present in addition to the CBF VNODE configuration (shown below )
** ii.rajus01.gcb.*.wintcp.port.v1:<xxn>
** ii.rajus01.gcb.*.wintcp.status.v1:<prot_stat>
** the bridge server fails even though the port is available for use.
** It has been found that the global 'sbprt' variable gets set
** by the bridge server during protocol initialization to 'n' in the
** three charater listen address 'xxn'. Later, while resolving the
** three character portname into port number by GCwintcp_port routine
** it assumes that this port is already in use even though it is not
** the case.
** Added server_type to determine the GCF server type.
** The error messages from errlog.log are the following:
** rajus01 ::[R3\BRIDGE\12c4 , 4804 , ffffffff]: Tue Feb 19
** 19:49:27 2008 E_GC2808_NTWK_OPEN_FAIL Network open failed for
** protocol TCP_IP, port R3; status follows.
** rajus01 ::[R3\BRIDGE\12c4 , 4804 , ffffffff]: Tue Feb 19
** 19:49:27 2008 E_CL2787_GC_OPEN_FAIL An attempted network open
** failed.
** Change description:
** The code that clears the third character in the listen address
** specified in the config.dat has been removed. This
** appears to be a wrong assumption in the protocol driver based
** on the documentation in "Appendix A:TCP/IP protocol, Listen
** Address Format seciton of Connectivity Guide". With these
** changes the protocol driver will behave the way UNIX does.
**
** WARNING: This DOES introduce the behavioural changes in the
** following cases when starting one or more servers by increa-
** sing the startup count in config.dat.
**
** Case 1:
** Both tcp_ip and win_tcp status are set to ON with Listen
** Addresses II5 and II5 for example.
** New behaviour: The GCF server will come up and listen on
** one protocol using port II5, but will fail on the other
** protocol.
** Original behaviour:
** The GCF server will listen on port II5 on the first
** protocol and the second one will listen on II6.
** This seems to be a bug in the driver as this is not the
** behaviour documented in the connectivity guide.
** Case 2:
** Both tcp_ip and win_tcp status are set to ON with Listen
** Addresses (win_tcp=II, tcp_ip = II1).
** Original behaviour:
** First GCF server will come up OK (II0, II1). The second
** GCF server will come up fine too ( II2, II3 ).
** New Behaviour:
** First GCF server will come up fine. The second GCF server
** will fail for tcp_ip protocol, but will come up on win_tcp
** protocol. This doesn't seem to be much of an issue because
** the second GCF server will still come up using win_tcp.
** 13-Apr-2010 (Bruce Lunsford) SIR 122679
** Set wsd->pce_driver from GCC PCT rather than from ex-global
** WS_wintcp.
*/
STATUS
GCwintcp_init(GCC_PCE * pptr, GCC_WINSOCK_DRIVER *wsd)
{
char *ptr = NULL;
char real_name_size[] = "100";
char *host, *server_id, *port_id;
char config_string[256];
char install[32]; //II_INSTALLATION code
/*
** Get set up for the PMget call.
*/
PMinit();
if( PMload( NULL, (PM_ERR_FUNC *)NULL ) != OK )
PCexit( FAIL );
/*
** Construct the network port identifier.
*/
host = PMhost();
server_id = PMgetDefault(3);
if (!server_id)
server_id = "*" ;
STprintf( config_string, ERx("!.wintcp.port"),
SystemCfgPrefix, host, server_id);
/*
** Search config.dat for a match on the string we just built.
** If we don't find it, then use the value for II_INSTALLATION
** failing that, default to II.
*/
if ((PMget( config_string, &port_id ) != OK) ||
(port_id == NULL ))
{
NMgtAt("II_INSTALLATION", &ptr);
port_id = install;
if (ptr != NULL && *ptr != '\0')
{
STcopy(ptr, port_id);
}
else
{
STcopy(SystemVarPrefix, port_id);
}
}
STcopy(port_id, pptr->pce_port);
GCTRACE(1)("GCwintcp_init: port = %s\n", pptr->pce_port );
/*
** Fill in protocol-specific info
*/
wsd->addr_len = sizeof( struct sockaddr_in );
wsd->sock_fam = AF_INET;
wsd->sock_type = SOCK_STREAM;
wsd->sock_proto = 0;
wsd->block_mode = FALSE;
wsd->pce_driver = pptr->pce_driver;
/*
** Get trace variable
*/
ptr = NULL;
NMgtAt( "II_WINTCP_TRACE", &ptr );
if ( !(ptr && *ptr) && PMget("!.wintcp_trace_level", &ptr) != OK )
{
GCWINTCP_trace = 0;
}
else
{
GCWINTCP_trace = atoi( ptr );
}
return OK;
}
BOOL CWinstartApp::InitInstance()
{
char *ii_installation;
HWND hWnd;
CString csWindow;
NMgtAt(ERx( "II_INSTALLATION" ), &ii_installation);
if (ii_installation == NULL || *ii_installation == EOS)
ii_installation = ERx("II");
else
ii_installation = STalloc(ii_installation);
csSemaphore.Format("IngresII_Winstart_%s", ii_installation);
csWindow.Format(IDS_CAPTIONTEXT,(LPCTSTR)ii_installation);
hSemaphore = OpenSemaphore( SEMAPHORE_ALL_ACCESS, FALSE,
(LPCTSTR)csSemaphore );
if (hSemaphore)
{
/*
** We've already got a WINSTART running for this installation.
** Attempt to find it and change focus to it.
*/
CloseHandle(hSemaphore);
hWnd = FindWindow(NULL, csWindow);
if(hWnd)
{
SetForegroundWindow(hWnd);
ShowWindow(hWnd, SW_RESTORE);
exit(0);
}
}
hSemaphore = CreateSemaphore(NULL, cMax, cMax, (LPCTSTR)csSemaphore);
/*
** Standard initialization
** If you are not using these features and wish to reduce the size
** of your final executable, you should remove from the following
** the specific initialization routines you do not need.
*/
InitCommonControls();
CWinApp::InitInstance();
AfxEnableControlContainer ();
/* Load standard INI file options (including MRU) */
LoadStdProfileSettings();
CWinstartDlg dlg;
m_pMainWnd = &dlg;
CString strCmdLine="";
if (m_lpCmdLine)
strCmdLine = m_lpCmdLine;
strCmdLine.MakeLower();
if (strCmdLine.Find("/start") != -1)
dlg.m_bStartFlag = TRUE;
else
dlg.m_bStartFlag = FALSE;
if (strCmdLine.Find("/stop") != -1)
dlg.m_bStopFlag = TRUE;
else
dlg.m_bStopFlag = FALSE;
int i, iPos, iLen, iLeft, iChars=0;
TCHAR p;
dlg.m_strParam="";
iPos = strCmdLine.Find("/param=\"");
if (iPos != -1)
{
dlg.m_bParamFlag = TRUE;
iLen = strCmdLine.GetLength();
iLeft = iPos + 8;
for (i=iLeft; i<iLen; i++)
{
p = strCmdLine.GetAt(i);
if (p == '\"')
break;
iChars++;
}
dlg.m_strParam=strCmdLine.Mid(iLeft, iChars);
}
else
dlg.m_bParamFlag = FALSE;
dlg.DoModal();
/*
** Since the dialog has been closed, return FALSE so that we exit the
** application, rather than start the application's message pump.
*/
return FALSE;
}
