Beispiel #1
0
bool
r_rep_do()
{
	char	  *_Retrieving	= ERget(F_RW0003_Retrieving_data);
	LOCATION  loc;		/* file where the report will be written */
        char      title[80+1];      /* the help title buffer */
	char      help_scr[80+1];   /* the help screen buffer */
        char      pr_title[80+1];   /* print report title */
	char      file_title[80+1]; /* file report title */


	/*	
	** The following is for scrollable output.
	*/
FUNC_EXTERN	BCB	*IIUFint_Init();
FUNC_EXTERN	bool	IIUFmro_MoreOutput();
		bool	scrl_fl;


	r_rep_set(&loc);

	if (St_ing_error != 0)
		return FALSE;

	if (!St_silent)
	{	/* give message while waiting for retrieve */
		SIprintf(_Retrieving);
		SIflush(stdout);
	}
	if (St_to_term)
	{
		if( Warning_count != 0 )
		{
			r_prompt(ERget(S_RW0025_Hit_RETURN_when_done), FALSE);
		}

		/* 
		** If output is the terminal, then initialize forms to do
		** scrollable output.
		*/
		if  (r_init_frms() != OK)
		{
			return FALSE;						    
		}
		/* set up the bcb (buffer control block) */
		STprintf (title, ERget(S_RW1400_report_title), En_report);
		En_bcb = IIUFint_Init((char *)NULL, title);
		if (En_bcb == NULL)	/* IIUFint_Init failed */
		{
			return FALSE;  
		}
		/* initialize bcb */
		En_bcb->nxrec = r_scroll;  /* routine to handle scrolling */
		En_bcb->req_begin = TRUE;
		En_bcb->req_complete = FALSE;
		En_bcb->eor_warning = FALSE;
		LOdelete(&En_bcb->bfloc);  /* check directory is writable */
		En_bcb->nrecs = 0;
		En_bcb->mxcol = 0;
		En_bcb->print_time = FALSE;
		if (En_bcb->rd_ahead)
		{
			MEfree(En_bcb->rd_ahead);
			En_bcb->rd_ahead = NULL;
		}
		/* get first screen to display */
		if (!IIUFmro_MoreOutput(En_bcb, En_bcb->mx_rows-2, NULL))
		{
			r_end_frms();
			/* suppress message if undocumented flag is used */
			if (!St_copyright)
			{
				SIprintf(ERget(S_RW0045_No_data_in_table));
			}
			SIflush(stdout);
			return FALSE;  
		}
		STcopy (ERx("rwoutput.hlp"), help_scr);
		STcopy (ERget(S_RW13F1_RW_output_helpfile), title);
		STcopy (ERget(S_RW1408_print_report_title), pr_title);
		STcopy (ERget(S_RW1409_file_report_title), file_title);

		/* If there is nothing to display, then just exit */
		if (En_bcb->rows_added != 0) 
		{
			/*
			** If the pagelength is equal to screen display size
			** (4 less lines for the report title, status line, 
			** solid line and menu line in the scrollable output)
			** then do NOT scroll keeping the current line visible.
			** This is the default behavior.  Want to scroll a 
			** full page at a time.
			*/
			if (St_p_length == (En_lines-4))
				/* 
				** page length is the same as window size, so 
				** want page scrolling 
				*/
				scrl_fl = FALSE;
			else
				/*
				** different page size so want to scroll, 
				** leaving the one line for context.
				*/
				scrl_fl = TRUE;
			if (!IIUFdsp_Display(En_bcb, NULL, help_scr, title, 
				scrl_fl, pr_title, file_title, FALSE))
			{
				return FALSE;  
			}			
		}
		IIUFdone (En_bcb);
	}
	else 
	{ 
		while (r_getrow() == OK)
		{
			r_nxt_row();	/* process next row */
		}
		return (r_do_end(&loc));
	} 
	return TRUE;
}
Beispiel #2
0
i4
IIgetfldio(i2 *ind, i4 variable, i4 type, i4 len, PTR data, char *name)
{
	char			*namestr;
	char			fbuf[MAXFRSNAME+1];
	DB_EMBEDDED_DATA	edv;
	DB_DATA_VALUE		*dbvptr;
	DB_DATA_VALUE		oper_dbv;
	DB_DATA_VALUE		dbvcop;
	i4			oper;
	ADF_CB			*cb;
	bool			errflag = FALSE;
	i4			getop = 0;
	i4			(*oldproc)();
	bool			disp_msgs = TRUE;

	/*	Check field name for validity  */

	namestr = IIstrconv(II_CONV, name, fbuf, (i4)MAXFRSNAME);
	if (namestr == NULL)
	{
		IIFDerror(RTRFFL, 2, IIfrmio->fdfrmnm, ERx(""));
		return(FALSE);
	}

	/*  Set up an EDV to describe the caller's parameters.  */

	edv.ed_type = type;
	edv.ed_length = len;
	edv.ed_data = (PTR) data;
	edv.ed_null = ind;
	
	cb = FEadfcb();

	if (IIfrscb->frs_globs->enabled & GETMSGS_OFF)
	{
	    disp_msgs = FALSE;
	    oldproc = IIseterr(IIFRgmoGetmsgsOff);
	}

	/*
	**  If getting an 'oper', not a value, special processing required.
	**  Operators are not returned from FRAME as DBV's, so we must build
	**  one so we can follow the normal path and convert to the final EDV.
	*/

	getop = IIgetoper( (i4) 0 );

	if ( getop )
	{
		oper_dbv.db_datatype = DB_INT_TYPE;
		oper_dbv.db_length = sizeof(i4);
		oper_dbv.db_prec = 0;
		oper_dbv.db_data = (PTR) &oper;

		/*
		** Make sure the frame is in Query mode, else return NOOP.
		*/
		if (IIfrmio->fdrunmd != fdrtQRY)
			oper = fdNOP;
		else
			FDqryop( IIfrmio->fdrunfrm, namestr, (i4 *)
				oper_dbv.db_data );

		dbvptr = &oper_dbv;
	}
	else if (IIfrmio->fdrunmd == fdrtQRY)
	{
		/*
		**	If in query mode, we must use a different routine
		**	to retrieve the data portion of the field.  This
		**	routine also strips off the operator.
		*/

		if (!FDqryfld(IIfrmio->fdrunfrm, namestr, &dbvptr))
			errflag = TRUE;
	}
	else
	{
		IIfrscb->frs_event->eval_aggs = TRUE;

		/*
		**	Get data portion of the field
		*/

		if (!FDgetfld(IIfrmio->fdrunfrm, namestr, &dbvptr))
			errflag = TRUE;

		IIfrscb->frs_event->eval_aggs = FALSE;
	}

	/*
	**  If "errflag" is set at this point, then it was not
	**  possible to get the DB_DATA_VALUE pointer for a field.
	**
	**  Trim trailing blanks on character-type fields
	*/
	if ( errflag == FALSE && ( IIftrim( dbvptr, &dbvcop ) != OK ) )
		errflag = TRUE;

	/*
	**  Convert the DBV containing the field's value to an EDV
	*/

	if ( errflag == FALSE && ( adh_dbcvtev( cb, &dbvcop, &edv ) != OK ) )
	{
		if (cb->adf_errcb.ad_errcode == E_AD1012_NULL_TO_NONNULL)
		{
			IIFDerror(RTRNLNNL, 2, IIfrmio->fdfrmnm, namestr);
		}
		else
		{
			IIFDerror(RTGFERR, 2, IIfrmio->fdfrmnm, namestr);
		}
		errflag = TRUE;
	}

	if (!disp_msgs)
	    _VOID_ IIseterr(oldproc);

	if ( errflag == TRUE )
		return (FALSE);
	else
		return (TRUE);
}
Beispiel #3
0
/*
** Writes or erases a transaction log and displays a completion thermometer.
**
** 'context' must not be NULL, and defaults for element 0 & 1 of context
** must have been set.
*/
i4
write_transaction_log(bool create, PM_CONTEXT *context,
	char *log_dir[], char *log_file[],
	void (*message)(char *), void (*init_graph)(bool, i4), 
	i4 graph_size, void (*update_graph)())
{

# define LG_PAGE_SIZE		2048L
# define LG_NUMBER_OF_PAGES	32L	/* Number of pages to write at a time */

    DI_IO 		dio[LG_MAX_FILE];
    char 		buf[LG_PAGE_SIZE * LG_NUMBER_OF_PAGES];
    char		nodename[GL_MAXNAME];
    i4  		i, j, marker, count, num_logs;
    i4 		num_pages, page, part_size, remainder, loop;
    CL_ERR_DESC 	err;
    char		*string;
    LOCATION 		loc[LG_MAX_FILE];
    char 		locbuf[MAX_LOC + 1];
    char 		*path[LG_MAX_FILE];
    i4  		LOinfo_flag;
    LOINFORMATION 	loc_info;
    i8 		size;
    CS_SCB 		scb;
    bool		size_in_kbytes = FALSE;

    MEfill( sizeof( scb ), 0, ( PTR ) &scb ); 
    
    ++graph_size;

    /* Prepare transaction for log LOCATION(s) */
    for (num_logs = 0; num_logs < LG_MAX_FILE; num_logs++)
    {
	if (log_dir[num_logs] == 0)
	    break;
	STcopy( log_dir[num_logs], locbuf );
	LOfroms( PATH, locbuf, &loc[num_logs] );
	LOfstfile( log_file[num_logs], &loc[num_logs] );
	LOtos( &loc[num_logs], &path[num_logs] );
    }

    /* get size (in bytes) of log file to be created or erased */
    if( create )
    {
	STATUS status;
	char *value;
	bool havevalue = FALSE;

	status = PMmGet( context, ERx( "$.$.rcp.file.kbytes" ), &value );
	if ( status == OK )
	{
	    havevalue = TRUE;
	    size_in_kbytes = TRUE;
	}

	if ( havevalue == FALSE )
	{
	    status = PMmGet( context, ERx( "$.$.rcp.file.size" ), &value );
	    if ( status == OK )
		havevalue = TRUE;
	}

	if ( havevalue == FALSE )
	{
	    if ( message != NULL )
	    {
		char msg[ BIG_ENOUGH ];
		STprintf( msg, ERx( "%s %s" ),
			PMmExpandRequest( context,
			ERx( "$.$.rcp.file.kbytes" ) ),
			"not found." );
		message( msg );
	    }
	    return( 0 );	
	}
	CVal8( value, &size );
    }
    else
    {
	LOinfo_flag = LO_I_SIZE;
	size = 0;

	for (i = 0; i < num_logs; i++)
	{
	    if ( LOinfo( &loc[i], &LOinfo_flag, &loc_info ) != OK )
	    {
		if ( message != NULL )
		{
		    char msg[ BIG_ENOUGH ];

		    STprintf( msg,
			    "Unable to get size of transaction log:\n\n\t%s",
			    path[i] );	
		    (*message)( msg );
		}
		return( 0 );	
	    }
	    else
		size += loc_info.li_size;
	    if ((LOinfo_flag & LO_I_SIZE) == 0)
		break;
	}

	if ( (LOinfo_flag & LO_I_SIZE) == 0 || size == 0L)
	{
	    STATUS status;
	    char *value;
	    bool havevalue = FALSE;

	    status = PMmGet( context, ERx( "$.$.rcp.file.kbytes" ), &value );
	    if ( status == OK )
	    {
		havevalue = TRUE;
		size_in_kbytes = TRUE;
	    }

	    if ( havevalue == FALSE )
	    {
		status = PMmGet( context, ERx( "$.$.rcp.file.size" ), &value );
		if ( status == OK )
		    havevalue = TRUE;
	    }

	    if ( havevalue == FALSE  )
	    {
		if ( message != NULL )
		{
		    char msg[ BIG_ENOUGH ];

		    STprintf( msg, ERx( "%s %s." ),
			    PMmExpandRequest( context,
			    ERx( "$.$.rcp.file.kbytes" ) ),
			    "not found." );
		    message( msg );
		}
		return( 0 );	
	    }
	    CVal8( value, &size );
	}
    }

    for (i = 0; i < num_logs; i++)
    {
	if ( create && LOexist( &loc[i] ) == OK )
	{
		char msg[ BIG_ENOUGH ];

		if ( message != NULL )
		{
			STprintf( msg, "%s already exists.", path[i] ); 
			(*message)( msg ); 
			STprintf( msg, "To create a new transaction log, you must first delete all partitions of the old one." ); 
			(*message)( msg ); 
		}
		return( 0 );	
	}
    }

    if ( CSinitiate( (i4 *) NULL, (char ***) NULL, (CS_CB *) NULL )
	    != OK )
    {
	    if ( message != NULL )
		    message( "Unable to connect to shared memory" );
	    return( 0 );	
    }

    CSset_sid( &scb );

    /* create DI file */
    for (i = 0; i < num_logs; i++)
    {
	if ( create && DIcreate( &dio[i], 
		log_dir[i],  (u_i4)STlength(log_dir[i]), 
		log_file[i], (u_i4)STlength(log_file[i]),
		(i4)LG_PAGE_SIZE, &err) != OK )
	{
	    char msg[ BIG_ENOUGH ];

	    if ( message != NULL )
	    {
		STprintf( msg,
			"Unable to create transaction log:\n\n\t%s",
			path[i] );	
		(*message)( msg );
	    }
	    return( 0 );
	}

	/* open DI file */
	if ( DIopen( &dio[i],
		log_dir[i],  (u_i4)STlength(log_dir[i]), 
		log_file[i], (u_i4)STlength(log_file[i]),
		(i4)LG_PAGE_SIZE, DI_IO_WRITE, 0, &err) != OK )
	{
	    if ( message != NULL )
	    {
		char msg[ BIG_ENOUGH ];

		STprintf( msg,
			"Unable to open transaction log:\n\n\t%s",
			path[i] );	
		(*message)( msg );
	    }
	    return( 0 );
	}
    }

    if ( size_in_kbytes == FALSE )
	size = (size + 1023) / 1024;

    (*init_graph)( create, (i4) size );

    num_pages = size / (LG_PAGE_SIZE/1024);

    part_size = num_pages / num_logs;

    /* Readjust num_pages to be a multiple of num_logs */
    num_pages = part_size * num_logs;

    loop = part_size / LG_NUMBER_OF_PAGES;
    remainder = part_size % LG_NUMBER_OF_PAGES;

    marker = loop / graph_size;

    /* Fill buffer with zeroes */
    MEfill( sizeof( buf ), 0 , buf);

    for (i = 0; i < num_logs; i++)
    {
	if ( create &&
		DIalloc( &dio[i], part_size, &page, &err ) != OK )
	{
	    DIdelete( &dio[i], log_dir[i], (u_i4)STlength( log_dir[i] ),
		    log_file[i], (u_i4)STlength( log_file[i] ), &err );
	    if ( message != NULL )
		    (*message)( "Unable to allocate space in transaction log file." );
	    return( 0 );
	}
    }

    count = 0;
    for( j = 0; j < loop; j++ )
    {
	i4	n = LG_NUMBER_OF_PAGES;
	i4	page_no = j * n;

	for (i = 0; i < num_logs; i++)
	{
	    if ( DIwrite( &dio[i], &n, page_no, 
			buf, &err ) != OK )
	    {
		DIdelete( &dio[i], 
		    log_dir[i], (u_i4)STlength(log_dir[i]),
		    log_file[i], (u_i4)STlength(log_file[i]),
		    &err );
		if ( message != NULL )
			(*message)( "Unable to continue writing transaction log." );
		return( 0 );
	    }
	}

	if ( j >= marker && j % marker == 0 &&
		(f4) ((f4) j / (f4) loop) >= ((f4) count + 1) /
		graph_size )
	{
	    ++count;
	    (*update_graph)();
	    SIflush( stdout );
	}
    }

    if (remainder)
    {
	i4	page_no = loop * LG_NUMBER_OF_PAGES;

	for (i = 0; i < num_logs; i++)
	{
	    if ( DIwrite( &dio[i], &remainder, page_no,
			buf, &err ) != OK )
	    {
		DIdelete( &dio[i], 
		    log_dir[i], (u_i4)STlength(log_dir[i]),
		    log_file[i], (u_i4)STlength(log_file[i]),
		    &err );
		if ( message != NULL )
			(*message)( "Unable to continue writing transaction log." );
		return( 0 );
	    }
	}
    }

    for (i = 0; i < num_logs; i++)
    {
	if ( DIforce( &dio[i], &err ) != OK )
	{
	    DIdelete( &dio[i], log_dir[i], (u_i4)STlength(log_dir[i]),
		    log_file[i], (u_i4)STlength(log_file[i]), &err );
	    if ( message != NULL )
		(*message)( "Unable to force changes to transaction log." );
	    return( 0 );
	}

	if ( create && DIflush( &dio[i], &err ) != OK )
	{
	    DIdelete( &dio[i], log_dir[i], (u_i4)STlength(log_dir[i]),
		    log_file[i], (u_i4)STlength(log_file[i]), &err );
	    if ( message != NULL )
		(*message)( "Unable to flush transaction log to disk." );
	    return( 0 );
	}

	if( DIclose( &dio[i], &err ) != OK)
	{
	    DIdelete( &dio[i], log_dir[i], (u_i4)STlength(log_dir[i]),
		    log_file[i], (u_i4)STlength(log_file[i]), &err );
	    if ( message != NULL )
		(*message)( "Unable to finish writing transaction log." );
	    return( 0 );
	}
    }

    return( (i4) size );
}
Beispiel #4
0
static	STATUS	mmsModifyModuleStar();
static  VOID	pmsPrintModuleStatus();

