main()
{
printf("%d\n",STRCHR("abc",'a'));
printf("%d\n",STRCHR("abc",'b'));
printf("%d\n",STRCHR("abc",'d'));
printf("%d\n",STRRCHR("abc",'a'));
printf("%d\n",STRRCHR("abc",'b'));
printf("%d\n",STRRCHR("abc",'d'));
}
/*===========================================================================
This function returns the file name portion of the path.
===========================================================================*/
char * TS_GetFileName(const char * psz)
{
char * pszName = STRRCHR(psz, (int)DIRECTORY_CHAR);
if (pszName)
pszName++;
else
pszName = (char *)psz;
return pszName;
}
// P R I V A T E M E T H O D S
int ACLStr::_FindCh
(
IN const TCHAR charToFind,
IN BOOL caseSensitive /*=TRUE*/,
IN BOOL reverseFind /*=FALSE*/
)
{
LPTSTR string = NULL;
TCHAR ib[MAX_STRING];
// Initialize this to the
// internal buffer.
LPTSTR ibPtr = _string;
TCHAR chToFind = charToFind;
// If the internal string is NULL or the lenght is
// zero then we will just bail and say we couldn't
// find the string we were searching for.
if (ibPtr != NULL || 0 != _length)
{
if (caseSensitive == TRUE)
{
chToFind = TOUPPER(charToFind);
// Now copy the internal ACLStr buffer to the new
// tempory Upper case version.
if (_string)
{
// NOTE: STRCPY_S(target, length, source) - The length parameter is for
// the length of the target string, not the source string.
STRCPY_S(ib, MAX_STRING, _string);
AnsiUpper(ib);
ibPtr = ib;
}
} // case sensitive search?
// Go look for the starting point of the string.
// if we do NOT find it return STR_NOTFOUND
if (reverseFind == TRUE)
{
string = STRRCHR(ibPtr, chToFind);
}
else
{
string = STRCHR(ibPtr, chToFind);
}
} // search string NULL?
return (string == NULL) ? STR_NOTFOUND : (int)(string - ibPtr);
} // ::_FindCh
INLINE int ispage(struct pike_string *url, struct multiset *pagexts)
{
char *dot;
int cnt;
if(!url->len)
return 0;
if(*(url->str+url->len-1) == '/' || *(url->str) != '/') {
return 1;
}
dot = STRRCHR(url->str, '.');
if(dot && multiset_string_lookup(pagexts, dot+1)) {
return 1;
}
return 0;
}
/*
* Read the errorfile into memory, line by line, building the error list.
* Return FAIL for error, OK for success.
*/
int
qf_init()
{
char_u namebuf[CMDBUFFSIZE + 1];
char_u errmsg[CMDBUFFSIZE + 1];
int col;
int type;
int valid;
long lnum;
int enr;
FILE *fd;
struct qf_line *qfp = NULL;
struct qf_line *qfprev = NULL; /* init to make SASC shut up */
char_u *pfmt, *fmtstr;
#ifdef UTS2
char_u *(adr[7]);
#else
void *(adr[7]);
#endif
int adr_cnt = 0;
int maxlen;
int i;
if (p_ef == NULL || *p_ef == NUL)
{
emsg(e_errorf);
return FAIL;
}
if ((fd = fopen((char *)p_ef, "r")) == NULL)
{
emsg2(e_openerrf, p_ef);
return FAIL;
}
qf_free();
qf_index = 0;
for (i = 0; i < 7; ++i)
adr[i] = NULL;
/*
* The format string is copied and modified from p_efm to fmtstr.
* Only a few % characters are allowed.
*/
/* get some space to modify the format string into */
/* must be able to do the largest expansion 7 times (7 x 3) */
maxlen = STRLEN(p_efm) + 25;
fmtstr = alloc(maxlen);
if (fmtstr == NULL)
goto error2;
for (pfmt = p_efm, i = 0; *pfmt; ++pfmt, ++i)
{
if (pfmt[0] != '%') /* copy normal character */
fmtstr[i] = pfmt[0];
else
{
fmtstr[i++] = '%';
switch (pfmt[1])
{
case 'f': /* filename */
adr[adr_cnt++] = namebuf;
case 'm': /* message */
if (pfmt[1] == 'm')
adr[adr_cnt++] = errmsg;
fmtstr[i++] = '[';
fmtstr[i++] = '^';
if (pfmt[2])
fmtstr[i++] = pfmt[2];
else
#ifdef MSDOS
fmtstr[i++] = '\r';
#else
fmtstr[i++] = '\n';
#endif
fmtstr[i] = ']';
break;
case 'c': /* column */
adr[adr_cnt++] = &col;
fmtstr[i] = 'd';
break;
case 'l': /* line */
adr[adr_cnt++] = &lnum;
fmtstr[i++] = 'l';
fmtstr[i] = 'd';
break;
case 'n': /* error number */
adr[adr_cnt++] = &enr;
fmtstr[i] = 'd';
break;
case 't': /* error type */
adr[adr_cnt++] = &type;
fmtstr[i] = 'c';
break;
case '%': /* %% */
case '*': /* %*: no assignment */
fmtstr[i] = pfmt[1];
break;
default:
EMSG("invalid % in format string");
goto error2;
}
if (adr_cnt == 7)
{
EMSG("too many % in format string");
goto error2;
}
++pfmt;
}
if (i >= maxlen - 6)
{
EMSG("invalid format string");
goto error2;
}
}
fmtstr[i] = NUL;
while (fgets((char *)IObuff, CMDBUFFSIZE, fd) != NULL && !got_int)
{
if ((qfp = (struct qf_line *)alloc((unsigned)sizeof(struct qf_line))) == NULL)
goto error2;
IObuff[CMDBUFFSIZE] = NUL; /* for very long lines */
namebuf[0] = NUL;
errmsg[0] = NUL;
lnum = 0;
col = 0;
enr = -1;
type = 0;
valid = TRUE;
if (sscanf((char *)IObuff, (char *)fmtstr, adr[0], adr[1], adr[2], adr[3],
adr[4], adr[5]) != adr_cnt)
{
namebuf[0] = NUL; /* something failed, remove file name */
valid = FALSE;
STRCPY(errmsg, IObuff); /* copy whole line to error message */
if ((pfmt = STRRCHR(errmsg, '\n')) != NULL)
*pfmt = NUL;
#ifdef MSDOS
if ((pfmt = STRRCHR(errmsg, '\r')) != NULL)
*pfmt = NUL;
#endif
}
if (namebuf[0] == NUL) /* no file name */
qfp->qf_fnum = 0;
else
qfp->qf_fnum = buflist_add(namebuf);
if ((qfp->qf_text = strsave(errmsg)) == NULL)
goto error1;
qfp->qf_lnum = lnum;
qfp->qf_col = col;
qfp->qf_nr = enr;
qfp->qf_type = type;
qfp->qf_valid = valid;
if (qf_count == 0) /* first element in the list */
{
qf_start = qfp;
qfp->qf_prev = qfp; /* first element points to itself */
}
else
{
qfp->qf_prev = qfprev;
qfprev->qf_next = qfp;
}
qfp->qf_next = qfp; /* last element points to itself */
qfp->qf_cleared = FALSE;
qfprev = qfp;
++qf_count;
if (qf_index == 0 && qfp->qf_valid) /* first valid entry */
{
qf_index = qf_count;
qf_ptr = qfp;
}
breakcheck();
}
free(fmtstr);
if (!ferror(fd))
{
if (qf_index == 0) /* no valid entry found */
{
qf_ptr = qf_start;
qf_index = 1;
qf_nonevalid = TRUE;
}
else
qf_nonevalid = FALSE;
fclose(fd);
qf_jump(0, 0); /* display first error */
return OK;
}
emsg(e_readerrf);
error1:
free(qfp);
error2:
fclose(fd);
qf_free();
return FAIL;
}
/* mode
0,1: Default mode.
2: Remove the directory path of input_filename, then add output_dir.
3: Replace directory separator characters ('/','\',':') with '_', then add output_dir.
*/
char *create_auto_output_name(const char *input_filename, char *ext_str, char *output_dir, int mode)
{
char *output_filename;
char *ext, *p;
int32 dir_len = 0;
char ext_str_tmp[65];
output_filename = (char *)safe_malloc((output_dir?strlen(output_dir):0) + strlen(input_filename) + 6);
if(output_filename==NULL)
return NULL;
output_filename[0] = '\0';
if(output_dir!=NULL && (mode==2 || mode==3)) {
strcat(output_filename,output_dir);
dir_len = strlen(output_filename);
#ifndef __W32__
if(dir_len>0 && output_filename[dir_len-1]!=PATH_SEP){
#else
if(dir_len>0 && output_filename[dir_len-1]!='/' && output_filename[dir_len-1]!='\\' && output_filename[dir_len-1]!=':'){
#endif
strcat(output_filename,PATH_STRING);
dir_len++;
}
}
strcat(output_filename, input_filename);
if((ext = strrchr(output_filename, '.')) == NULL)
ext = output_filename + strlen(output_filename);
else {
/* strip ".gz" */
if(strcasecmp(ext, ".gz") == 0) {
*ext = '\0';
if((ext = strrchr(output_filename, '.')) == NULL)
ext = output_filename + strlen(output_filename);
}
}
/* replace '\' , '/' or PATH_SEP between '#' and ext */
p = strrchr(output_filename,'#');
if(p!=NULL){
char *p1;
#ifdef _mbsrchr
#define STRCHR(a,b) _mbschr(a,b)
#else
#define STRCHR(a,b) strchr(a,b)
#endif
#ifndef __W32__
p1 = p + 1;
while((p1 = STRCHR(p1,PATH_SEP))!=NULL && p1<ext){
*p1 = '_';
p1++;
}
#else
p1 = p + 1;
while((p1 = STRCHR(p1,'\\'))!=NULL && p1<ext){
*p1 = '_';
p1++;
}
p1 = p;
while((p1 = STRCHR(p1,'/'))!=NULL && p1<ext){
*p1 = '_';
p1++;
}
#endif
#undef STRCHR
}
/* replace '.' and '#' before ext */
for(p = output_filename; p < ext; p++)
#ifndef __W32__
if(*p == '.' || *p == '#')
#else
if(*p == '#')
#endif
*p = '_';
if(mode==2){
char *p1,*p2,*p3;
#ifndef __W32__
p = strrchr(output_filename+dir_len,PATH_SEP);
#else
#ifdef _mbsrchr
#define STRRCHR _mbsrchr
#else
#define STRRCHR strrchr
#endif
p1 = STRRCHR(output_filename+dir_len,'/');
p2 = STRRCHR(output_filename+dir_len,'\\');
p3 = STRRCHR(output_filename+dir_len,':');
#undef STRRCHR
p1>p2 ? (p1>p3 ? (p = p1) : (p = p3)) : (p2>p3 ? (p = p2) : (p = p3));
#endif
if(p!=NULL){
for(p1=output_filename+dir_len,p2=p+1; *p2; p1++,p2++)
*p1 = *p2;
*p1 = '\0';
}
}
if(mode==3){
for(p=output_filename+dir_len; *p; p++)
#ifndef __W32__
if(*p==PATH_SEP)
#else
if(*p=='/' || *p=='\\' || *p==':')
#endif
*p = '_';
}
if((ext = strrchr(output_filename, '.')) == NULL)
ext = output_filename + strlen(output_filename);
if(*ext){
strncpy(ext_str_tmp,ext_str,64);
ext_str_tmp[64]=0;
if(isupper(*(ext + 1))){
for(p=ext_str_tmp;*p;p++)
*p = toupper(*p);
*p = '\0';
} else {
for(p=ext_str_tmp;*p;p++)
*p = tolower(*p);
*p = '\0';
}
strcpy(ext+1,ext_str_tmp);
}
return output_filename;
}
int32_t CTB_compress(const char *filename)
{
char *p, tmp_file[MAXPATH], file_name[MAXPATH];
CTB_handle hi, ho;
int32_t i, n, compress;
uchar dst[CTB_DATA_SIZE], buffer[256* 128 + 2 + CTB_DATA_SIZE ];
p = ctb_last_punct(file_name);
strcpy(file_name, filename);
ctb_err_code = CTB_ERR_NONE;
if (p)
*p = '\0';
STRCPY(tmp_file, file_name);
p = STRRCHR(tmp_file, '\\');
if (p) {
*(p + 1) = '\0';
STRCAT(tmp_file, "$$$$$$$$");
}
else
STRCPY(tmp_file, "$$$$$$$$");
if (!CTB_open(file_name, &hi, "w"))
return FALSE;
CTB_read_global_data(&hi, dst);
CTB_files_init(tmp_file, dst, hi.width, hi.height, hi.dpb, hi.signums,
hi.attr_size);
n = CTB_volume(&hi);
compress = hi.need_compress;
if (compress) {
if (!CTB_open(tmp_file, &ho, "w"))
return 0;
for (i = 0; i < n; i++) {
switch (CTB_read(&hi, i, buffer, dst)) {
case 1:
CTB_write_mark(&ho, -1, buffer, dst, FALSE);
break;
case 2:
CTB_write_mark(&ho, -1, buffer, dst, TRUE);
break;
default:
break;
}
}
ho.need_compress = 0;
CTB_close(&ho);
}
hi.need_compress = 0;
CTB_close(&hi);
if (!compress) { // delete tmp file //
STRCAT(tmp_file, ".CTB");
UNLINK(tmp_file);
*ctb_last_punct(tmp_file) = 0;
STRCAT(tmp_file, ".IND");
UNLINK(tmp_file);
return 0;
}
STRCAT(file_name, ".CTB");
STRCAT(tmp_file, ".CTB");
UNLINK(file_name);
RENAME(tmp_file, file_name);
*ctb_last_punct(tmp_file) = 0;
*ctb_last_punct(file_name) = 0;
STRCAT(file_name, ".IND");
STRCAT(tmp_file, ".IND");
UNLINK(file_name);
RENAME(tmp_file, file_name);
return n;
}
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');
}
/* EXTPROTO */
void
rxvt_makeutent(rxvt_t *r, const char *pty, const char *hostname)
{
#ifdef HAVE_STRUCT_UTMP
struct utmp *ut = &(r->h->ut);
#endif
#ifdef HAVE_STRUCT_UTMPX
struct utmpx *utx = &(r->h->utx);
#endif
char ut_id[5];
struct passwd *pwent = getpwuid(getuid());
if (!STRNCMP(pty, "/dev/", 5))
pty += 5; /* skip /dev/ prefix */
if (!STRNCMP(pty, "pty", 3) || !STRNCMP(pty, "tty", 3)) {
STRNCPY(ut_id, (pty + 3), sizeof(ut_id));
}
#ifdef RXVT_UTMP_PID
else if (sscanf(pty, "pts/%d", &i) == 1)
sprintf(ut_id, "vt%02x", (i & 0xff)); /* sysv naming */
#endif
else if (STRNCMP(pty, "pty", 3) && STRNCMP(pty, "tty", 3)) {
rxvt_print_error("can't parse tty name \"%s\"", pty);
return;
}
#ifdef HAVE_STRUCT_UTMP
MEMSET(ut, 0, sizeof(struct utmp));
# ifdef RXVT_UTMP_PID
setutent();
STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
ut->ut_type = DEAD_PROCESS;
getutid(ut); /* position to entry in utmp file */
STRNCPY(r->h->ut_id, ut_id, sizeof(r->h->ut_id));
# endif
#endif
#ifdef HAVE_STRUCT_UTMPX
MEMSET(utx, 0, sizeof(struct utmpx));
setutxent();
STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
utx->ut_type = DEAD_PROCESS;
getutxid(utx); /* position to entry in utmp file */
STRNCPY(r->h->ut_id, ut_id, sizeof(r->h->ut_id));
#endif
#ifdef HAVE_STRUCT_UTMP
STRNCPY(ut->ut_line, pty, sizeof(ut->ut_line));
ut->ut_time = time(NULL);
# ifdef RXVT_UTMP_PID
STRNCPY(ut->ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
sizeof(ut->ut_user));
STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
ut->ut_time = time(NULL);
ut->ut_pid = r->h->cmd_pid;
# ifdef HAVE_UTMP_HOST
STRNCPY(ut->ut_host, hostname, sizeof(ut->ut_host));
# endif
ut->ut_type = USER_PROCESS;
pututline(ut);
endutent(); /* close the file */
r->h->utmp_pos = -1;
# else
STRNCPY(ut->ut_name, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
sizeof(ut->ut_name));
STRNCPY(ut->ut_host, hostname, sizeof(ut->ut_host));
# endif
#endif
#ifdef HAVE_STRUCT_UTMPX
STRNCPY(utx->ut_line, pty, sizeof(utx->ut_line));
STRNCPY(utx->ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
sizeof(utx->ut_user));
STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
utx->ut_session = getsid(0);
utx->ut_tv.tv_sec = time(NULL);
utx->ut_tv.tv_usec = 0;
utx->ut_pid = r->h->cmd_pid;
# ifdef HAVE_UTMPX_HOST
STRNCPY(utx->ut_host, hostname, sizeof(utx->ut_host));
# if 0
{
char *colon;
if ((colon = STRRCHR(ut->ut_host, ':')) != NULL)
*colon = '\0';
}
# endif
# endif
utx->ut_type = USER_PROCESS;
pututxline(utx);
endutxent(); /* close the file */
r->h->utmp_pos = -1;
#endif
#if defined(HAVE_STRUCT_UTMP) && !defined(RXVT_UTMP_PID)
{
int i;
# ifdef HAVE_TTYSLOT
i = ttyslot();
if (rxvt_write_bsd_utmp(i, ut))
r->h->utmp_pos = i;
# else
FILE *fd0;
if ((fd0 = fopen(TTYTAB_FILENAME, "r")) != NULL) {
char buf[256], name[256];
buf[sizeof(buf) - 1] = '\0';
for (i = 1; (fgets(buf, sizeof(buf) - 1, fd0) != NULL);) {
if (*buf == '#' || sscanf(buf, "%s", name) != 1)
continue;
if (!STRCMP(ut->ut_line, name)) {
if (!rxvt_write_bsd_utmp(i, ut))
i = 0;
r->h->utmp_pos = i;
fclose(fd0);
break;
}
i++;
}
fclose(fd0);
}
# endif
}
#endif
#ifdef WTMP_SUPPORT
# ifdef WTMP_ONLY_ON_LOGIN
if (r->Options & Opt_loginShell)
# endif
{
# ifdef HAVE_STRUCT_UTMP
# ifdef HAVE_UPDWTMP
updwtmp(RXVT_WTMP_FILE, ut);
# else
rxvt_update_wtmp(RXVT_WTMP_FILE, ut);
# endif
# endif
# ifdef HAVE_STRUCT_UTMPX
updwtmpx(RXVT_WTMPX_FILE, utx);
# endif
}
#endif
#if defined(LASTLOG_SUPPORT) && defined(RXVT_LASTLOG_FILE)
if (r->Options & Opt_loginShell)
rxvt_update_lastlog(RXVT_LASTLOG_FILE, pty, hostname);
#endif
}
/* EXTPROTO */
char *
rindex(const char *s, int c)
{
return STRRCHR(s, c);
}