/*!
*************************************************************************************
* \brief reopen log file when finish setting current path
*
* \param pCtx context pCtx
* \param pCurPath current path string
*
* \return NONE
*
* \note N/A
*************************************************************************************
*/
void WelsReopenTraceFile( void *pCtx, str_t *pCurPath )
{
#ifdef ENABLE_TRACE_FILE
sWelsEncCtx *pEncCtx = (sWelsEncCtx *)pCtx;
if (wlog == WelsLogDefault)
{
str_t strTraceFile[MAX_FNAME_LEN] = {0};
int32_t len = 0;
if (pEncCtx->pFileLog != NULL)
{
fclose(pEncCtx->pFileLog);
pEncCtx->pFileLog = NULL;
}
pEncCtx->uiSizeLog = 0;
len = STRNLEN( pCurPath, MAX_FNAME_LEN-1 ); // confirmed_safe_unsafe_usage
if (len >= MAX_FNAME_LEN)
return;
STRNCPY(strTraceFile, MAX_FNAME_LEN, pCurPath, len); // confirmed_safe_unsafe_usage
#ifdef __GNUC__
STRCAT(strTraceFile, MAX_FNAME_LEN-len, "/wels_encoder_trace.txt"); // confirmed_safe_unsafe_usage
pEncCtx->pFileLog = FOPEN(strTraceFile, "wt+"); // confirmed_safe_unsafe_usage
#elif WIN32
STRCAT(strTraceFile, MAX_FNAME_LEN-len, "\\wels_encoder_trace.txt");// confirmed_safe_unsafe_usage
#if _MSC_VER >= 1500
FOPEN(&pEncCtx->pFileLog, strTraceFile, "wt+"); // confirmed_safe_unsafe_usage
#else
pEncCtx->pFileLog = FOPEN(strTraceFile, "wt+"); // confirmed_safe_unsafe_usage
#endif//_MSC_VER>=1500
#else
#endif//__GNUC__
}
#endif//ENABLE_TRACE_FILE
}
void ShapeFile::Open_( // read shape file from disk
const char* shapepath) // in
{
lprintf("Reading %s: ", shapepath);
STRCPY(shapepath_, shapepath);
FILE* file = fopen(shapepath, "rb");
if (!file)
Err("Cannot open %s", shapepath);
bool oldformat = false;
Header(oldformat, shapepath, file);
ImgDirs(dirs_, shapepath, file);
shapes_.clear();
bases_.clear();
bits_.clear();
poses_.clear();
char base[SLEN]; unsigned bits; Shape shape;
nchar_ = 0;
int nrows = -1;
while (ReadMat(base, bits, shape, file, shapepath))
{
bool normalshape = true;
if (oldformat)
{
if (bits & FA_Meta) // metashape?
normalshape = false;
}
else if (bits & AT_Meta) // metashape?
{
normalshape = false;
if (bits == AT_Pose)
{
CV_Assert(shape.rows == 1 && shape.cols == 4);
poses_[base] = shape.clone();
}
}
if (normalshape)
{
// check that all shapes have same number of points
if (nrows == -1) // first shape?
nrows = shape.rows;
else if (shape.rows != nrows)
Err("%s has %d row%s but %s has %d row%s",
base, shape.rows, plural(shape.rows),
bases_[0].c_str(), nrows, plural(nrows));
shapes_.push_back(shape.clone());
bases_.push_back(base);
bits_.push_back(bits);
int len = STRNLEN(base, 100);
if (len > nchar_)
nchar_ = len;
}
}
fclose(file);
nshapes_ = NSIZE(shapes_);
lprintf("%d shape%s\n", nshapes_, plural(nshapes_));
if (nshapes_ == 0)
Err("No shapes in %s", shapepath);
}
CHAR *
generic_stpncpy (CHAR *dst, const CHAR *src, size_t n)
{
size_t nc = STRNLEN (src, n);
MEMCPY (dst, src, nc);
dst += nc;
if (nc == n)
return dst;
return MEMSET (dst, 0, n - nc);
}
CHAR *
STUPID_STPNCPY (CHAR *dst, const CHAR *src, size_t n)
{
size_t nc = STRNLEN (src, n);
size_t i;
for (i = 0; i < nc; ++i)
dst[i] = src[i];
for (; i < n; ++i)
dst[i] = '\0';
return dst + nc;
}
/*!
* \brief get library/module name
* \param pBuf pBuffer to restore module name
* \param iSize size of pBuffer overall
* \return actual size of pBuffer used; 0 returned in failure
*/
int32_t GetLibName (str_t* pBuf, int32_t iSize) {
int32_t iLen = 0;
if (NULL == pBuf)
return 0;
iLen = STRNLEN (WELS_LIB_NAME, 7); // confirmed_safe_unsafe_usage
if (iSize <= iLen)
return 0;
pBuf[iLen] = '\0';
STRNCPY (pBuf, iSize, WELS_LIB_NAME, iLen); // confirmed_safe_unsafe_usage
return iLen;
}
/*!
* \brief get identify information
* \param pBuf pBuffer to restore indentify information
* \param iSize size of pBuffer overall
* \return actual size of pBuffer used; 0 returned in failure
*/
int32_t GetIdentInfo (str_t* pBuf, int32_t iSize) {
int32_t iLen = 0;
if (NULL == pBuf)
return 0;
iLen = STRNLEN (WELS_IDENT, 30); // confirmed_safe_unsafe_usage
if (iSize <= iLen)
return 0;
pBuf[iLen] = '\0';
STRNCPY (pBuf, iSize, WELS_IDENT, iLen); // confirmed_safe_unsafe_usage
return iLen;
}
/*!
* \brief get version number
* \param pBuf pBuffer to restore version number
* \param iSize size of pBuffer overall
* \return actual size of pBuffer used; 0 returned in failure
*/
int32_t GetVerNum (str_t* pBuf, int32_t iSize) {
int32_t iLen = 0;
if (NULL == pBuf)
return 0;
iLen = STRNLEN (WELS_VERSION_STR, 5); // confirmed_safe_unsafe_usage
if (iSize <= iLen)
return 0;
pBuf[iLen] = '\0';
STRNCPY (pBuf, iSize, WELS_VERSION_STR, iLen); // confirmed_safe_unsafe_usage
return iLen;
}
STATICFNDEF int4 update_trigger_name_value(char *trig_name, int trig_name_len, int new_trig_index)
{
int len;
char name_and_index[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT];
int num_len;
char *ptr;
int4 result;
mval trig_gbl;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(!gv_cur_region->read_only); /* caller should have already checked this */
assert(cs_addrs->hasht_tree == gv_target); /* should have been set up by caller */
assert(gv_target->root); /* should have been ensured by caller */
/* $get(^#t("#TNAME",^#t(GVN,index,"#TRIGNAME"))) */
BUILD_HASHT_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), trig_name, trig_name_len - 1);
if (!gvcst_get(&trig_gbl))
{ /* There has to be a #TNAME entry */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""),
trig_name_len - 1, trig_name);
}
ptr = trig_gbl.str.addr;
len = MIN(trig_gbl.str.len, MAX_MIDENT_LEN);
STRNLEN(ptr, len, len);
ptr += len;
if ((trig_gbl.str.len == len) || ('\0' != *ptr))
{
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""),
trig_name_len - 1, trig_name);
}
memcpy(name_and_index, trig_gbl.str.addr, ++len); /* inline increment intended */
ptr = name_and_index + len;
num_len = 0;
I2A(ptr, num_len, new_trig_index);
len += num_len;
/* set ^#t("#TNAME",<trigname>)=gblname_$C(0)_new_trig_index */
SET_TRIGGER_GLOBAL_SUB_SUB_STR(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), trig_name, trig_name_len - 1,
name_and_index, len, result);
return result;
}
char* const fread_str(FILE* const f)
{
size_t n = 2;
char* out = (char*) malloc((n +1) *sizeof(char));
char* x = out;
int c = fgetc(f);
while (c != EOF && c != 0x00)
{
if (x >= out +n)
{
out = realloc(out, (n*2 +1) *sizeof(char));
x = out +n; n *= 2;
}
*(x++) = (char) c;
c = fgetc(f);
}
*x = 0x00;
return realloc(out, (STRNLEN(out, n) +1) *sizeof(char));
}
/*!
*************************************************************************************
* \brief System trace log output in Wels
*
* \param pCtx instance pointer
* \param kiLevel log iLevel ( WELS_LOG_QUIET, ERROR, WARNING, INFO, DEBUG )
* \param kpFmtStr formated string to mount
* \param argv pData string argument
*
* \return NONE
*
* \note N/A
*************************************************************************************
*/
void WelsLogDefault( void *pCtx, const int32_t kiLevel, const str_t *kpFmtStr, va_list argv )
{
sWelsEncCtx *pEncCtx = (sWelsEncCtx *)pCtx;
iWelsLogLevel iVal = (kiLevel & g_iLevelLog);
if ( 0 == iVal || NULL == pEncCtx ) // such iLevel not enabled
{
return;
}
else
{
str_t pBuf[WELS_LOG_BUF_SIZE+1] = {0};
const int32_t kiBufSize = sizeof(pBuf) / sizeof(pBuf[0]) - 1;
int32_t iCurUsed = 0;
int32_t iBufUsed = 0;
int32_t iBufLeft = kiBufSize - iBufUsed;
if ( pEncCtx ){
time_t l_time;
#if defined(WIN32)
#if defined(_MSC_VER)
#if _MSC_VER >= 1500
struct tm t_now;
#else//VC6
struct tm* t_now;
#endif//_MSC_VER >= 1500
#endif//_MSC_VER
#else//__GNUC__
struct tm* t_now;
#endif//WIN32
#if defined( WIN32 )
struct _timeb tb;
time(&l_time);
#ifdef _MSC_VER
#if _MSC_VER >= 1500
LOCALTIME(&t_now, &l_time);
#else
t_now = LOCALTIME(&l_time);
if ( NULL == t_now )
{
return;
}
#endif//_MSC_VER >= 1500
#endif//_MSC_VER
FTIME(&tb);
#elif defined( __GNUC__ )
struct timeval tv;
time(&l_time);
t_now = (struct tm *)LOCALTIME(&l_time);
gettimeofday(&tv,NULL);
#endif//WIN32
if (iBufLeft > 0){
#ifdef _MSC_VER
#if _MSC_VER >= 1500
iCurUsed = SNPRINTF( &pBuf[iBufUsed], iBufLeft, iBufLeft, "[0x%p @ ", pEncCtx ); // confirmed_safe_unsafe_usage
#else
iCurUsed = SNPRINTF( &pBuf[iBufUsed], iBufLeft, "[0x%p @ ", pEncCtx ); // confirmed_safe_unsafe_usage
#endif//_MSC_VER >= 1500
#endif//_MSC_VER
if (iCurUsed >= 0){
iBufUsed += iCurUsed;
iBufLeft -= iCurUsed;
}
}
else{
return;
}
if ( iBufLeft > 0 ){
iCurUsed = GetCodeName( &pBuf[iBufUsed], iBufLeft );
if ( iCurUsed > 0 ){
iBufUsed += iCurUsed;
iBufLeft -= iCurUsed;
}
pBuf[iBufUsed] = ' ';
++ iBufUsed;
-- iBufLeft;
iCurUsed = GetLibName( &pBuf[iBufUsed], iBufLeft );
if ( iCurUsed > 0 ){
iBufUsed += iCurUsed;
iBufLeft -= iCurUsed;
}
pBuf[iBufUsed] = ' ';
++ iBufUsed;
-- iBufLeft;
pBuf[iBufUsed] = 'v';
++ iBufUsed;
-- iBufLeft;
iCurUsed = GetVerNum( &pBuf[iBufUsed], iBufLeft );
if ( iCurUsed > 0 ){
iBufUsed += iCurUsed;
iBufLeft -= iCurUsed;
}
pBuf[iBufUsed] = ' ';
++ iBufUsed;
-- iBufLeft;
}
if (iBufLeft > 0){
#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1500)
iCurUsed = strftime(&pBuf[iBufUsed], iBufLeft, "%y-%m-%d %H:%M:%S", &t_now);
#else
iCurUsed = strftime(&pBuf[iBufUsed], iBufLeft, "%y-%m-%d %H:%M:%S", t_now);
#endif//WIN32..
if (iCurUsed > 0){
iBufUsed += iCurUsed;
iBufLeft -= iCurUsed;
}
}
else{
return;
}
if (iBufLeft > 0){
#if defined (WIN32)
#ifdef _MSC_VER
#if _MSC_VER >= 1500
iCurUsed = SNPRINTF(&pBuf[iBufUsed], iBufLeft, iBufLeft, ".%03.3u]: ", tb.millitm); // confirmed_safe_unsafe_usage
#else
iCurUsed = SNPRINTF(&pBuf[iBufUsed], iBufLeft, ".%3.3u]: ", tb.millitm); // confirmed_safe_unsafe_usage
#endif//_MSC_VER >= 1500
#endif//_MSC_VER
#elif defined (__GNUC__)
iCurUsed = SNPRINTF(&pBuf[iBufUsed], iBufLeft, ".%3.3u]: ", tv.tv_usec/1000); // confirmed_safe_unsafe_usage
#endif//WIN32
if (iCurUsed >= 0){
iBufUsed += iCurUsed;
iBufLeft -= iCurUsed;
}
}
else{
return;
}
}
// fixed stack corruption issue on vs2008
if ( iBufLeft > 0 ){
int32_t i_shift = 0;
str_t *pStr = NULL;
pStr = GetLogTag( kiLevel, &i_shift );
if ( NULL != pCtx){
int32_t iLenTag = STRNLEN( pStr, 8 ); // confirmed_safe_unsafe_usage
STRCAT( &pBuf[iBufUsed], iBufLeft, pStr ); // confirmed_safe_unsafe_usage
iBufUsed += iLenTag;
pBuf[iBufUsed] = ' ';
iBufUsed++;
++iLenTag;
iBufLeft -= iLenTag;
}
}
if (iBufLeft > 0){
#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1500)
int32_t len = 0;
len = _vscprintf( kpFmtStr, argv ) // _vscprintf doesn't count
+ 1; // terminating '\0'
iCurUsed = VSPRINTF(&pBuf[iBufUsed], len, kpFmtStr, argv); // confirmed_safe_unsafe_usage
#else
iCurUsed = VSPRINTF(&pBuf[iBufUsed], kpFmtStr, argv); // confirmed_safe_unsafe_usage
#endif//WIN32..
if (iCurUsed > 0){
iBufUsed += iCurUsed;
iBufLeft -= iCurUsed;
}
}
#ifdef ENABLE_TRACE_FILE
if (NULL != pEncCtx && NULL != pEncCtx->pFileLog){
if ( pEncCtx->uiSizeLog > MAX_TRACE_LOG_SIZE){
if (0 == fseek(pEncCtx->pFileLog, 0L, SEEK_SET))
pEncCtx->uiSizeLog = 0;
}
if ( iBufUsed > 0 && iBufUsed < WELS_LOG_BUF_SIZE )
{
iCurUsed = fwrite(pBuf, 1, iBufUsed, pEncCtx->pFileLog);
fflush( pEncCtx->pFileLog );
if ( iCurUsed == iBufUsed )
pEncCtx->uiSizeLog += iBufUsed;
}
}
else{
#if defined(WIN32) && defined(_DEBUG)
OutputDebugStringA(pBuf);
#endif
}
#endif//ENABLE_TRACE_FILE
}
}
static bool ReadMat( // true if read the mat, false if no (more) mats in file
char* base, // out: basename in tag
unsigned& bits, // out: hex bits in tag
Shape& mat, // out: the matrix
FILE* file, // in: pointer to the shape file
const char* path) // in: for error messages
{
char s[SLEN]; // the string tag before the matrix
while (1)
{
int c = fgetc(file);
if (c == EOF)
return false; // note return
if (c == '{')
break; // note break
else if (c == '#')
SkipToEndOfLine(file, path);
else if (c == '\n' || c == '\r' || c == '\t' || c == ' ') // white space
;
else if (c == '"') // old format tag (enclosed in quotes)
;
else // any other char, assume it is the start of the tag
{
s[0] = char(c);
if (!Fgets(s+1, SLEN-1, file))
Err("%s(%d): Read failed (premature EOF)",
path, LineNbr(file));
// remove trailing white space and final quote if any
int i = STRNLEN(s, SLEN) - 1;
CV_Assert(i >= 4);
while (s[i] == ' ' || s[i] == '\t' || s[i] == '"')
i--;
s[i+1] = 0;
}
}
if (!s[0])
Err("%s(%d): Empty tag", path, LineNbr(file));
if (s[4] != ' ' && s[8] != ' ') // hex string must be 4 or 8 chars
Err("%s(%d): Malformed tag", path, LineNbr(file));
if (2 != sscanf(s, "%x %s", &bits, base))
Err("%s(%d): Malformed tag", path, LineNbr(file));
int nrows, ncols; int c;
if (2 != fscanf(file, "%d %d", &nrows, &ncols))
Err("%s(%d): Cannot read matrix size", path, LineNbr(file));
if (ncols < 1 || nrows > MAX_MAT_DIM)
Err("%s(%d): Invalid number of rows %d", path, LineNbr(file), nrows);
if (ncols < 1 || ncols > MAX_MAT_DIM)
Err("%s(%d): Invalid number of columns %d", path, LineNbr(file), ncols);
mat.create(nrows, ncols);
ReadMatData(mat, nrows, ncols, file, path);
// make sure that next non-white char is matrix terminator '}'
c = ' ';
while (c == ' ' || c == '\t' || c == '\n' || c == '\r') // skip white space
if (EOF == (c = fgetc(file))) // assignment is intentional
Err("%s(%d): Cannot read matrix\n"
" Reached EOF before finding \"}\"",
path, LineNbr(file));
if (c == '#')
Err("%s(%d): Comment not allowed here", path, LineNbr(file));
if (c != '}')
Err("%s(%d): Footer is not \"}\" "
"(too many or two few entries in matrix?)", path, LineNbr(file));
return true; // success
}
boolean_t trigger_delete_name(char *trigger_name, uint4 trigger_name_len, uint4 *trig_stats)
{
sgmnt_addrs *csa;
char curr_name[MAX_MIDENT_LEN + 1];
uint4 curr_name_len, orig_name_len;
mval mv_curr_nam;
char *ptr;
char *name_tail_ptr;
char save_name[MAX_MIDENT_LEN + 1];
gv_key save_currkey[DBKEYALLOC(MAX_KEY_SZ)];
gd_region *save_gv_cur_region, *lgtrig_reg;
gv_namehead *save_gv_target;
sgm_info *save_sgm_info_ptr;
mval trig_gbl;
mval *trigger_count;
char trigvn[MAX_MIDENT_LEN + 1];
int trigvn_len;
int trig_indx;
int badpos;
boolean_t wildcard;
char utilprefix[1024];
int utilprefixlen;
boolean_t first_gtmio;
uint4 triggers_deleted;
mval trigjrec;
boolean_t jnl_format_done;
gd_region *reg, *reg_top;
char disp_trigvn[MAX_MIDENT_LEN + SPANREG_REGION_LITLEN + MAX_RN_LEN + 1 + 1];
/* SPANREG_REGION_LITLEN for " (region ", MAX_RN_LEN for region name,
* 1 for ")" and 1 for trailing '\0'.
*/
int disp_trigvn_len;
int trig_protected_mval_push_count;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
badpos = 0;
trigjrec.mvtype = MV_STR;
trigjrec.str.len = trigger_name_len--;
trigjrec.str.addr = trigger_name++;
orig_name_len = trigger_name_len;
if ((0 == trigger_name_len)
|| (trigger_name_len != (badpos = validate_input_trigger_name(trigger_name, trigger_name_len, &wildcard))))
{ /* is the input name valid */
CONV_STR_AND_PRINT("Invalid trigger NAME string: ", orig_name_len, trigger_name);
/* badpos is the string position where the bad character was found, pretty print it */
trig_stats[STATS_ERROR_TRIGFILE]++;
return TRIG_FAILURE;
}
name_tail_ptr = trigger_name + trigger_name_len - 1;
if ((TRIGNAME_SEQ_DELIM == *name_tail_ptr) || wildcard)
trigger_name_len--; /* drop the trailing # sign for wildcard */
jnl_format_done = FALSE;
lgtrig_reg = NULL;
first_gtmio = TRUE;
triggers_deleted = 0;
assert(trigger_name_len < MAX_MIDENT_LEN);
memcpy(save_name, trigger_name, trigger_name_len);
save_name[trigger_name_len] = '\0';
utilprefixlen = ARRAYSIZE(utilprefix);
trig_protected_mval_push_count = 0;
INCR_AND_PUSH_MV_STENT(trigger_count); /* Protect trigger_count from garbage collection */
for (reg = gd_header->regions, reg_top = reg + gd_header->n_regions; reg < reg_top; reg++)
{
GVTR_SWITCH_REG_AND_HASHT_BIND_NAME(reg);
csa = cs_addrs;
if (NULL == csa) /* not BG or MM access method */
continue;
/* gv_target now points to ^#t in region "reg" */
/* To write the LGTRIG logical jnl record, choose some region that has journaling enabled */
if (!reg->read_only && !jnl_format_done && JNL_WRITE_LOGICAL_RECS(csa))
lgtrig_reg = reg;
if (!gv_target->root)
continue;
memcpy(curr_name, save_name, trigger_name_len);
curr_name_len = trigger_name_len;
do {
/* GVN = $get(^#t("#TNAME",curr_name)) */
BUILD_HASHT_SUB_SUB_CURRKEY(LITERAL_HASHTNAME, STRLEN(LITERAL_HASHTNAME), curr_name, curr_name_len);
if (gvcst_get(&trig_gbl))
{
if (reg->read_only)
rts_error_csa(CSA_ARG(csa) VARLSTCNT(4) ERR_TRIGMODREGNOTRW, 2, REG_LEN_STR(reg));
SAVE_TRIGGER_REGION_INFO(save_currkey);
ptr = trig_gbl.str.addr;
trigvn_len = MIN(trig_gbl.str.len, MAX_MIDENT_LEN);
STRNLEN(ptr, trigvn_len, trigvn_len);
ptr += trigvn_len;
if ((trig_gbl.str.len == trigvn_len) || ('\0' != *ptr))
{ /* We expect $c(0) in the middle of ptr. If not found, this is a restartable situation */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""),
curr_name_len, curr_name);
}
memcpy(trigvn, trig_gbl.str.addr, trigvn_len);
/* the index is just beyond the length of the GVN string */
ptr++;
A2I(ptr, trig_gbl.str.addr + trig_gbl.str.len, trig_indx);
if (1 > trig_indx)
{ /* Trigger indexes start from 1 */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_TRIGNAMBAD, 4, LEN_AND_LIT("\"#TNAME\""),
curr_name_len, curr_name);
}
SET_DISP_TRIGVN(reg, disp_trigvn, disp_trigvn_len, trigvn, trigvn_len);
/* $get(^#t(GVN,"COUNT") */
BUILD_HASHT_SUB_SUB_CURRKEY(trigvn, trigvn_len, LITERAL_HASHCOUNT, STRLEN(LITERAL_HASHCOUNT));
if (!gvcst_get(trigger_count))
{
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
util_out_print_gtmio("Trigger named !AD exists in the lookup table, "
"but global ^!AD has no triggers",
FLUSH, curr_name_len, curr_name, disp_trigvn_len, disp_trigvn);
trig_stats[STATS_ERROR_TRIGFILE]++;
RETURN_AND_POP_MVALS(TRIG_FAILURE);
}
if (!jnl_format_done && JNL_WRITE_LOGICAL_RECS(csa))
{
jnl_format(JNL_LGTRIG, NULL, &trigjrec, 0);
jnl_format_done = TRUE;
}
/* kill the target trigger for GVN at index trig_indx */
if (PUT_SUCCESS != (trigger_delete(trigvn, trigvn_len, trigger_count, trig_indx)))
{
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
util_out_print_gtmio("Trigger named !AD exists in the lookup table for global ^!AD," \
" but was not deleted!", FLUSH, orig_name_len, trigger_name,
disp_trigvn_len, disp_trigvn);
trig_stats[STATS_ERROR_TRIGFILE]++;
RETURN_AND_POP_MVALS(TRIG_FAILURE);
} else
{
csa->incr_db_trigger_cycle = TRUE;
trigger_incr_cycle(trigvn, trigvn_len); /* ^#t records changed, increment cycle */
if (dollar_ztrigger_invoked)
{ /* Increment db_dztrigger_cycle so that next gvcst_put/gvcst_kill in this
* transaction, on this region, will re-read triggers. See trigger_update.c
* for a comment on why it is okay for db_dztrigger_cycle to be incremented
* more than once in the same transaction.
*/
csa->db_dztrigger_cycle++;
}
trig_stats[STATS_DELETED]++;
if (0 == trig_stats[STATS_ERROR_TRIGFILE])
{
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
util_out_print_gtmio("Deleted trigger named '!AD' for global ^!AD",
FLUSH, curr_name_len, curr_name, disp_trigvn_len, disp_trigvn);
}
}
trigger_count->mvtype = 0; /* allow stp_gcol to release the current contents if necessary */
RESTORE_TRIGGER_REGION_INFO(save_currkey);
triggers_deleted++;
}
if (!wildcard)
/* not a wild card, don't $order for the next match */
break;
op_gvorder(&mv_curr_nam);
if (0 == mv_curr_nam.str.len)
break;
assert(mv_curr_nam.str.len < MAX_MIDENT_LEN);
memcpy(curr_name, mv_curr_nam.str.addr, mv_curr_nam.str.len);
curr_name_len = mv_curr_nam.str.len;
if (0 != memcmp(curr_name, save_name, trigger_name_len))
/* stop when gv_order returns a string that no longer starts save_name */
break;
} while (TRUE);
}
DECR_AND_POP_MV_STENT();
if (!jnl_format_done && (NULL != lgtrig_reg))
{ /* There was no journaled region that had a ^#t update, but found at least one journaled region
* so write a LGTRIG logical jnl record there.
*/
GVTR_SWITCH_REG_AND_HASHT_BIND_NAME(lgtrig_reg);
csa = cs_addrs;
/* Attach to jnlpool. Normally SET or KILL of the ^#t records take care of this but in
* case this is a NO-OP trigger operation that wont update any ^#t records and we still
* want to write a TLGTRIG/ULGTRIG journal record. Hence the need to do this.
*/
JNLPOOL_INIT_IF_NEEDED(csa, csa->hdr, csa->nl);
assert(dollar_tlevel);
/* below is needed to set update_trans TRUE on this region even if NO db updates happen to ^#t nodes */
T_BEGIN_SETORKILL_NONTP_OR_TP(ERR_TRIGLOADFAIL);
jnl_format(JNL_LGTRIG, NULL, &trigjrec, 0);
jnl_format_done = TRUE;
}
if (wildcard)
{
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
if (triggers_deleted)
{
trig_stats[STATS_NOERROR_TRIGFILE]++;
util_out_print_gtmio("All existing triggers named !AD (count = !UL) now deleted",
FLUSH, orig_name_len, trigger_name, triggers_deleted);
} else
{
trig_stats[STATS_UNCHANGED_TRIGFILE]++;
util_out_print_gtmio("No matching triggers of the form !AD found for deletion",
FLUSH, orig_name_len, trigger_name);
}
} else if (triggers_deleted)
{
/* util_out_print_gtmio of "Deleted trigger named ..." already done so no need to do it again */
trig_stats[STATS_NOERROR_TRIGFILE]++;
} else
{ /* No names match. But treat it as a no-op (i.e. success). */
UTIL_PRINT_PREFIX_IF_NEEDED(first_gtmio, utilprefix, &utilprefixlen);
util_out_print_gtmio("Trigger named !AD does not exist", FLUSH, orig_name_len, trigger_name);
trig_stats[STATS_UNCHANGED_TRIGFILE]++;
}
return TRIG_SUCCESS;
}
STATICFNDEF int4 update_trigger_hash_value(char *trigvn, int trigvn_len, char **values, uint4 *value_len, stringkey *set_hash,
stringkey *kill_hash, int old_trig_index, int new_trig_index)
{
sgmnt_addrs *csa;
int hash_index;
mval key_val;
uint4 len;
mval mv_hash;
mval mv_hash_indx;
int num_len;
char *ptr;
int4 result;
char tmp_str[MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT];
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(!gv_cur_region->read_only); /* caller should have already checked this */
assert(cs_addrs->hasht_tree == gv_target); /* should have been set up by caller */
assert(gv_target->root); /* should have been ensured by caller */
csa = cs_addrs;
if ((NULL != strchr(values[CMD_SUB], 'S')) && (set_hash->hash_code != kill_hash->hash_code))
{
if (!search_trigger_hash(trigvn, trigvn_len, set_hash, old_trig_index, &hash_index))
{ /* There has to be an entry with the old hash value, we just looked it up */
TRHASH_DEFINITION_RETRY_OR_ERROR(set_hash, csa);
}
MV_FORCE_UMVAL(&mv_hash, set_hash->hash_code);
MV_FORCE_UMVAL(&mv_hash_indx, hash_index);
BUILD_HASHT_SUB_SUB_MSUB_MSUB_CURRKEY(trigvn, trigvn_len,
LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH), mv_hash, mv_hash_indx);
if (!gvcst_get(&key_val))
{ /* There has to be a #TRHASH entry */
TRHASH_DEFINITION_RETRY_OR_ERROR(set_hash, csa);
}
assert((MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT) >= key_val.str.len);
ptr = key_val.str.addr;
len = MIN(key_val.str.len, MAX_MIDENT_LEN);
STRNLEN(ptr, len, len);
ptr += len;
if ((key_val.str.len == len) || ('\0' != *ptr))
{ /* We expect $c(0) in the middle of ptr. If we dont find it, this is a restartable situation */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(REG2CSA(gv_cur_region)) VARLSTCNT(8) ERR_TRIGDEFBAD, 6, trigvn_len, trigvn,
LEN_AND_LIT("\"#BHASH\""), mv_hash.str.len, mv_hash.str.addr);
}
memcpy(tmp_str, key_val.str.addr, len);
ptr = tmp_str + len;
*ptr++ = '\0';
num_len = 0;
I2A(ptr, num_len, new_trig_index);
len += num_len + 1;
SET_TRIGGER_GLOBAL_SUB_SUB_MSUB_MSUB_STR(trigvn, trigvn_len,
LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH), mv_hash, mv_hash_indx, tmp_str, len, result);
if (PUT_SUCCESS != result)
return result;
}
if (!search_trigger_hash(trigvn, trigvn_len, kill_hash, old_trig_index, &hash_index))
{ /* There has to be an entry with the old hash value, we just looked it up */
TRHASH_DEFINITION_RETRY_OR_ERROR(kill_hash, csa);
}
MV_FORCE_UMVAL(&mv_hash, kill_hash->hash_code);
MV_FORCE_UMVAL(&mv_hash_indx, hash_index);
BUILD_HASHT_SUB_SUB_MSUB_MSUB_CURRKEY(trigvn, trigvn_len,
LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH), mv_hash, mv_hash_indx);
if (!gvcst_get(&key_val))
{ /* There has to be a #TRHASH entry */
TRHASH_DEFINITION_RETRY_OR_ERROR(kill_hash, csa);
}
assert((MAX_MIDENT_LEN + 1 + MAX_DIGITS_IN_INT) >= key_val.str.len);
ptr = key_val.str.addr;
len = MIN(key_val.str.len, MAX_MIDENT_LEN);
STRNLEN(ptr, len, len);
ptr += len;
if ((key_val.str.len == len) || ('\0' != *ptr))
{ /* We expect $c(0) in the middle of ptr. If we dont find it, this is a restartable situation */
if (CDB_STAGNATE > t_tries)
t_retry(cdb_sc_triggermod);
assert(WBTEST_HELPOUT_TRIGDEFBAD == gtm_white_box_test_case_number);
rts_error_csa(CSA_ARG(REG2CSA(gv_cur_region)) VARLSTCNT(8) ERR_TRIGDEFBAD, 6, trigvn_len, trigvn,
LEN_AND_LIT("\"#LHASH\""), mv_hash.str.len, mv_hash.str.addr);
}
memcpy(tmp_str, key_val.str.addr, len);
ptr = tmp_str + len;
*ptr++ = '\0';
num_len = 0;
I2A(ptr, num_len, new_trig_index);
len += num_len + 1;
SET_TRIGGER_GLOBAL_SUB_SUB_MSUB_MSUB_STR(trigvn, trigvn_len,
LITERAL_HASHTRHASH, STRLEN(LITERAL_HASHTRHASH), mv_hash, mv_hash_indx, tmp_str, len, result);
return result;
}
static int
do_test (void)
{
int size = sysconf (_SC_PAGESIZE);
int nchars = size / sizeof (CHAR);
CHAR *adr;
CHAR *dest;
int result = 0;
adr = (CHAR *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, -1, 0);
dest = (CHAR *) mmap (NULL, 3 * size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, -1, 0);
if (adr == MAP_FAILED || dest == MAP_FAILED)
{
if (errno == ENOSYS)
puts ("No test, mmap not available.");
else
{
printf ("mmap failed: %m");
result = 1;
}
}
else
{
int inner, middle, outer;
mprotect (adr, size, PROT_NONE);
mprotect (adr + 2 * nchars, size, PROT_NONE);
adr += nchars;
mprotect (dest, size, PROT_NONE);
mprotect (dest + 2 * nchars, size, PROT_NONE);
dest += nchars;
MEMSET (adr, L('T'), nchars);
/* strlen/wcslen test */
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
{
adr[inner] = L('\0');
if (STRLEN (&adr[outer]) != (size_t) (inner - outer))
{
printf ("%s flunked for outer = %d, inner = %d\n",
STRINGIFY (STRLEN), outer, inner);
result = 1;
}
adr[inner] = L('T');
}
}
/* strnlen/wcsnlen test */
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
{
for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
{
adr[inner] = L('\0');
if (STRNLEN (&adr[outer], inner - outer + 1)
!= (size_t) (inner - outer))
{
printf ("%s flunked for outer = %d, inner = %d\n",
STRINGIFY (STRNLEN), outer, inner);
result = 1;
}
adr[inner] = L('T');
}
}
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
{
for (inner = MAX (outer, nchars - 64); inner <= nchars; ++inner)
{
if (STRNLEN (&adr[outer], inner - outer)
!= (size_t) (inner - outer))
{
printf ("%s flunked bounded for outer = %d, inner = %d\n",
STRINGIFY (STRNLEN), outer, inner);
result = 1;
}
}
}
/* strchr/wcschr test */
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
{
for (inner = middle; inner < nchars; ++inner)
{
adr[middle] = L('V');
adr[inner] = L('\0');
CHAR *cp = STRCHR (&adr[outer], L('V'));
if ((inner == middle && cp != NULL)
|| (inner != middle
&& (cp - &adr[outer]) != middle - outer))
{
printf ("%s flunked for outer = %d, middle = %d, "
"inner = %d\n",
STRINGIFY (STRCHR), outer, middle, inner);
result = 1;
}
adr[inner] = L('T');
adr[middle] = L('T');
}
}
}
/* Special test. */
adr[nchars - 1] = L('\0');
if (STRCHR (&adr[nchars - 1], L('\n')) != NULL)
{
printf ("%s flunked test of empty string at end of page\n",
STRINGIFY (STRCHR));
result = 1;
}
/* strrchr/wcsrchr test */
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
{
for (inner = middle; inner < nchars; ++inner)
{
adr[middle] = L('V');
adr[inner] = L('\0');
CHAR *cp = STRRCHR (&adr[outer], L('V'));
if ((inner == middle && cp != NULL)
|| (inner != middle
&& (cp - &adr[outer]) != middle - outer))
{
printf ("%s flunked for outer = %d, middle = %d, "
"inner = %d\n",
STRINGIFY (STRRCHR), outer, middle, inner);
result = 1;
}
adr[inner] = L('T');
adr[middle] = L('T');
}
}
}
/* memchr test */
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
{
adr[middle] = L('V');
CHAR *cp = MEMCHR (&adr[outer], L('V'), 3 * size);
if (cp - &adr[outer] != middle - outer)
{
printf ("%s flunked for outer = %d, middle = %d\n",
STRINGIFY (MEMCHR), outer, middle);
result = 1;
}
adr[middle] = L('T');
}
}
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
{
CHAR *cp = MEMCHR (&adr[outer], L('V'), nchars - outer);
if (cp != NULL)
{
printf ("%s flunked for outer = %d\n",
STRINGIFY (MEMCHR), outer);
result = 1;
}
}
/* These functions only exist for single-byte characters. */
#ifndef WCSTEST
/* rawmemchr test */
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
{
adr[middle] = L('V');
CHAR *cp = rawmemchr (&adr[outer], L('V'));
if (cp - &adr[outer] != middle - outer)
{
printf ("%s flunked for outer = %d, middle = %d\n",
STRINGIFY (rawmemchr), outer, middle);
result = 1;
}
adr[middle] = L('T');
}
}
/* memrchr test */
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
{
adr[middle] = L('V');
CHAR *cp = memrchr (&adr[outer], L('V'), nchars - outer);
if (cp - &adr[outer] != middle - outer)
{
printf ("%s flunked for outer = %d, middle = %d\n",
STRINGIFY (memrchr), outer, middle);
result = 1;
}
adr[middle] = L('T');
}
}
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
{
CHAR *cp = memrchr (&adr[outer], L('V'), nchars - outer);
if (cp != NULL)
{
printf ("%s flunked for outer = %d\n",
STRINGIFY (memrchr), outer);
result = 1;
}
}
#endif
/* strcpy/wcscpy test */
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
{
adr[inner] = L('\0');
if (STRCPY (dest, &adr[outer]) != dest
|| STRLEN (dest) != (size_t) (inner - outer))
{
printf ("%s flunked for outer = %d, inner = %d\n",
STRINGIFY (STRCPY), outer, inner);
result = 1;
}
adr[inner] = L('T');
}
}
/* strcmp/wcscmp tests */
for (outer = 1; outer < 32; ++outer)
for (middle = 0; middle < 16; ++middle)
{
MEMSET (adr + middle, L('T'), 256);
adr[256] = L('\0');
MEMSET (dest + nchars - outer, L('T'), outer - 1);
dest[nchars - 1] = L('\0');
if (STRCMP (adr + middle, dest + nchars - outer) <= 0)
{
printf ("%s 1 flunked for outer = %d, middle = %d\n",
STRINGIFY (STRCMP), outer, middle);
result = 1;
}
if (STRCMP (dest + nchars - outer, adr + middle) >= 0)
{
printf ("%s 2 flunked for outer = %d, middle = %d\n",
STRINGIFY (STRCMP), outer, middle);
result = 1;
}
}
/* strncmp/wcsncmp tests */
for (outer = 1; outer < 32; ++outer)
for (middle = 0; middle < 16; ++middle)
{
MEMSET (adr + middle, L('T'), 256);
adr[256] = L('\0');
MEMSET (dest + nchars - outer, L('T'), outer - 1);
dest[nchars - 1] = L('U');
for (inner = 0; inner < outer; ++inner)
{
if (STRNCMP (adr + middle, dest + nchars - outer, inner) != 0)
{
printf ("%s 1 flunked for outer = %d, middle = %d, "
"inner = %d\n",
STRINGIFY (STRNCMP), outer, middle, inner);
result = 1;
}
if (STRNCMP (dest + nchars - outer, adr + middle, inner) != 0)
{
printf ("%s 2 flunked for outer = %d, middle = %d, "
"inner = %d\n",
STRINGIFY (STRNCMP), outer, middle, inner);
result = 1;
}
}
if (STRNCMP (adr + middle, dest + nchars - outer, outer) >= 0)
{
printf ("%s 1 flunked for outer = %d, middle = %d, full\n",
STRINGIFY (STRNCMP), outer, middle);
result = 1;
}
if (STRNCMP (dest + nchars - outer, adr + middle, outer) <= 0)
{
printf ("%s 2 flunked for outer = %d, middle = %d, full\n",
STRINGIFY (STRNCMP), outer, middle);
result = 1;
}
}
/* strncpy/wcsncpy tests */
adr[nchars - 1] = L('T');
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
{
size_t len;
for (len = 0; len < nchars - outer; ++len)
{
if (STRNCPY (dest, &adr[outer], len) != dest
|| MEMCMP (dest, &adr[outer], len) != 0)
{
printf ("outer %s flunked for outer = %d, len = %Zd\n",
STRINGIFY (STRNCPY), outer, len);
result = 1;
}
}
}
adr[nchars - 1] = L('\0');
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
{
size_t len;
adr[inner] = L('\0');
for (len = 0; len < nchars - outer + 64; ++len)
{
if (STRNCPY (dest, &adr[outer], len) != dest
|| MEMCMP (dest, &adr[outer],
MIN (inner - outer, len)) != 0
|| (inner - outer < len
&& STRLEN (dest) != (inner - outer)))
{
printf ("%s flunked for outer = %d, inner = %d, "
"len = %Zd\n",
STRINGIFY (STRNCPY), outer, inner, len);
result = 1;
}
if (STRNCPY (dest + 1, &adr[outer], len) != dest + 1
|| MEMCMP (dest + 1, &adr[outer],
MIN (inner - outer, len)) != 0
|| (inner - outer < len
&& STRLEN (dest + 1) != (inner - outer)))
{
printf ("%s+1 flunked for outer = %d, inner = %d, "
"len = %Zd\n",
STRINGIFY (STRNCPY), outer, inner, len);
result = 1;
}
}
adr[inner] = L('T');
}
}
/* stpcpy/wcpcpy test */
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (inner = MAX (outer, nchars - 64); inner < nchars; ++inner)
{
adr[inner] = L('\0');
if ((STPCPY (dest, &adr[outer]) - dest) != inner - outer)
{
printf ("%s flunked for outer = %d, inner = %d\n",
STRINGIFY (STPCPY), outer, inner);
result = 1;
}
adr[inner] = L('T');
}
}
/* stpncpy/wcpncpy test */
adr[nchars - 1] = L('T');
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
{
size_t len;
for (len = 0; len < nchars - outer; ++len)
{
if (STPNCPY (dest, &adr[outer], len) != dest + len
|| MEMCMP (dest, &adr[outer], len) != 0)
{
printf ("outer %s flunked for outer = %d, len = %Zd\n",
STRINGIFY (STPNCPY), outer, len);
result = 1;
}
}
}
adr[nchars - 1] = L('\0');
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
{
for (middle = MAX (outer, nchars - 64); middle < nchars; ++middle)
{
adr[middle] = L('\0');
for (inner = 0; inner < nchars - outer; ++ inner)
{
if ((STPNCPY (dest, &adr[outer], inner) - dest)
!= MIN (inner, middle - outer))
{
printf ("%s flunked for outer = %d, middle = %d, "
"inner = %d\n",
STRINGIFY (STPNCPY), outer, middle, inner);
result = 1;
}
}
adr[middle] = L('T');
}
}
/* memcpy/wmemcpy test */
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
for (inner = 0; inner < nchars - outer; ++inner)
if (MEMCPY (dest, &adr[outer], inner) != dest)
{
printf ("%s flunked for outer = %d, inner = %d\n",
STRINGIFY (MEMCPY), outer, inner);
result = 1;
}
/* mempcpy/wmempcpy test */
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
for (inner = 0; inner < nchars - outer; ++inner)
if (MEMPCPY (dest, &adr[outer], inner) != dest + inner)
{
printf ("%s flunked for outer = %d, inner = %d\n",
STRINGIFY (MEMPCPY), outer, inner);
result = 1;
}
/* This function only exists for single-byte characters. */
#ifndef WCSTEST
/* memccpy test */
memset (adr, '\0', nchars);
for (outer = nchars; outer >= MAX (0, nchars - 128); --outer)
for (inner = 0; inner < nchars - outer; ++inner)
if (memccpy (dest, &adr[outer], L('\1'), inner) != NULL)
{
printf ("memccpy flunked full copy for outer = %d, inner = %d\n",
outer, inner);
result = 1;
}
for (outer = nchars - 1; outer >= MAX (0, nchars - 128); --outer)
for (middle = 0; middle < nchars - outer; ++middle)
{
memset (dest, L('\2'), middle + 1);
for (inner = 0; inner < middle; ++inner)
{
adr[outer + inner] = L('\1');
if (memccpy (dest, &adr[outer], '\1', middle + 128)
!= dest + inner + 1)
{
printf ("\
memccpy flunked partial copy for outer = %d, middle = %d, inner = %d\n",
outer, middle, inner);
result = 1;
}
else if (dest[inner + 1] != L('\2'))
{
printf ("\
memccpy copied too much for outer = %d, middle = %d, inner = %d\n",
outer, middle, inner);
result = 1;
}
adr[outer + inner] = L('\0');
}
/* Flags once read from the file. */
static int default_nss_flags;
/* Code to make sure we call 'init' once. */
__libc_once_define (static, once);
/* Table of the recognized variables. */
static const struct
{
char name[23];
unsigned int len;
int flag;
} vars[] =
{
#define STRNLEN(s) s, sizeof (s) - 1
{ STRNLEN ("NETID_AUTHORITATIVE"), NSS_FLAG_NETID_AUTHORITATIVE },
{ STRNLEN ("SERVICES_AUTHORITATIVE"), NSS_FLAG_SERVICES_AUTHORITATIVE },
{ STRNLEN ("SETENT_BATCH_READ"), NSS_FLAG_SETENT_BATCH_READ },
{ STRNLEN ("ADJUNCT_AS_SHADOW"), NSS_FLAG_ADJUNCT_AS_SHADOW },
};
#define nvars (sizeof (vars) / sizeof (vars[0]))
static void
init (void)
{
int saved_errno = errno;
FILE *fp = fopen (default_nss, "rc");
if (fp != NULL)
{
char *line = NULL;
/* Flags once read from the file. */
static int default_nss_flags;
/* Code to make sure we call 'init' once. */
__libc_once_define (static, once);
/* Table of the recognized variables. */
static const struct
{
char name[23];
unsigned int len;
int flag;
} vars[] =
{
#define STRNLEN(s) s, sizeof (s) - 1
{ STRNLEN ("NETID_AUTHORITATIVE"), NSS_FLAG_NETID_AUTHORITATIVE },
{ STRNLEN ("SERVICES_AUTHORITATIVE"), NSS_FLAG_SERVICES_AUTHORITATIVE },
{ STRNLEN ("SETENT_BATCH_READ"), NSS_FLAG_SETENT_BATCH_READ }
};
#define nvars (sizeof (vars) / sizeof (vars[0]))
static void
init (void)
{
int saved_errno = errno;
FILE *fp = fopen (default_nss, "rc");
if (fp != NULL)
{
char *line = NULL;
size_t linelen = 0;