GLOBALREF       bool    IIDDsilent;
GLOBALREF	i4	IIDDpagesize;

static VOID	DDexit();
static char	*dbname;
static char	*uname;
static char	*xflag;
static bool	Wait	= FALSE;
static bool	nowait	= FALSE;
static char	*Wait_final;
static i4	page_size = 0;
#ifdef NT_GENERIC
static char     *connect_w = ERx("");
#else
static char     *connect = ERx("");
#endif

static const char _Pgm[]	= ERx("modifyfe");
static const char _Empty[]	= ERx("");
static const char _Wait[]	= ERx("+w");
static const char _Nowait[]	= ERx("-w");

  static ARG_DESC args[] =
{
    /* Required arguments */
    {ERx("database"),	 DB_CHR_TYPE,	FARG_PROMPT,	(PTR) &dbname},

    /* Optional arguments */
Beispiel #5
0
i4
Is_it_If_statement(FILE *testFile,i4 *counter,bool Ignore_it)
{
    char                  *cp1 = NULL ;
    char                  *cp2 = NULL ;
    i4                     cmd ;
    bool                   yes_its_if = FALSE ;
    bool                   yes_its_tc = FALSE ;

    cmd = 0;
    if ((!shellMode)&&(SEP_CMstlen(lineTokens[0],0) > 1)&&
	(CMcmpcase(lineTokens[0],ERx(".")) == 0))
    {
	cp1 = buffer_1 ;		/* Fix the ".if" statement. */
	cp2 = buffer_2 ;

	STcopy(buffer_1, holdBuf);
	CMcpyinc(cp1,cp2);
	CMcpychar(ERx(" "),cp2);
	CMnext(cp2);
	STcopy(cp1, cp2);
	STcopy(buffer_2, buffer_1);
	break_line(buffer_2, counter, lineTokens);
    }

    cmd = classify_cmmd(sepcmmds, lineTokens[1]);
    if (cmd == IF_CMMD || cmd == ELSE_CMMD || cmd == ENDIF_CMMD)
    {
	yes_its_if = TRUE;
    }
    else if (cmd == TEST_CASE_CMMD || cmd == TEST_CASE_END_CMMD)
    {
	yes_its_tc = TRUE;
    }

    if (yes_its_if || yes_its_tc)
    {
	append_line(holdBuf, 0);

	if (Ignore_it)
	    ignore_silent == TRUE;

	if (yes_its_if)
	{
	    process_if(testFile, lineTokens, cmd);
	}
	else if (yes_its_tc)
	{
	    if (cmd == TEST_CASE_CMMD)
	    {
		testcase_start(&lineTokens[1]);
	    }
	    else if (cmd == TEST_CASE_END_CMMD)
	    {
		testcase_end(FALSE);
	    }
	}

	if (Ignore_it)
	    ignore_silent == FALSE;
    }
    else
    {
	cmd = 0;
    }

    return (cmd);
}
Beispiel #6
0
static DB_DATA_VALUE Op_dpart = AFE_DCMP_INIT_MACRO(DB_CHA_TYPE,5,NULL);
static DB_DATA_VALUE *Op_db[2] = { &Op_dpart, NULL };
static AFE_OPERS Ops = { 2, Op_db };

/*
** set up a "convert to string" DB_DATA_VALUE to use
*/
static GRC_STORE Dsa;
static DB_DATA_VALUE Dstr = AFE_DCMP_INIT_MACRO(DB_LTXT_TYPE,GRC_SLEN-1,(PTR) &Dsa);

/*
** format for date string conversion for fields / legends.  Df_str is
** set to NULL after Dfmt has been built.
*/
static FMT *Dfmt;
static char *Df_str = ERx("d\"3-feb-1901\"");

/**
** Name: grcoerce.c - graf library type coercion routine.
**
** Description:
**	This are the routines used to coerce types when mapping a
**	query to a graph:
**
**	GRcoerce_type: coerce a database type into internal types
**	used to produce graphics data, and optionally, into
**	a string.
**
**	GRzero_pt: produce a data value for use in filling in "empty"
**	spots when dense data must be constructed.
**
Beispiel #7
0
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;
}
Beispiel #8
0
STATUS
open_log(char *testPrefix,char *testSufix,char *username,char *errbuff)
{
    SYSTIME                atime ;
    char                   uname [20] ;
    char                   logFileName [MAX_LOC+1] ;
    char                   timestr [TEST_LINE] ;
    char                   buffer [MAX_LOC+1] ;
    char                  *dot = NULL ;
    char                  *cptr = NULL ;
	char				   year[5];

    if (shellMode)
        STpolycat(3, testPrefix, ERx("."), testSufix, logFileName);
    else if (updateMode)
            STpolycat(2, testPrefix, ERx(".upd"), logFileName);
         else
            STpolycat(2, testPrefix, ERx(".log"), logFileName);

    if (outputDir)
    {
	if (outputDir_type == PATH)
	{
	    STcopy(outputDir, buffer);
	    LOfroms(PATH, buffer, &logloc);
	    LOfstfile(logFileName, &logloc);
	    LOtos(&logloc, &cptr);
	}
	else
	{
	    LOtos(&outLoc,&cptr);
	}
	STcopy(cptr, logname);
    }
    else
        STcopy(logFileName, logname);
    
    
    if (LOfroms(FILENAME & PATH, logname, &logloc) != OK)
    {
	STprintf(errbuff,ERx("ERROR: could not get location for log file"));
	return(FAIL);
    }
    if (SIopen(&logloc,ERx("w"),&logptr) != OK)
    {
	STprintf(errbuff,ERx("ERROR: could not open log file"));
	return(FAIL);
    }

    if (!updateMode)
    {
	append_line(ERx("/*"),1);

	copyright_year(&year[0]);
	STprintf(buffer, ERx("Copyright (c) %s Ingres Corporation"), &year);
	append_line(buffer, 1);
	append_line(ERx(" "), 1);

	STprintf(buffer,ERx("\tTest Name: %s.%s"), testPrefix, testSufix);
	append_line(buffer,1);
	TMnow(&atime);
	TMstr(&atime,timestr);
	STprintf(buffer,ERx("\tTime: %s"),timestr);
	append_line(buffer,1);
	dot = uname;
	if (username == NULL || *username == '\0')
	    IDname(&dot);
	else
	    STcopy(username,uname);
	STprintf(buffer,ERx("\tUser Name: %s"),uname);
	append_line(buffer,1);
	STprintf(buffer, ERx("\tTerminal type: %s"), terminalType);
	append_line(buffer,1);
	append_line(ERx(" "),1);
    }

    return(OK);
}
Beispiel #9
0
/*
** The table which converts from a suffix of a file to the
** Right equel language constants for IIlang.
*/
typedef struct {
    char    *acsuffix;
    i4      aclang;
    i4      acci;
    i4      acdml;
} UT_SUFFIX;

# define        UTSUFSIZ        (sizeof(utsuffix)/sizeof(utsuffix[0]))

/* GLOBALDEF's */
GLOBALDEF char  *IIutExtensions[_OLMAX+1][3] = {
    {ERx("c"),      ERx("qc"),      ERx("sc")},
    {FORTRAN,       ERx("qf"),      ERx("sf")},
    {PASCAL,        ERx("qp"),      ERx("sp")},
    {BASIC,         ERx("qb"),      ERx("sb")},
    {COBOL,         ERx("qcb"),     ERx("scb")},
    {ERx(""),       ERx(""),        ERx("")},
    {ADA,           ERx("qa"),      ERx("sa")},
    {ERx(""),       ERx("osl"),     ERx("osq")},
    {ERx(""),       ERx("quel"),    ERx("sql")}
};

/* extern's */

/* static's */
static STATUS   getLanguage();
static UT_SUFFIX * _utSuffix ();
Beispiel #10
0
STATUS
disp_diff(STATUS acmmt,i4 canons)
{
    STATUS                 ioerr ;
    STATUS                 up_canon = FAIL ;
    char                   cmmtfile [50] ;
    char                   canon_upd = '\0' ;
    char                   junk ;
    char                   menu_ans ;
    bool                   conditional_exp ;

    /* initialize diff window */

    conditional_exp = FALSE;
#ifndef NT_GENERIC
    TEwrite(CL,STlength(CL));
    TEflush();
#endif
    diffW = TDnewwin(MAIN_ROWS,MAIN_COLS,FIRST_MAIN_ROW,FIRST_MAIN_COL);
    diffstW = TDnewwin(STATUS_ROWS,STATUS_COLS,FIRST_STAT_ROW,FIRST_MAIN_COL);
    TDrefresh(diffstW);
    TDrefresh(diffW);

    screenLine = 0;
    old_page = 0;
    bottom_page = 0;
    myPages = NULL;
    ioerr = OK;

    STprintf(cmmtfile,ERx("ct%s.stf"),SEPpidstr);
    diffPtr = sepDiffer->_fptr;

    /*
    **	display diff
    */

    page_down(0);
    if (updateMode)
	    up_canon = OK;

    for (;;)
    {
	if (updateMode)
	{
	    if (editCAns == '\0')
		disp_prompt(DIFF_MENU_M,&menu_ans,DIFF_MENU_AM);
	    else
		menu_ans = 'e';
	}
	else
	    disp_prompt(DIFF_MENU,&menu_ans,DIFF_MENU_A);

	switch (menu_ans)
	{
	   case 'A': case 'a':
		    ioerr = FAIL;
		    break;
	   case 'P': case 'p':
		    page_up();
		    break;
	   case 'N': case 'n':
		    page_down(0);
		    break;
	   case 'C': case 'c':
		    if (acmmt == FAIL && !updateMode)
			disp_prompt(ERx("no comments attached to this command"),
			    &junk,NULL);
		    else
		    {
			edit_file(cmmtfile);
			TDtouchwin(diffW);
			TDrefresh(diffW);
		    }
		    break;
	   case 'E': case 'e':
		    if (up_canon == OK)
		    {
			if (editCAns == '\0')
			{
			    disp_prompt(UPD_CANON,&canon_upd,UPD_CANON_A);
			}
			else
			{
			    canon_upd = editCAns;
			    menu_ans = 'q';
			}

			if (canon_upd == 'M' || canon_upd == 'A' ||
			    canon_upd == 'm' || canon_upd == 'a' )
			    conditional_exp = ask_for_conditional(diffstW,
								  editCAns);

			up_canon = FAIL;
		    }
		    break;
	}
	if (menu_ans == 'Q' || menu_ans == 'q' ||
	    menu_ans == 'A' || menu_ans == 'a' ||
	    menu_ans == 'D' || menu_ans == 'd')
	{
	    disp_prompt(NULLSTR,NULL,NULL);
	    SEPdisconnect = (menu_ans == 'A' || menu_ans == 'a' ||
			     menu_ans == 'D' || menu_ans == 'd');
	    break;
	}
    }

    /*
    **	update test
    */

    if (updateMode)
    {
	LOCATION	cmmtloc;
	short	count;

	/* add comments */

	LOfroms(FILENAME & PATH,cmmtfile,&cmmtloc);
	if (SEP_LOexists(&cmmtloc))
	{
	    append_line(OPEN_COMMENT,1);
	    append_file(cmmtfile);
	    append_line(CLOSE_COMMENT,1);
	    LOdelete(&cmmtloc);
	}

	/* add canons   */
	    
	switch (canon_upd)
	{
	   case 'I':
	   case 'i':
		    append_line(OPEN_CANON,1);
		    append_line(SKIP_SYMBOL,1);
		    append_line(CLOSE_CANON,1);
		    break;
	   case 'M':
	   case 'm':
		    SEPrewind(sepResults, FALSE);
		    if (conditional_exp == TRUE)
		    {
			append_line(OPEN_CANON,0);
			append_line(conditional_prompt,1);
		    }
 		    else
			append_line(OPEN_CANON,1);

		    append_sepfile(sepResults);
		    append_line(CLOSE_CANON,1);
		    append_sepfile(sepGCanons);
		    break;
	   case 'O':
	   case 'o':
		    SEPrewind(sepResults, FALSE);
		    append_line(OPEN_CANON,1);
		    append_sepfile(sepResults);
		    append_line(CLOSE_CANON,1);
		    break;
	   case '\0':
	   case 'E':
	   case 'e':
		    append_sepfile(sepGCanons);
		    break;
	   case 'A':
	   case 'a':
		    append_sepfile(sepGCanons);
		    SEPrewind(sepResults, FALSE);
		    if (conditional_exp == TRUE)
		    {
			append_line(OPEN_CANON,0);
			append_line(conditional_prompt,1);
		    }
		    else
			append_line(OPEN_CANON,1);

		    append_sepfile(sepResults);
		    append_line(CLOSE_CANON,1);
		    break;
	}
    }
    MEtfree(SEP_ME_TAG_PAGES);
    TDdelwin(diffW);
    TDdelwin(diffstW);
    return(ioerr);
}
Beispiel #11
0
STATUS
display_lines()
{
    STATUS                 ret_val ;
    i4                count ;
    char                   dispBuff [TERM_LINE+1] ;
#ifdef NT_GENERIC
    char                  *ptr = NULL;
    i4                     buffCount, i, count2;
    bool                   more_found;
#endif

    for (screenLine = 0;;)
    {
	if ((ret_val = SIread(diffPtr, TEST_LINE, &count, dispBuff)) == FAIL)
	{
	    get_d_answer(ERx("ERROR: read failed on diff file."), dispBuff);
	    return(FAIL);
	}
#ifdef NT_GENERIC
	ptr = dispBuff;
	i = count = 0;
	count2 = TEST_LINE;
	more_found = TRUE;
	while (more_found == TRUE)
	{
	count2 = count2 + count;
	buffCount = 0;
	while (i != count2)
	{
	  if (dispBuff[i] == SEP_ESCAPE)
	  {
	    CMnext(ptr);
	    i++;
	    if (i == count2)
	    {
	      if (diffPtr->_ptr[0] == SEP_ESCAPE)
		buffCount++;
	    }
	    else 
	      if (dispBuff[i] == SEP_ESCAPE)
		buffCount++;
	  }
	  if (i != count2)
	  {
	    i++;
	    CMnext(ptr);
	  }
	}

	if (buffCount > 0)
	{
	  if ((ret_val = SIread(diffPtr, buffCount, &count, ptr)) == FAIL)
	  {
	    get_d_answer(ERx("ERROR: read failed on diff file."), dispBuff);
	    return(FAIL);
	  }
	}
	else
	  more_found = FALSE;
	}
#endif    
 	if (ret_val == ENDFILE || SEPcheckEnd(dispBuff))
	{
	    STprintf(dispBuff, ERx("---  EOF RETURNED  ---"));
	    myPages->final_page = TRUE;
	    disp_d_line(dispBuff, 0, 0);
	    break;
	}
	dispBuff[TEST_LINE + 1] = '\0';
#ifdef NT_GENERIC
	if (dispBuff[TEST_LINE] == -3)
	  dispBuff[TEST_LINE] = '\0';
#endif
 	SEPtranslate(dispBuff, TERM_LINE);
	disp_d_line(dispBuff, 0, 0);
	if (screenLine > LAST_MAIN_ROW)
	    break;
    }
    return(OK);
}  /* display_lines */
Beispiel #12
0
VOID
get_string(WINDOW *wndow,char *question,char *ansbuff)
{
    char                  *prompt = NULL ;
    char                   tempBuffer [TERM_LINE] ;
    char                  *cp = ansbuff ;
    char                  *cptr = NULL ;
    i4                     clen ;
    register i4            i ;

    prompt = SEP_MEalloc(SEP_ME_TAG_NODEL, STlength(question)+5, TRUE,
			 (STATUS *) NULL);

    STprintf(prompt, ERx("%s "), question);
    put_message(wndow, prompt);    
    getstr(wndow, tempBuffer, FALSE);

    /* check if continuation character was entered */

    cptr = SEP_CMlastchar(tempBuffer,0);

    if (CMcmpcase(cptr,cont_char) == 0)
    {
	*cptr = EOS;
	STcopy(tempBuffer,cp);

	clen = SEP_CMstlen(tempBuffer,0);
	for (i=0; i<clen; i++)
	    CMnext(cp);

	TDerase(wndow);
	STprintf(tempBuffer, ERx("%s%s"), prompt, ansbuff);
	SEPprintw(wndow, PROMPT_ROW - 1, PROMPT_COL, tempBuffer);
	STprintf(prompt, ERx("%s%s"), question, cont_char);
	SEPprintw(wndow, PROMPT_ROW, PROMPT_COL, prompt);
	TDrefresh(wndow);
	getstr(wndow,tempBuffer,FALSE);

	/* check if continuation character was entered */

	cptr = SEP_CMlastchar(tempBuffer,0);

	if (CMcmpcase(cptr,cont_char) == 0)
	{
	    i4	    temp;

	    *cptr = EOS;
	    STprintf(prompt, ERx("%s %s"), question, tempBuffer);
	    SEPprintw(wndow, PROMPT_ROW, PROMPT_COL, prompt);
	    STcopy(tempBuffer, cp);

	    STprintf(prompt, ERx("%s%s"), question, cont_char);
	    SEPprintw(wndow, PROMPT_ROW + 1, PROMPT_COL, prompt);
	    /*
	    **	ugly fix to prevent the screen from scrolling when
	    **	typing to the last line of the screen. It will hopefully
	    **	be changed in the future for a more elegant solution
	    */
	    temp = LINES;
	    LINES++;
	    TDrefresh(wndow);
	    getstr(wndow, tempBuffer, FALSE);
	    disp_prompt((char *)NULLSTR, (char *)NULL, (char *)NULL);
	    LINES = temp;
	}
    }
    MEfree(prompt);
    STcopy(tempBuffer, cp);
    TDerase(wndow);
    TDrefresh(wndow);
}
Beispiel #13
0
STATUS
disp_prompt(char *buffer,char *achar,char *range)
{
    STATUS                 ret_val = OK ;
    char                   caracter ;
    char                  *legal = NULL ;
    char                   termBuffer [255] ;
#ifdef NT_GENERIC
    COORD		   coordinate;
    int			   numchars, i;
    char		   tempchar [80];
#endif

    if (achar == NULL)
    {
#ifndef NT_GENERIC
	STprintf(termBuffer,ERx("%s%s%s%s%s"),REG_CHAR,ATTR_OFF,
	    PROMPT_POS,DEL_EOL,buffer);

	TEwrite(termBuffer,STlength(termBuffer));
	TEflush();
#else
	SetConsoleActiveScreenBuffer(hTEconsole);
	coordinate.X=0;
	coordinate.Y=22;
	SetConsoleCursorPosition(hTEconsole, coordinate);
	WriteConsole(hTEconsole, buffer, strlen(buffer), &numchars, NULL);
	coordinate.X=strlen(buffer);
	coordinate.Y=22;
	SetConsoleCursorPosition(hTEconsole, coordinate);
	strcpy (tempchar, " ");
	for (i=2; i<=(80-strlen(buffer)); i++)
	  strcat (tempchar, " ");
	WriteConsole(hTEconsole, tempchar, strlen(tempchar), &numchars, NULL);
#endif
    }
    else
    {
#ifndef NT_GENERIC
	STprintf(termBuffer,ERx("%s%s%s%s%s[ %s ]%s "),REG_CHAR,ATTR_OFF,
	    PROMPT_POS,DEL_EOL,REV_VIDEO,buffer,ATTR_OFF);

	TEwrite(termBuffer,STlength(termBuffer));
	TEflush();
#else
	SetConsoleActiveScreenBuffer(hTEconsole);
	coordinate.X=0;
	coordinate.Y=22;
	SetConsoleCursorPosition(hTEconsole, coordinate);
	SetConsoleTextAttribute(hTEconsole, FOREGROUND_BLUE|BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE|BACKGROUND_INTENSITY);
	STpolycat(3, ERx("[ "), buffer, ERx(" ]"), &termBuffer);
	WriteConsole(hTEconsole, termBuffer, strlen(termBuffer), &numchars, NULL);
	coordinate.X=strlen(termBuffer);
	coordinate.Y=22;
	SetConsoleCursorPosition(hTEconsole, coordinate);
	strcpy (tempchar, " ");
	for (i=2; i<=(80-strlen(termBuffer)); i++)
	  strcat (tempchar, " ");
	SetConsoleTextAttribute(hTEconsole, FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE|FOREGROUND_INTENSITY|BACKGROUND_BLUE);
	WriteConsole(hTEconsole, tempchar, strlen(tempchar), &numchars, NULL);
#endif
	TEinflush();

	for (;;)
	{
	    EXinterrupt(EX_OFF);
#ifdef VMS
	    sys$setast(0);
#endif
	    caracter = TEget(0);
	    EXinterrupt(EX_ON);
#ifdef VMS
	    sys$setast(1);
#endif
	    if (range == NULL || (legal = STindex(range,&caracter,0)) != NULL)
		break;
	    else
	    {
		TEput(BELL);
		TEflush();
	    }		    
	}
	*achar = caracter;
    }
    return (ret_val);
}
Beispiel #14
0
FUNC_EXTERN	GR_DVEC *GTdvcreate();
FUNC_EXTERN	char	*GRtxtstore();

static	i4	deftag = 0;
static	i4	npoints = 6;

static	char	xname[FE_MAXNAME+1];
static	char	yname[FE_MAXNAME+1];
static	char	zname[FE_MAXNAME+1];

static	struct	txtmap {
	char	*str;
	i4	val;
} labels[] =
{
	{ERx("Athens"),1},
	{ERx("London"),2},
	{ERx("New York"),3},
	{ERx("Paris"),4},
	{ERx("Rome"),5},
	{ERx("Tokyo"),6}
};

static	float	pieval[]	= { 40, 25, 10, 5, 15, 5 };
static	float	bary1[]		= { 5, 8, 9.8, 3, 3, 2 };
static	float	bary2[]		= { 14.8, 10, 7, 2, 10, 12 };
static	float	*liney1		= bary1;
static	float	*liney2		= bary2;

/*{
** Name:	map_def		-	get 'default' data for a chart
Beispiel #15
0
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);
	}
}
Beispiel #16
0
/*
** 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;
}
Beispiel #17
0
FUNC_EXTERN	VOID	IIFGti_tblindx();

extern FILE *outfp;
extern METAFRAME *G_metaframe;

/* static's */
static VOID fgqdelete();
static VOID fgqinsert();
static VOID fgqselect();
static VOID fgqmselect();
static VOID fgqdselect();
static VOID fgqupdate();
static VOID check_options();
static i4   check_section();

static const char _and[] 		= ERx("AND");
static const char _delete[] 		= ERx("delete");
static const char _detail[] 		= ERx("detail");
static const char _insert[] 		= ERx("insert");
static const char _select[] 		= ERx("select");
static const char _master[] 		= ERx("master");
static const char _master_detail[] 	= ERx("master_detail");
static const char _null[]   		= ERx("");
static const char _repeat[] 		= ERx("repeated");
static const char _noterm[] 		= ERx("noterm");
static const char _repeated[] 	= ERx("REPEATED ");
static const char _update[] 		= ERx("update");

static char *fgpad;
static i4   sectdx[TAB_DETAIL+1][2];
Beispiel #18
0
/* GLOBALDEF's */

/* extern's */
GLOBALREF FILE *outfp;
GLOBALREF METAFRAME *G_metaframe;

FUNC_EXTERN bool  IIFGnkf_nullKeyFlags();
FUNC_EXTERN MFTAB *IIFGpt_pritbl();
FUNC_EXTERN i4    IIFGnkc_nullKeyCols();
FUNC_EXTERN MFCOL *IIFGmj_MasterJoinCol();
FUNC_EXTERN char *IIFGbuf_pad();


/* static's */
static VOID genSetNulKeys();
static const char _null[]            = ERx("");
static const char _dot[]             = ERx(".");

/*{
** Name:  IIFGsf_SetNullKeyFlags - Gen 4gl to set Nullable key Flag fields.
**
** Description:
**	Process ##GENERATE SET_NULL_KEY_FLAGS  [ MASTER | DETAIL ]  statement.
**
**	Create 4gl statements to set the values of the Flag fields that we
**	need to use when a table has NULLable keys and/or NULLable optimistic
**	locking columns.
**	Generated statements look like:
**
**		IF (<name of NULLable hidden key field or column> IS NULL) THEN
**		    iiNullKeyFlag1 = 1;
Beispiel #19
0
**	    Unicode data that gets through to the tm and provide a means of
**	    altering the default with II_UNICODE_SUBS environment varaiable.
**	15-Sep-2008 (jonj)
**	    SIR 120874: Add ad_dberror inside adf_errcb in ADF_CB static.
**	05-Feb-2009 (wanfr01)
**	    Bug 121617
**	    Do not blindly copy 4 bytes in IIUGnfNowFunc because you might
**	    be copying the value into a long rather than an i4.
*/

static bool	done = FALSE;

static ADF_CB  cb = {
	NULL,					/* adf_srv_cb */
	DB_US_DFMT,				/* adf_dfmt */
	{ERx("$"),ERx(""),DB_LEAD_MONY,2},	/* adf_mfmt */
	{ TRUE, '.' },				/* adf_decimal */
	{					/* adf_outarg */
	  -1,					/* .ad_c0width */
	  -1,					/* .ad_t0width */
	  -1,					/* .ad_i1width */
	  -1,					/* .ad_i2width */
	  -1,					/* .ad_i4width */
	  -1,					/* .ad_f4width */
	  -1,					/* .ad_f8width */
	  -1,					/* .ad_f4prec */
	  -1,					/* .ad_f8prec */
	  -1,					/* .ad_i8width */
	  -1,					/* .ad_2_rsvd */
	  NULLCHAR,				/* .ad_f4style */
	  NULLCHAR,				/* .ad_f8style */
Beispiel #20
0
**	OK if everything ok.
**	status, usually FAIL, if anything goes wrong.
**
** History:
**	9-jun-1987 (Joe)
**		Initial Version
**     22-mar-94 (donc) Bug 59981
**		Replace CI_PART_RUNTIME in preference for CI_ABF_IMAGE
*/

/* Parameter Description */

static ARG_DESC
	args[] = {
		/* Required */
		{ERx("database"),	DB_CHR_TYPE,	FARG_PROMPT,	NULL},
		{ERx("application"),	DB_CHR_TYPE,	FARG_PROMPT,	NULL},
		/* Internal optional */
		{ERx("equel"),		DB_CHR_TYPE,	FARG_FAIL,	NULL},
		/* Optional */
		{ERx("user"),		DB_CHR_TYPE,	FARG_FAIL,	NULL},
		{ERx("open"),		DB_BOO_TYPE,	FARG_FAIL,	NULL},
		{ERx("warning"),	DB_BOO_TYPE,	FARG_FAIL,	NULL},
		{ERx("5.0"),		DB_BOO_TYPE,	FARG_FAIL,	NULL},
		{ERx("groupid"),	DB_CHR_TYPE,	FARG_FAIL,	NULL},
		{ERx("roleid"),		DB_CHR_TYPE,	FARG_FAIL,	NULL},
		{ERx("password"),	DB_BOO_TYPE,	FARG_FAIL,	NULL},
		{ERx("force"),		DB_BOO_TYPE,	FARG_FAIL,	NULL},
		{ERx("executable"),	DB_CHR_TYPE,	FARG_FAIL,	NULL},
		{ERx("connect"),	DB_CHR_TYPE,	FARG_FAIL,	NULL},
		{ERx("constants_file"),	DB_CHR_TYPE,	FARG_FAIL,	NULL},
Beispiel #21
0
int
main(int argc, char *argv[])
{
#define 	MAXBUF	4095

	char 	buf[ MAXBUF+1 ];
	int	iarg, ibuf, ichr;
	bool	debug = FALSE;
        CL_ERR_DESC     err_code;
        char		*p1 = NULL;
        char		pid[MAXBUF];
        char    	*database = ERx("");
        char    	*user = ERx("");
        char    	*xmlfile = ERx("");
        char    	sql_fname[LO_NM_LEN + 1];
        char    	*work_dir = NULL;
        char    	directory[MAX_LOC + 1]; 
        char    	*tmp_dir = NULL;
        char		tmp_buf[MAX_LOC + 1];
        char		subdir_buf[MAX_LOC + 1];
        char		sql_loc_buf[MAX_LOC + 1];
	char		*progname; 
        LOCATION    tmp_dir_loc;
        LOCATION    tmp_subdir_loc;
        LOCATION    tmp_buff_loc;
        LOCATION    curr_loc;
        LOCATION    sql_file_loc;
	char        *password = ERx("");
	char        *groupid = ERx("");
	ARGRET  rarg;
        i4      pos;
	LOCATION    xmlfile_loc;
	FILE	    *xmlfile_read;
	STATUS	    stat = FAIL;
	char	    dbuf[256];
	char	    encode[32];
        u_i4        tmppid;
        TM_STAMP    tm_stamp;


	/* Tell EX this is an ingres tool. */
   	(void) EXsetclient(EX_INGRES_TOOL);

	/* Call IIUGinit to initialize character set attribute table */
	if ( IIUGinit() != OK)
	    PCexit(FAIL);

	progname = ERget(F_XM0006_IMPXML);
	FEcopyright(progname, ERx("2001")); 

	/*
	** Get arguments from command line
	*/

	/* required parameters */

	if (FEutaopen(argc, argv, ERx("xmlimport")) != OK)
          PCexit(FAIL);

	/* database name is required */
	if (FEutaget(ERx("database"), 0, FARG_PROMPT, &rarg, &pos) != OK)
          PCexit(FAIL);
	database = rarg.dat.name;

        if (FEutaget(ERx("xmlfile"), 0, FARG_PROMPT, &rarg, &pos) != OK)
            PCexit(FAIL);
        xmlfile = rarg.dat.name;

        if (FEutaget(ERx("user"), 0, FARG_FAIL, &rarg, &pos) == OK)
            user = rarg.dat.name;

        if (FEutaget(ERx("password"), 0, FARG_FAIL, &rarg, &pos) == OK)
        {
            char *IIUIpassword();

            if ((password = IIUIpassword(ERx("-P"))) == NULL)
            {
                FEutaerr(BADARG, 1, ERx(""));
                PCexit(FAIL);
            }
        }

        if (FEutaget(ERx("groupid"), 0, FARG_FAIL, &rarg, &pos) == OK)
          groupid = rarg.dat.name;

        if (FEutaget(ERx("debug"), 0, FARG_FAIL, &rarg, &pos) == OK)
	  debug = TRUE;

        ibuf = STlength(buf); 

        /* b121678: pid is no longer based on process id, but it's
        ** a random number instead.
        */
        PCpid(&tmppid);
        TMget_stamp(&tm_stamp);
        MHsrand2(tmppid * tm_stamp.tms_usec);
        STprintf(pid, "%x", MHrand2());

#ifdef xDEBUG
        SIprintf(" the pid is: %s \n", pid);
#endif

        /* create the sql file */
	/* Avoid a name like "foo.xml.sql" on VMS, use pid.sql instead */
        STcopy(pid, sql_fname); 
        STcat(sql_fname, ".sql");

        /* 
        ** create in the temp location a directory 
        ** with the name pid. set this directory 
        ** as the working directory for impxml
        */

      NMloc (TEMP, PATH, NULL, &tmp_dir_loc);	
      /* make a location for TMP loc */
      /* print location name */
      LOcopy (&tmp_dir_loc, tmp_buf, &tmp_buff_loc);
      LOtos (&tmp_buff_loc, &tmp_dir);

#ifdef xDEBUG
      SIprintf ("temploc: %s \n", tmp_dir);
#endif

      /* make a subdir location with filename, pid */
      STcopy (pid, subdir_buf);				
      /* Initialize result loc so that everyone is happy */
      LOcopy (&tmp_dir_loc, sql_loc_buf, &sql_file_loc); 
      /* Generate location for temp subdirectory */
      if (LOfaddpath (&tmp_dir_loc, subdir_buf, &sql_file_loc) != OK)
      {
	 IIUGerr(E_XM0007_Locname_Failed, UG_ERR_FATAL, 2, tmp_dir, subdir_buf);
	 /* NOTREACHED */
      }

      /* print the location name */
      LOcopy (&sql_file_loc, tmp_buf, &tmp_buff_loc);    
      LOtos (&tmp_buff_loc, &work_dir);

#ifdef xDEBUG
	SIprintf ("work dir loc: %s \n", work_dir);
#endif

      /* create the subdir */
      if (LOcreate (&sql_file_loc) != OK) {
	 IIUGerr(E_XM0008_Create_Temp_Dir, UG_ERR_ERROR, 1, work_dir);
	 PCexit(FAIL);
      }

      STcopy(work_dir, directory);

#ifdef xDEBUG
      SIprintf ("sql file name: %s \n", sql_fname);
      SIprintf ("xml file name: %s \n", xmlfile);
#endif

      /* Execute the command impxml */	
      STprintf (buf, ERx( "impxml -d=\"%s\" -o=\"%s\" " ),  directory, sql_fname);

      /* encoding? */
      if ( (LOfroms(PATH & FILENAME, xmlfile, &xmlfile_loc) != OK)
          ||
	  (SIopen(&xmlfile_loc, "r", &xmlfile_read) != OK)
	  ||
	  (xmlfile_read == NULL)
	 )
      {
	  IIUGerr(E_XM0009_Cannot_Open_File, UG_ERR_ERROR, 1, xmlfile);
          PCexit(FAIL);
      }

      /* scan XML declaration for encoding, if any */
      if (stat = SIgetrec(dbuf, sizeof(dbuf) - 1, xmlfile_read) == OK)
      {
	  char 	*d = dbuf;
	  i4	i = 0;

	  for (d = dbuf; d != (dbuf + sizeof(dbuf)); d++)
	  {
	      if (MEcmp(d, ERx("encoding="), sizeof(ERx("encoding=")) - 1) == 0)
	      {
		  d += sizeof(ERx("encoding="));
		  while (MEcmp (d, "\'", sizeof(char)) && MEcmp(d, "\"", sizeof(char)))
		      MEcopy(d++, sizeof(char), &encode[i++]);
		  encode[i++] = MIN_CHAR;
		  encode[i] = EOS;
		  STcat(buf, ERx("-x="));
		  STcat(buf, encode);
		  break;
	      }
	  }
      }
      else if (stat != ENDFILE)
      {
          /* unable to read file, report error */
	  IIUGerr(E_XM000A_Cannot_Read_File, UG_ERR_ERROR, 1, xmlfile);
	  PCexit(FAIL);
      }

      stat = SIclose(xmlfile_read);

      STcat(buf, xmlfile);

#ifdef xDEBUG
      SIprintf ( " query send: %s \n", buf);
#endif

      /* 	Execute the command.  
      */

      if( PCcmdline((LOCATION *) NULL, buf, PC_WAIT, 
  		(LOCATION *)NULL, &err_code) != OK )
      {
	if (!debug)
	    LOdelete(&sql_file_loc);
	PCexit(FAIL);
      }

      /*
      **	we should run the sql script 
      **	sql dbname < new_filename
      */
      
      /* save the current location */
      LOcopy(&sql_file_loc, tmp_buf, &curr_loc);

      /* make a full location path to the location first */
      LOfroms(FILENAME, sql_fname, &tmp_buff_loc);
      LOstfile(&tmp_buff_loc, &curr_loc);
      LOcopy (&curr_loc, tmp_buf, &tmp_buff_loc);
      LOtos (&tmp_buff_loc, &tmp_dir);

#ifdef xDEBUG
      SIprintf ("sql file is: %s \n", tmp_dir);
#endif

      /* No space between < and input file for VMS */
      STprintf(buf, ERx( "sql -s %s %s %s %s <%s" ),
			database, user, password, groupid, tmp_dir);
#ifdef xDEBUG
      SIprintf (" query send: %s \n", buf);
#endif

      /*
      **	Execute the command.
      */

      if( PCcmdline((LOCATION *) NULL, buf, PC_WAIT, 
              (LOCATION *)NULL, &err_code) != OK )
      {
	if (!debug)
	    LOdelete(&sql_file_loc);
        PCexit(FAIL); 
      }

      /*
      **    Delete the location
      */
      if (!debug)
	LOdelete(&sql_file_loc);

      PCexit(OK);
}
Beispiel #22
0
**	The number of longnat indices that can fit on each page following
**	the leading index page.
*/
#define PERBLOCK	(sizeof(INDEX_PAGE)/sizeof(i4))

#define SRECFACTOR	(sizeof(INDEX_PAGE)/512)


/*
**  Language table
**
**  This table is used to get directory name and internal code.
**  (in ERlangcode and ERlangstr)
*/
GLOBALDEF ER_LANGT_DEF	ER_langt[] = {
	ERx("english"),  	1   ,
	ERx("japanese"), 	2   ,
	ERx("french"),   	3   ,
	ERx("flemish"),  	4   ,
	ERx("german"),   	5   ,
	ERx("italian"),  	6   ,
	ERx("dutch"),    	7   ,
	ERx("finnish"),  	8   ,
	ERx("danish"),   	9   ,
	ERx("spanish"),  	10  ,
	ERx("swedish"),  	11  ,
	ERx("norwegian"),	12  ,
	ERx("hebrew"),		13  ,
	ERx("korean"),		14  ,
	ERx("chinese"),		15  ,
	ERx("thai"),		16  ,
Beispiel #23
0
STATUS
gca_ns_init( VOID )
{
#ifdef GCF_EMBEDDED_GCN

    char	*ptr, host[ 50 ];
    char	*pm_default[ PM_MAX_ELEM ];
    i4		count;
    STATUS	status = OK;

    /*
    ** We do not want to initialize the embedded Name Server
    ** interface if this is the actual Name Server.  The Name
    ** Server initializes the interface before initializing
    ** GCA, so check to see if IIGCn_static is initialized,
    ** indicating that gcn_init() has already been called.
    */
    if ( IIGCn_static.maxsessions )  return( OK );

    /*
    ** Check to see if tracing of Name Server code
    ** is enabled (for whoever we are) before resetting
    ** PM for the Name Server.
    */
    gcu_get_tracesym( "II_GCN_TRACE", "!.gcn_trace_level", &ptr );
    if ( ptr  &&  *ptr )  CVal( ptr, &IIGCn_static.trace );

    /*
    ** Save current PM defaults and set up for Name Server.
    */
    for( count = 0; count < PM_MAX_ELEM; count++ )
	pm_default[ count ] = PMgetDefault( count );

    PMsetDefault( 0, SystemCfgPrefix );	/* Name Server defaults */
    PMsetDefault( 1, PMhost() );
    PMsetDefault( 2, ERx( "gcn" ) );

    for( count = 3; count < PM_MAX_ELEM; count++ )
	PMsetDefault( count, NULL );

    /*
    ** Initialize embedded Name Server.
    */
    GChostname( host, sizeof( host ) );
    if ( gcn_srv_init() != OK  ||  gcn_srv_load( host, NULL ) != OK )
	status = E_GC0013_ASSFL_MEM;

    /*
    ** Reset PM defaults.
    */
    for( count = 0; count < PM_MAX_ELEM; count++ )
	PMsetDefault( count, pm_default[ count ] );


    return( status );

#else /* GCA_EMBEDDED_GCN */

    return( OK );

#endif /* GCA_EMBEDDED_GCN */
}
Beispiel #24
0
/*
** 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;
}
Beispiel #25
0
VOID
s_break()
{
	/* internal declarations */

	i4		tok_type;		/* next token type */
	i4		rtn_char;		/*
						** dummy variable for s_g_skip()
						** and real variable for
						** s_g_ident().
						*/
	char		*name;			/* break name */
	bool		err;
	char		nrml_buf[(FE_MAXNAME + 1)];

	/* start of routine */

	if (St_b_given)
	{
		s_error(0x3A6, NONFATAL, NULL);
		s_cmd_skip();
		return;
	}
	St_b_given = TRUE;

	save_em();		/* store aside the values of Command fields */

	/* Initialize the fields in Command */

	STcopy(NAM_BREAK, Ctype);
	STcopy(ERx(" "), Csection);
	STcopy(ERx(" "), Ccommand);
	if (Cact_ren == NULL)
	{
		s_error(0x38A, FATAL, NULL);
	}

	Csequence = Cact_ren->ren_bcount;

	err = FALSE;
	while (!err)
	{
		tok_type = s_g_skip(TRUE, &rtn_char);

		switch (tok_type)
		{
			case TK_ENDFILE:
			case TK_PERIOD:
				goto allexit;

			case TK_COMMA:
				break;

			case TK_ALPHA:
			case TK_QUOTE:
			case TK_DOLLAR:
				if (tok_type == TK_ALPHA)
				{
					name = s_g_ident(FALSE,&rtn_char,
							 FALSE);
					if  (rtn_char != UI_REG_ID)
					{
						s_error(0x39D,NONFATAL,
							name,NULL);
						s_cmd_skip();
						err = TRUE;
						break;
					}
					IIUGdbo_dlmBEobject(name,FALSE);
				}
				else if (tok_type == TK_QUOTE)	/* Delim ID */
				{
					if  (!St_xns_given)
					{
						s_error(0x39D,NONFATAL,
							name,NULL);
						s_cmd_skip();
						err = TRUE;
						break;
					}
					name = s_g_ident(FALSE,&rtn_char,
							 FALSE);
					if  (rtn_char != UI_DELIM_ID)
					{
						s_error(0x39D,NONFATAL,
							name,NULL);
						s_cmd_skip();
						err = TRUE;
						break;
					}
					_VOID_ IIUGdlm_ChkdlmBEobject(name,
								&nrml_buf[0],
								FALSE);
					name = &nrml_buf[0];
				}
				else
				{
					name = s_g_name(FALSE);
					IIUGdbo_dlmBEobject(name,FALSE);
				}
				if (s_sbr_find(name) != NULL)
				{	/* already specified */
					s_error(0x39E, NONFATAL, name, NULL);
					s_cmd_skip();
					err = TRUE;
					break;
				}

				/* name not specified.	Add it */

				s_sbr_add(name);
				STcopy(name,Cattid);
				_VOID_ s_w_row();
				break;

			default:
				s_error(0x39D, NONFATAL, NULL);
				s_cmd_skip();
				err = TRUE;
				break;

		}
	}

    allexit:
	get_em();
}
Beispiel #26
0
**	30-mar-2004 (gupsh01)
**	    Added getQinfoParm as input parameter to II_sw... functions.
**/

# define MAX_TMWORDS	6


GLOBALDEF bool	RStwo_phase = TRUE;


static i4	high_limit = 0;
static i4	low = 0;
static II_PTR	dtrans_id_handle = NULL;
static bool	first = TRUE;

static char	*log_format = ERx("%d!%d!%d!%d!%s!%s!%d!%d!%d!%s!%s\n");


static void mktimestamp(char *timestr, char *timestamp);


/*{
** Name:	RScommit - two-phase commit processing
**
** Description:
**	Prepares to commit locally, commits remotely, commits locally.
**	Logs each step of the commit so that a reasonable attempt can
**	be made to recover if it does not complete.
**
** Inputs:
**	target	- target database, CDDS and connection number
Beispiel #27
0
**	31-aug-2000 (hanch04)
**	    cross change to main
**	    replace nat and longnat with i4
**	01-aug-2003 (somsa01)
**	    Added NO_OPTIM for i64_win to prevent oslsql.exe from SEGVing
**	    during the run of 4GL SEP test fgl10.sep .
**      17-dec-2008 (joea)
**          Replace READONLY/WSCREADONLY by const.
**	26-Aug-2009 (kschendel) b121804
**	    Void prototypes to keep gcc 4.3 happy.
*/

GLOBALREF char	osDecimal;	/* referenced in osmkconst()  */
bool osckadfproc();
/* _Is_ prefix for postfix RELOP operators */
static const char _Is_[] = ERx("is ");

/*{
** Name:	osmknode() -	Make a Node.
**
** History:
**	01/90 (jhw)
**	    Modify procedure check so all UNDEF procedures
**	    are also not ADF functions.
**	04/07/91 (emerson)
**	    Modifications for local procedures:
**	    Doctor VALUE node if symbol is a local procedure.
**	09/20/92 (emerson)
**	    Use N_ROW bit of n_flags instead of n_sub.  Added logic to set
**	    new N_COMPLEXOBJ, N_TABLEFLD, and N_ROW bits in n_flags.
**	    Added logic to place "value" into the new n_targlfrag member
Beispiel #28
0
**	    Added additional error handling for Vista OS.
**	    This program will recognize ERROR_ELEVATION_REQUIRED
**	    and ERROR_ACCESS_DENIED errors as Vista's lack
**	    of privileges.
*/

/*
**      mkming hints

NEEDLIBS =      COMPATLIB 

PROGRAM =       iirundbms

*/

char	bad_msg[GL_MAXNAME] 	= ERx("\nFAIL\n");
char	iirun[GL_MAXNAME] 	= ERx("iirun.exe");
char	iirundbms[GL_MAXNAME] 	= ERx("iirundbms");


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;
Beispiel #29
0
void 
main(int argc, char *argv[])
{
#define 	MAXBUF	4095
#define 	MAX_NAME  32	

	char 		buf[ MAXBUF+1 ];
	char 		repbuf[ MAXBUF+1 ];
	int		iarg, ibuf, ichr;
	char		*database = NULL;
	char 		username[MAX_NAME] = {""};
	LOCATION	tloc;
	LOCATION        loc_out;
	LOCATION        loc_in;
	char            loc_buf[MAX_LOC + 1];
	char            tmp_buf[MAX_LOC + 1];
	char			otmp_buf[MAX_LOC + 1];
	char		dev[MAX_LOC + 1];
	char		path[MAX_LOC + 1];
	char		fprefix[MAX_LOC + 1];
	char		fsuffix[MAX_LOC + 1];
	char		version[MAX_LOC + 1];
	char            odev[MAX_LOC + 1];
	char            opath[MAX_LOC + 1];
	char            ofprefix[MAX_LOC + 1];
	char            ofsuffix[MAX_LOC + 1];
	char            oversion[MAX_LOC + 1];
	char            *new_filename;
	char		*temploc;
	CL_ERR_DESC 	err_code;
	char 		*p1 = NULL;
	bool		usergiven = FALSE;
	bool		Repmod = FALSE;
	bool		nowait = TRUE;
	char	 	waitflag[3];
	
	
	if (argc < 2) 
	{
		usage();
	    PCexit(FAIL);
	}
	
	/* Get the temporary path location */	
	NMloc(TEMP, PATH, NULL, &tloc);		
	LOcopy(&tloc, tmp_buf, &loc_in);
	LOtos(&tloc, &temploc);
	LOcopy(&tloc, otmp_buf, &loc_out);
	     	
	/* Get the new filename for path location */	
	LOuniq(ERx("usrmod"), ERx("sql"), &loc_in);	
	LOtos(&loc_in, &new_filename);
	
	LOuniq(ERx("usrmod"), ERx("out"), &loc_out);

	/* Get just the filename for copydb code   */	
	LOdetail(&loc_in, dev, path, fprefix, fsuffix, version); 
	if ( *fsuffix !=  '\0' )
	{
	    STcat(fprefix, ".");
	    STcat(fprefix, fsuffix);
	}
       /* Get just the filename for copydb code   */
         LOdetail(&loc_out, odev, opath, ofprefix, ofsuffix,oversion);
		STcat(ofprefix, ".");
		STcat(ofprefix, ofsuffix);
	

	STprintf(buf, 
        ERx("copydb -with_modify -nodependency_check -with_index -with_comments -no_persist -parallel -no_repmod -group_tab_idx -no_warn -d\"%s\" -infile=\"%s\" -outfile=\"%s\""
	), temploc, fprefix,ofprefix);
	ibuf = STlength(buf); 

	for (iarg = 1; (iarg < argc) && (ibuf < MAXBUF); iarg++) 
	{

	    if( STscompare( argv[ iarg ], 1, ERx( "-" ), 1 ) == 0 )
		{
			p1 = argv[ iarg ]; 
			(void) CMnext( p1 );

			if ( (STlength(p1) == 0) || 
			  !(((STscompare( p1, 1, ERx( "u" ), 1 ) == 0 ) ||
			  (STscompare( p1, 5, ERx( "noint" ), 5 ) == 0 ) || 
			  (STscompare( p1, 6, ERx( "repmod" ), 6 ) == 0 ) || 
			  (STscompare( p1, 1, ERx( "w" ), 6 ) == 0 ) ||
			  (STscompare( p1, 6, ERx( "online"), 6 ) == 0 )) &&
			  ( argc > 2 ) ))
			{
				usage(); 
				PCexit(FAIL);
			}
			/*
			** Get the username if the -u flag is passed in
			** with the input
			*/
			
			if (STscompare( p1, 1, ERx( "u" ), 1 ) == 0 )
			{
				STcopy(&argv[iarg][2] , (char *)&username);
				usergiven = TRUE;
			}
			else if (STscompare( p1, 1, ERx( "r" ), 1 ) == 0 )
			{ 	
				Repmod = TRUE;
				continue;
			}
			else if (STscompare( p1, 1, ERx( "w"), 1 ) == 0)	
			{	
				nowait = TRUE;
				continue;
			}	
                }              	
		
        if( STscompare( argv[ iarg ], 1, ERx( "+" ), 1 ) == 0 )
		{
			p1 = argv[ iarg ];
			(void) CMnext( p1 );
			if (STscompare( p1, 1, ERx( "w" ), 1 ) == 0 )
			{
				nowait = FALSE;	
				continue;
			}
			else
			{
				usage();
				PCexit(FAIL); 
			}
		}

        if((database == NULL) &&
           (STscompare( argv[ iarg ], 1, ERx( "+" ), 1 ) != 0) &&
           (STscompare( argv[ iarg ], 1, ERx( "-" ), 1 ) != 0))
        {
            database =  argv[ iarg ];
        }

	buf[ibuf++] = ' ';
		for (ichr = 0; (argv[iarg][ichr] != '\0') && (ibuf < MAXBUF); 
			ichr++, ibuf++)
		{
			buf[ibuf] = argv[iarg][ichr];
		}
		buf[ibuf] = '\0';
	}

	/*
	**	Execute the command.
	*/

	if( PCcmdline((LOCATION *) NULL, buf, PC_WAIT, 
			(LOCATION *) NULL, &err_code) != OK )
	    PCexit(FAIL);

	/*
	**	we should run the sql script 
	**	  sql dbname < new_filename
	**	if -u flag given then run:
	**	  sql -uusername dbname < new_filename	
	*/

	if (usergiven)
	  STprintf(buf, ERx( "sql -u%s -s %s <%s" ),
			username, database, new_filename );
	else
	  STprintf(buf, ERx( "sql -s %s <%s" ),
				database, new_filename );

	/*
	**	Execute the command.
	*/

        if( PCcmdline((LOCATION *) NULL, buf, PC_WAIT, 
                        (LOCATION *) NULL, &err_code) != OK )
        {
            STprintf(buf, ERx(" Warning: Non-persistent objects associated with the base table\n in the failed query may have been lost. Please refer to\n %s\n to determine whether any corrective action is required.\n"), new_filename);
            SIfprintf(stdout, buf);
	    PCexit(FAIL);
        }

	/* Now execute the repmod command if the replicator 
	** modify is also required by the user (-repmod)
	*/
	
	if (Repmod)
	{
		
	  if (nowait)
	    STcopy("-w", waitflag) ;
	  else
	    STcopy("+w", waitflag) ;
		
	  if (usergiven)
	    STprintf(repbuf, ERx( "repmod -u%s %s %s" ), 
		username, database, waitflag );
	  else
	    STprintf(repbuf, ERx( "repmod %s %s" ), 
		database, waitflag );
            	
	
	  if( PCcmdline((LOCATION *) NULL, repbuf, PC_WAIT,
                 (LOCATION *) NULL, &err_code) != OK )
     	    PCexit(FAIL);

	}	
	/*
	**	Delete the location
	*/
	LOdelete(&loc_in); 
	LOdelete(&loc_out);
	PCexit(OK);
}
Beispiel #30
0
/*{
** Name:	RSstats_init - initialize monitor statistics
**
** Description:
**	Initializes the Replicator Server statistics memory segment.
**
** Inputs:
**	none
**
** Outputs:
**	none
**
** Returns:
**	OK	Function completed normally.
*/
STATUS
RSstats_init()
{
	STATUS		status;
	char		*val;
	i4		num_targs;
	SIZE_TYPE	pages_alloc;
	u_i4	stats_size;
	RS_TARGET_STATS	*targ;
	RS_TARGET_STATS	*targ_end;
	RS_TABLE_STATS	*tbl;
	RS_CONN		*conn;
	RS_TBLDESC	*tbl_info;
	CL_SYS_ERR	sys_err;
	char		server_num[4];

	PMsetDefault(1, PMhost());
	STprintf(server_num, ERx("%d"), (i4)RSserver_no);
	PMsetDefault(3, server_num);
	status = PMget(ERx("II.$.REPSERV.$.SHARED_STATISTICS"), &val);
	if (status == OK && STbcompare(val, 0, ERx("ON"), 0, TRUE) == 0)
		shared_stats = TRUE;
	num_targs = RSnum_conns - TARG_BASE;
	stats_size = sizeof(RS_MONITOR) +
		sizeof(RS_MONITOR) % sizeof(ALIGN_RESTRICT);
	targ_size = sizeof(RS_TARGET_STATS) +
		sizeof(RS_TARGET_STATS) % sizeof(ALIGN_RESTRICT);
	if (shared_stats)
		tbl_size = sizeof(RS_TABLE_STATS) + sizeof(RS_TABLE_STATS) %
			sizeof(ALIGN_RESTRICT);
	else
		tbl_size = 0;
	num_pages = (stats_size + num_targs * (targ_size + RSrdf_svcb.num_tbls *
		tbl_size)) / ME_MPAGESIZE + 1;
	if (shared_stats)
	{
		STprintf(sm_key, ERx("%s.%03d"), RS_STATS_FILE, RSserver_no);
		status = MEget_pages(ME_SSHARED_MASK | ME_CREATE_MASK |
			ME_MZERO_MASK | ME_NOTPERM_MASK, num_pages, sm_key,
			(PTR *)&mon_stats, &pages_alloc, &sys_err);
		if (status == ME_ALREADY_EXISTS)
		{
			status = MEsmdestroy(sm_key, &sys_err);
			if (status == OK)
				status = MEget_pages(ME_SSHARED_MASK |
					ME_CREATE_MASK | ME_MZERO_MASK |
					ME_NOTPERM_MASK, num_pages, sm_key,
					(PTR *)&mon_stats, &pages_alloc,
					&sys_err);
		}
	}
	else
	{
		mon_stats = (RS_MONITOR *)MEreqmem(0, num_pages * ME_MPAGESIZE,
			TRUE, &status);
	}
	if (status != OK)
		return (status);
	mon_stats->server_no = RSserver_no;
	mon_stats->local_db_no = RSlocal_conn.db_no;
	PCpid(&mon_stats->pid);
	mon_stats->startup_time = TMsecs();
	mon_stats->num_targets = num_targs;
	mon_stats->num_tables = RSrdf_svcb.num_tbls;
	STcopy(RSlocal_conn.vnode_name, mon_stats->vnode_name);
	STcopy(RSlocal_conn.db_name, mon_stats->db_name);
	mon_stats->target_stats = (RS_TARGET_STATS *)((PTR)mon_stats +
		stats_size);
	targ_end = (RS_TARGET_STATS *)((PTR)mon_stats->target_stats +
		mon_stats->num_targets * (targ_size + tbl_size *
		mon_stats->num_tables));
	for (conn = &RSconns[TARG_BASE], targ = mon_stats->target_stats;
		targ < targ_end; ++conn, targ = (RS_TARGET_STATS *)((PTR)targ +
		targ_size + tbl_size * mon_stats->num_tables))
	{
		targ->db_no = conn->db_no;
		STcopy(conn->vnode_name, targ->vnode_name);
		STcopy(conn->db_name, targ->db_name);
		if (shared_stats)
		{
			targ->table_stats = (RS_TABLE_STATS *)((PTR)targ +
				targ_size);
			for (tbl_info = RSrdf_svcb.tbl_info,
				tbl = targ->table_stats;
				tbl < targ->table_stats + mon_stats->num_tables;
				++tbl, ++tbl_info)
			{
				tbl->table_no = tbl_info->table_no;
				STcopy(tbl_info->table_owner, tbl->table_owner);
				STcopy(tbl_info->table_name, tbl->table_name);
			}
		}
	}

	return (OK);
}