char *
STrindex_DB(
const char *str,
const char *mstr,
register size_t len)
{
char *where = NULL;
if (len <= 0)
len = MAXI2;
while (len > 0 && *str != '\0')
{
if (CMcmpcase(str, mstr) == 0)
where = (char *)str;
CMbytedec(len, str);
CMnext(str);
}
if (where != NULL && *where != '\0')
return (where);
else
return (NULL);
}
char *
STindex_DB(
const char *str,
const char *mstr,
size_t len)
{
if (str == NULL || mstr == NULL)
return (NULL);
if (len <= 0)
len = 32767;
while (len > 0 && *str != '\0')
{
if (CMcmpcase(str, mstr) == 0)
return ((char *)str);
CMbytedec(len, str);
CMnext(str);
}
return (NULL);
}
/*
* regatom - the lowest level
*
* Optimization: gobbles an entire sequence of ordinary characters so that
* it can turn them into a single node, which is smaller to store and
* faster to run. Backslashed characters are exceptions, each becoming a
* separate node; the code is simpler that way and it's not worth fixing.
*/
static char *
regatom(i4 *flagp)
{
register char *ret;
i4 flags;
char null_byte = '\0';
*flagp = WORST; /* Tentatively. */
switch (*regparse) {
case '^':
CMnext( regparse );
ret = regnode(BOL);
break;
case '$':
CMnext( regparse );
ret = regnode(EOL);
break;
case '.':
CMnext( regparse );
ret = regnode(ANY);
*flagp |= HASWIDTH|SIMPLE;
break;
case '[': {
char *range_start = NULL;
bool double_start;
u_i2 first_u2, last_u2;
u_char first_u1, last_u1;
CMnext( regparse );
if (*regparse == '^') { /* Complement of range. */
ret = regnode(ANYBUT);
CMnext( regparse );
} else
ret = regnode(ANYOF);
if (*regparse == ']' || *regparse == '-') {
regc( regparse );
CMnext( regparse );
}
while (*regparse != '\0' && *regparse != ']') {
if (*regparse == '-') {
char range_op = '-';
CMnext( regparse );
if( *regparse == ']' ||
*regparse == '\0'
)
regc( &range_op );
else {
char *tmp;
bool invalid = FALSE;
bool double_end;
if( range_start == NULL )
invalid = TRUE;
double_end =
CMdbl1st( regparse );
if( !invalid &&
double_end
&& !double_start
)
invalid = TRUE;
if( !invalid &&
double_start
&& !double_start
)
invalid = TRUE;
if( !invalid &&
CMcmpcase( range_start,
regparse ) > 0
)
invalid = TRUE;
if( double_start )
_FAIL("don't know how to support character classes containing double-byte ranges");
if( invalid )
_FAIL("invalid [] range");
/* no double-byte ranges! */
/*
** Initialize the value for the end of the range.
*/
last_u1 = UCHARAT(regparse);
for (; first_u1 <= last_u1;
first_u1++
)
regc( (char *)
&first_u1 );
CMnext( regparse );
}
} else {
range_start = regparse;
if( CMdbl1st( range_start ) )
{
double_start = TRUE;
first_u2 = *(u_i2 *) range_start;
}
else
{
double_start = FALSE;
first_u1 = UCHARAT(range_start);
}
regc( regparse );
CMnext( regparse );
}
}
regc( &null_byte );
if (*regparse != ']')
_FAIL("unmatched []");
CMnext( regparse );
*flagp |= HASWIDTH|SIMPLE;
}
break;
case '(':
CMnext( regparse );
ret = reg(1, &flags);
if (ret == NULL)
return(NULL);
*flagp |= flags&(HASWIDTH|SPSTART);
break;
case '\0':
case '|':
case ')':
CMnext( regparse );
_FAIL("internal urp"); /* Supposed to be caught earlier. */
break;
case '?':
case '+':
case '*':
CMnext( regparse );
_FAIL("?+* follows nothing");
break;
case '\\':
CMnext( regparse );
if (*regparse == '\0')
_FAIL("trailing \\");
ret = regnode(EXACTLY);
regc( regparse );
CMnext( regparse );
regc( &null_byte );
*flagp |= HASWIDTH|SIMPLE;
break;
default: {
register i4 len;
register char ender;
len = my_strcspn(regparse, META);
if (len <= 0)
_FAIL("internal disaster");
ender = *(regparse+len);
if (len > 1 && ISMULT(ender))
len--; /* Back off clear of ?+* operand. */
*flagp |= HASWIDTH;
if (len == 1)
*flagp |= SIMPLE;
ret = regnode(EXACTLY);
while (len > 0) {
regc( regparse );
CMbytedec( len, regparse );
CMnext( regparse );
}
regc( &null_byte );
}
break;
}
return(ret);
}
/*{
** Name: scu_xencode - encrypt a character string
**
** Description:
** This function uses CI routines to encrypt a character string.
** Since the character string is used to generate the key schedule,
** the encryption is essentially one-way (you'd need to know the
** password to decode the password....) This routine was designed
** to encrypt application_id passwords.
**
** Inputs:
** SCU_XENCODE the opcode to scf_call()
** scf_cb control block in which is specified
** .scf_ptr_union.scf_xpassword
** pointer to buffer to be encrypted
** .scf_nbr_union.scf_xpasskey
** pointer to seed for key schedule
** .scf_len_union.scf_xpwdlen
** length of password and key seed
**
** Outputs:
** scf_cb the same control block
** .error the error control area
** .err_code E_SC_OK or ...
** E_SC0261_XENCODE_BAD_PARM
** E_SC0262_XENCODE_BAD_RESULT
** Returns:
** E_DB_{OK, WARNING, ERROR, FATAL}
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 24-mar-89 (ralph)
** Written for terminator
** 20-may-89 (ralph)
** Changed encryption to use separate key
** 06-jun-89 (ralph)
** Fixed unix compile problems
** 06-may-1993 (ralph)
** DELIM_IDENT:
** Translate key seed to lower case prior to encryption.
** 2-Jul-1993 (daveb)
** prototyped.
** 14-jul-93 (ed)
** replacing <dbms.h> by <gl.h> <sl.h> <iicommon.h> <dbdbms.h>
** 12-Sep-2007 (drivi01)
** Modified scu_xencode function to fix numerous bugs.
** The buffers for password manipulation shouldn't exceed
** the size of scb_xpassword field in SCF control block,
** otherwise the data will be truncated.
*/
DB_STATUS
scu_xencode(SCF_CB *scf_cb, SCD_SCB *scb )
{
STATUS status;
CI_KS KS;
char inbuffer[DB_PASSWORD_LENGTH+1];
char outbuffer[DB_PASSWORD_LENGTH+1];
char keybuffer[DB_PASSWORD_LENGTH];
u_i2 i2_size;
i4 longnat_size;
i4 nat_size;
char *char_ptr;
#define PASSINIT "hjodvwHOJHOJhodh498032&*&*#)$&*jpkshghjlg58925fjkdjkpg"
status = E_DB_OK;
CLRDBERR(&scf_cb->scf_error);
/* Ensure input parameter is okay */
if ((scf_cb->scf_len_union.scf_xpwdlen <= 0) ||
(scf_cb->scf_len_union.scf_xpwdlen >= sizeof(inbuffer)) ||
(scf_cb->scf_nbr_union.scf_xpasskey == NULL) ||
(scf_cb->scf_ptr_union.scf_xpassword == NULL))
{
sc0ePut(NULL, E_SC0261_XENCODE_BAD_PARM, NULL, 0);
SETDBERR(&scf_cb->scf_error, 0, E_SC0261_XENCODE_BAD_PARM);
return(E_DB_ERROR);
}
/* Copy string to input buffer */
MEmove(scf_cb->scf_len_union.scf_xpwdlen,
(PTR)scf_cb->scf_ptr_union.scf_xpassword,
(char)'\0',
sizeof(inbuffer),
(PTR)inbuffer);
/* Copy key to key buffer */
MEmove(scf_cb->scf_len_union.scf_xpwdlen,
(PTR)scf_cb->scf_nbr_union.scf_xpasskey,
(char)'?',
sizeof(keybuffer),
(PTR)keybuffer);
/* Fold the key to lower case */
for (nat_size = sizeof(keybuffer), char_ptr = keybuffer;
nat_size > 0;
nat_size = CMbytedec(nat_size, char_ptr), char_ptr = CMnext(char_ptr))
{
CMtolower(char_ptr, char_ptr);
}
/* Remove white space from input string */
nat_size = STzapblank(inbuffer, outbuffer);
/* Check size */
if ((nat_size <= 0) ||
(nat_size > sizeof(outbuffer)-1))
{
sc0ePut(NULL, E_SC0261_XENCODE_BAD_PARM, NULL, 0);
SETDBERR(&scf_cb->scf_error, 0, E_SC0261_XENCODE_BAD_PARM);
return(E_DB_ERROR);
}
/* Initialize input buffer to "garbage" */
MEmove(sizeof(PASSINIT), (PTR)PASSINIT, (char)'?',
sizeof(inbuffer), (PTR)inbuffer);
/* Normalize the string back into input buffer */
MEcopy((PTR)outbuffer, nat_size, (PTR)inbuffer);
/* Reset output buffer to blanks */
MEfill(sizeof(outbuffer),
(u_char)' ',
(PTR)outbuffer);
/*
** First, encrypt the key seed using the string to encode.
** Then, encrypt the string using the encrypted seed.
** This is done to prevent two roles with the same password
** from having the same encrypted value.
** Note that this makes the encryption one-way, since
** the password must be provided to decrypt the password!
*/
/* Generate the key schedule to encrypt the key seed */
(VOID)CIsetkey((PTR)inbuffer, KS);
/* Encrypt the key seed */
longnat_size = DB_PASSWORD_LENGTH;
(VOID)CIencode((PTR)keybuffer, longnat_size, KS, (PTR)outbuffer);
/* Generate the second key schedule */
(VOID)CIsetkey((PTR)keybuffer, KS);
/* Encode the string */
longnat_size = DB_PASSWORD_LENGTH;
(VOID)CIencode((PTR)inbuffer, longnat_size, KS, (PTR)outbuffer);
/* Make sure it was really encoded */
if ((char *)STskipblank(outbuffer, (i4)sizeof(outbuffer))
!= NULL)
{
/* It was; copy result to caller's area */
i2_size = scf_cb->scf_len_union.scf_xpwdlen;
MEmove(sizeof(outbuffer), (PTR)outbuffer, (char)' ',
i2_size, (PTR)scf_cb->scf_ptr_union.scf_xpassword);
}
else
{
/* The encryption did not work; return an error */
sc0ePut(NULL, E_SC0262_XENCODE_BAD_RESULT, NULL, 0);
SETDBERR(&scf_cb->scf_error, 0, E_SC0262_XENCODE_BAD_RESULT);
status = E_DB_ERROR;
}
return(status);
}
static
i4
do_readln(FILE *fp,char *buf_ptr,i2 maxchar)
{
char *ptr; /* Working pointer into line buffer */
i4 count; /* Number of chars read */
STATUS status;
ptr = buf_ptr;
while (maxchar > 0)
{
status = SIread(fp,sizeof(char),&count,ptr);
CMbytedec(maxchar,ptr);
if ((CMdbl1st(ptr)) && (maxchar > 0))
{
status = SIread(fp,sizeof(char),&count,(ptr + 1));
CMbytedec(maxchar,ptr);
}
switch(status)
{
case(ENDFILE):
*ptr = EOS;
count = STlength(buf_ptr);
if (count > 0)
{
/*
** We hit EOF on a file that ended abruptly
** without a final end-of-line character.
** Return the final line's count this time -
** we'll return EOF on the next call.
*/
return(count);
}
return(-1);
break;
case(OK):
if ((*ptr == CR) || (*ptr == LF) || (*ptr == FF))
{
/*
** Do NOT include the end-of-line character!
*/
*ptr = EOS;
return(STlength(buf_ptr));
}
CMnext(ptr);
break;
default:
/*
** According to the documentation, we shouldn't
** be able to get here.
*/
IIUGerr(E_DE000E_Dobj_read_fail,UG_ERR_ERROR,0);
return(-1);
}
}
/*
** If we wind up here, then
** we've exceeded maxchars!
*/
*ptr = EOS;
return(STlength(buf_ptr));
}