152 #if defined( HAVE_LOCALE_H )
158 #if defined( HAVE_SYS_WAIT_H )
159 # include <sys/wait.h>
165 #if defined( HAVE_MALLOC_H )
178 #include <sys/stat.h>
181 #include <sys/types.h>
183 #include <sys/syscall.h>
185 #include <sys/utsname.h>
188 #include <semaphore.h>
194 #if defined( HAVE_SYS_SEM_H )
195 # include <sys/sem.h>
199 #include <sys/time.h>
203 #if defined( HAVE_SYS_SELECT_H )
204 # include <sys/select.h>
207 #if defined( HAVE_SYS_LDR_H )
208 # include <sys/ldr.h>
211 #if defined( HAVE_STRINGS_H )
212 # include <strings.h>
217 #if defined( HAVE_SYS_UTSNAME_H )
218 # include <sys/utsname.h>
223 #if defined( HAVE_SYS_RESOURCE_H )
224 # include <sys/resource.h>
227 #if defined( HAVE_FEATURES_H )
228 # include <features.h>
231 #if defined( HAVE_NL_TYPES_H )
232 # include <nl_types.h>
239 #if !defined( HAVE_UNION_SEMUN )
247 #if defined __APPLE__
251 # define lstat64 lstat
257 #define INVALID_ROUTINE 40
259 #define NO_UTIL_ERROR "0"
260 #define VALID_ROUTINE 0
262 #define MAX_LINE_LEN 4096
263 #define MAX_READ 0x10000
268 #define IBUF_LEN 4096
269 #define CURRENT_DIR_FIRST 0
270 #define ENVIRONMENT_ONLY 1
273 #define MAXUSECOUNT 65535
274 #define REXXMESSAGEFILE "rexx.cat"
277 #define FNAMESPEC_BUF_LEN IBUF_LEN
278 #define FOUNDFILE_BUF_LEN IBUF_LEN
279 #define FILETIME_BUF_LEN 64
280 #define FILEATTR_BUF_LEN 16
281 #define FOUNDFILELINE_BUF_LEN FOUNDFILE_BUF_LEN + FILETIME_BUF_LEN + FILEATTR_BUF_LEN
297 #define pi 3.14159265358979323846l
303 #define DEFAULT_PRECISION 9
304 #define MAX_PRECISION 16
312 #define NO_UTIL_ERROR "0"
313 #define ERROR_NOMEM "2"
314 #define ERROR_FILEOPEN "3"
320 #define ERROR_RETSTR "ERROR:"
326 #define INVALID_ROUTINE 40
327 #define VALID_ROUTINE 0
332 #define SORT_CASESENSITIVE 0
333 #define SORT_CASEIGNORE 1
336 #define SORT_ASCENDING 0
337 #define SORT_DECENDING 1
339 #define SORT_NUMERIC 3
341 #define SORT_DEF_AVG_SIZE 20
347 #define BUILDRXSTRING(t, s) { \
348 strcpy((t)->strptr,(s));\
349 (t)->strlength = strlen((s)); \
353 #define RETVAL(retc) { \
354 sprintf(retstr->strptr, "%d", retc); \
355 retstr->strlength = strlen(retstr->strptr); \
356 return VALID_ROUTINE; \
363 #define RECURSE 0x0002
364 #define DO_DIRS 0x0004
365 #define DO_FILES 0x0008
366 #define NAME_ONLY 0x0010
367 #define EDITABLE_TIME 0x0020
368 #define LONG_TIME 0x0040
369 #define CASELESS 0x0080
377 #define stty(a,b) (void)tcsetattr(a,TCSANOW,b)
378 #define gtty(a,b) (void)tcgetattr(a,b)
379 #define discard_input(a) tcflush(a,TCIFLUSH)
380 #define restore_tty(a) stty(ttyfd,a)
489 length = strlen(
string);
500 if (!isdigit(*
string))
505 accumulator = accumulator * 10 + (*
string -
'0');
509 *number = accumulator;
541 if (filedata->
data != size)
550 filedata->
data = (size_t)(endptr - filedata->
buffer);
563 for(;*
string !=
'\0';
string++){
564 *
string = toupper(*
string);
582 char * endptr = NULL;
585 if((filedata->
handle = fopen(file,
"r")) == NULL)
588 if((stat64(file,&finfo) == -1)||(!finfo.st_size)){
594 if((filedata->
buffer = (
char *)malloc(finfo.st_size)) == NULL ){
598 filedata->
size = finfo.st_size;
602 finfo.st_size, filedata->
handle);
603 if(filedata->
data != (
size_t)finfo.st_size){
611 filedata->
data = (size_t)(endptr - filedata->
buffer);
620 filedata->
size = finfo.st_size;
665 if (!(filedata->
data)) {
675 scan = (
const char *)memchr(filedata->
scan,
CH_NL, filedata->
data);
678 length = scan - filedata->
scan;
680 if (copylength > size)
685 memcpy(
line, filedata->
scan, copylength);
686 line[copylength] =
'\0';
690 line[copylength - 1] =
'\0';
693 filedata->
data -= length + 1;
694 filedata->
scan = scan + 1;
696 if (!filedata->
data) {
721 if (size > filedata->
data)
723 copylength = filedata->
data;
725 memcpy(
line, filedata->
scan, copylength);
726 line[copylength] =
'\0';
729 filedata->
data -= copylength;
731 filedata->
scan += copylength;
737 return GetLine(
line + copylength, size - copylength, filedata);
741 copylength = filedata->
data;
742 if (size < copylength)
747 memcpy(
line, filedata->
scan, copylength);
748 line[copylength] =
'\0';
783 const char *haystack,
796 for (p = 0; p < hlen; p++) {
798 if (haystack[p] ==
'\0')
801 line[p] = haystack[p];
802 else line[p] = toupper(haystack[p]);
807 for (p = 0; p < nlen; p++) {
809 if (needle[p] ==
'\0')
812 target[p] = needle[p];
813 else target[p] = toupper(needle[p]);
816 const char *hit = strstr(
line, target);
822 return haystack + (hit -
line);
848 for(i=0;(**ppenv !=
':')&&(**ppenv !=
'\0');(*ppenv)++){
851 path_buf[i++] = **ppenv;
869 const char * filename,
884 while((ep = readdir(dp))){
886 if(!strcmp(ep->d_name,filename)){
887 if(!getcwd(buf,buf_size))
889 length = strlen(buf);
890 if((length+2+strlen(filename))>buf_size)
893 buf[length+1] =
'\0';
894 strcat(buf,filename);
911 dp = opendir(path_buf);
913 while((ep = readdir(dp))){
915 if(!strcmp(ep->d_name,filename)){
916 if(strlen(path_buf)>buf_size)
918 strcpy(buf,path_buf);
919 length = strlen(buf);
920 if((length+2+strlen(filename))>buf_size)
923 buf[length+1] =
'\0';
924 strcat(buf,filename);
957 if (*
string ==
'-') {
962 length = strlen(
string);
970 if (!isdigit(*
string))
973 accumulator = accumulator * 10 + (*
string -
'0');
977 *number = accumulator * sign;
998 int ttyfd = STDIN_FILENO;
1000 struct sigaction new_action;
1005 sigfillset(&new_action.sa_mask);
1006 new_action.sa_flags = SA_RESTART;
1009 sigaction(SIGINT, &new_action, NULL);
1010 sigaction(SIGTERM, &new_action, NULL);
1011 sigaction(SIGQUIT, &new_action, NULL);
1012 sigaction(SIGHUP, &new_action, NULL);
1013 sigaction(SIGTSTP, &new_action, NULL);
1014 sigaction(SIGTTIN, &new_action, NULL);
1015 sigaction(SIGTTOU, &new_action, NULL);
1017 sigaction(SIGSEGV, &new_action, NULL);
1018 sigaction(SIGFPE, &new_action, NULL);
1019 sigaction(SIGILL, &new_action, NULL);
1020 sigaction(SIGBUS, &new_action, NULL);
1021 sigaction(SIGPIPE, &new_action, NULL);
1024 if( !isatty(ttyfd) ){
1028 ttyfd = STDIN_FILENO;
1031 ttyfd = open(
"/dev/tty", O_RDONLY);
1033 struct termios in_raw;
1040 gtty(ttyfd, &in_raw);
1042 in_raw.c_lflag &= ~ICANON;
1044 in_raw.c_lflag &= ~ECHO;
1045 in_raw.c_cc[VMIN] = 1;
1046 in_raw.c_cc[VTIME] = 0;
1047 stty(ttyfd, &in_raw);
1073 if (context->ObjectToDouble(delay, &seconds) == 0 ||
1074 isnan(seconds) || seconds == HUGE_VAL || seconds == -HUGE_VAL)
1082 if (seconds < 0.0 || seconds > 999999999)
1086 context->ArrayOfFive(context->String(
"positional"), context->String(
"delay"),
1087 context->String(
"0"), context->String(
"999999999"), delay));
1092 long secs = (long) seconds;
1093 long nanoseconds = (long) ((seconds - secs) * 1000000000);
1095 #if defined( HAVE_NANOSLEEP )
1096 struct timespec Rqtp, Rmtp;
1098 Rqtp.tv_nsec = nanoseconds;
1099 nanosleep(&Rqtp, &Rmtp);
1100 #elif defined( HAVE_NSLEEP )
1101 struct timestruc_t Rqtp, Rmtp;
1103 Rqtp.tv_nsec = nanoseconds;
1104 nsleep(&Rqtp, &Rmtp);
1157 int ignore = system(
"clear");
1178 const char *s=
"test where this string will be protected";
1197 context->InvalidRoutine();
1233 context->InvalidRoutine();
1266 unsigned short position;
1344 char * dir_buf = NULL;
1347 if (numargs < 1 || numargs > 2)
1361 if (numargs < 2 || !
string2int(args[1].strptr, &mode))
1363 mode = S_IRWXU | S_IRWXG | S_IRWXO;
1365 rc = mkdir(path, mode);
1367 sprintf(retstr->
strptr,
"%d", (
int)rc);
1375 sprintf(retstr->
strptr,
"%d", 5);
1380 sprintf(retstr->
strptr,
"%d", 87);
1385 sprintf(retstr->
strptr,
"%d", 206);
1390 sprintf(retstr->
strptr,
"%d", 206);
1395 sprintf(retstr->
strptr,
"%d", 108);
1400 sprintf(retstr->
strptr,
"%d", 2);
1426 char * dir_buf = NULL;
1441 sprintf(retstr->
strptr,
"%d", (
int)rc);
1449 sprintf(retstr->
strptr,
"%d", 5);
1453 #if defined( ENOTEMPTY ) && defined( EEXIST )
1455 sprintf(retstr->
strptr,
"%d", 87);
1459 #elif defined( ENOTEMPTY )
1461 sprintf(retstr->
strptr,
"%d", 87);
1465 #elif defined( EEXIST )
1467 sprintf(retstr->
strptr,
"%d", 87);
1473 sprintf(retstr->
strptr,
"%d", 5);
1478 sprintf(retstr->
strptr,
"%d", 87);
1483 sprintf(retstr->
strptr,
"%d", 108);
1488 sprintf(retstr->
strptr,
"%d", 2);
1512 char * dir_buf = NULL;
1527 sprintf(retstr->
strptr,
"%d", (
int)rc);
1535 sprintf(retstr->
strptr,
"%d", 5);
1540 sprintf(retstr->
strptr,
"%d", 5);
1545 sprintf(retstr->
strptr,
"%d", 87);
1550 sprintf(retstr->
strptr,
"%d", 108);
1555 sprintf(retstr->
strptr,
"%d", 2);
1591 bool linenums =
false;
1593 bool sensitive =
false;
1597 char * dir_buf = NULL;
1602 if (numargs < 3 || numargs > 4 ||
1617 if (strstr(opts,
"N") || strstr(opts,
"n"))
1620 if (strstr(opts,
"C") || strstr(opts,
"c"))
1637 line = (
char *) malloc(4096 *
sizeof(
char));
1644 ptr =
mystrstr(
line, target, len, args[0].strlength, sensitive);
1647 sprintf(ldp.
ibuf,
"%d ", (
int)num);
1648 len2 = strlen(ldp.
ibuf);
1681 sprintf(ldp.
ibuf,
"%d", (
int)ldp.
count);
1730 if (numargs < 2 || numargs > 3 ||
1738 if ((*opts ==
'N') || (*opts ==
'n'))
1742 else if ((*opts ==
'C') || (*opts ==
'c'))
1749 ulRc =
SearchPath(SearchFlag, args[0].strptr, args[1].strptr,
1750 (
char *)buf,
sizeof(buf));
1756 char *temp = strdup(args[0].strptr);
1758 ulRc =
SearchPath(SearchFlag, temp, args[1].strptr,
1759 (
char *)buf,
sizeof(buf));
1778 struct utsname info;
1783 if(uname(&info) < 0)
1786 sprintf(retstr->
strptr,
"%s %s",info.sysname,info.release);
1803 struct utsname info;
1808 if(uname(&info) < 0)
1811 sprintf(retstr->
strptr,
"%s %s.%s",info.sysname, info.version, info.release);
1848 if (semdata == NULL) {
1849 return context->String(
"");
1853 semdata->
handle = (sem_t *)malloc(
sizeof(sem_t));
1854 rc = sem_init(semdata->
handle, 0, 0);
1857 return context->String(
"");
1859 semdata->
named =
false;
1863 semdata->
handle = sem_open(name, (O_CREAT | O_EXCL), (S_IRWXU | S_IRWXG), 0);
1864 if (semdata->
handle == SEM_FAILED ) {
1866 return context->String(
"");
1868 semdata->
named =
true;
1870 return context->Uintptr((
uintptr_t)semdata);
1889 if (semdata == NULL) {
1892 semdata->
handle = sem_open(name, 0);
1893 if (semdata->
handle == SEM_FAILED ) {
1896 semdata->
named =
true;
1915 sem_init(semdata->
handle, 1, 0);
1935 rc = sem_post(semdata->
handle);
1957 if (semdata->
named ==
false) {
1959 if (sem_destroy(semdata->
handle)) {
1960 if (errno == EINVAL) {
1970 if (sem_close(semdata->
handle)) {
1971 if (errno == EINVAL) {
1984 #define SEM_WAIT_PERIOD 100
2006 while (timeout > 0) {
2007 rc = sem_trywait(semdata->
handle);
2017 rc = sem_wait(semdata->
handle);
2020 if (errno == EAGAIN) {
2023 else if (errno == EINVAL) {
2050 if (semdata == NULL) {
2051 return context->String(
"");
2053 if (strlen(name) == 0) {
2055 semdata->
handle = (sem_t *)malloc(
sizeof(sem_t));
2056 rc = sem_init(semdata->
handle, 0, 0);
2059 return context->String(
"");
2061 semdata->
named =
false;
2065 semdata->
handle = sem_open(name, (O_CREAT | O_EXCL), (S_IRWXU | S_IRWXG), 0);
2066 if (semdata->
handle == SEM_FAILED ) {
2068 return context->String(
"");
2070 semdata->
named =
true;
2072 rc = sem_post(semdata->
handle);
2073 return context->Uintptr((
uintptr_t)semdata);
2092 if (semdata == NULL) {
2095 semdata->
handle = sem_open(name, 0);
2096 if (semdata->
handle == SEM_FAILED ) {
2099 semdata->
named =
true;
2123 while (timeout > 0) {
2124 rc = sem_trywait(semdata->
handle);
2134 rc = sem_wait(semdata->
handle);
2137 if (errno == EAGAIN) {
2140 else if (errno == EINVAL) {
2164 rc = sem_getvalue(semdata->
handle, &val);
2166 if (errno == EINVAL) {
2174 rc = sem_post(semdata->
handle);
2198 if (semdata->
named ==
false) {
2200 if (sem_destroy(semdata->
handle)) {
2201 if (errno == EINVAL) {
2211 if (sem_close(semdata->
handle)) {
2212 if (errno == EINVAL) {
2245 while ( have < need )
2288 snprintf(buf,
sizeof(buf),
"%s() argument %lu must be less than %lu characters in length; length is %lu",
2289 funcName, pos, len, realLen);
2303 char buf[256] = {0};
2304 snprintf(buf,
sizeof(buf),
2305 "SysFileTree argument %lu must be a combination of F, D, B, S, T, L, I, or O; found \"%s\"",
2399 if ( *nPath != nStaticBuffer )
2405 *dPath = (
char *)malloc(*nPath *
sizeof(
char));
2407 if ( *dPath == NULL )
2427 return (S_ISREG(m) ||
2441 else if ( S_ISBLK(m) )
2445 else if ( S_ISCHR(m) )
2449 else if ( S_ISDIR(m) )
2453 else if ( S_ISFIFO(m) )
2457 else if ( S_ISSOCK(m) )
2486 struct stat *finfo,
char **d_name,
bool caseless)
2490 char *dFullPath = fullPath;
2493 struct dirent *dir_entry = readdir(dir_handle);
2494 if( dir_entry == NULL )
2501 len = snprintf(dFullPath, nFullPath,
"%s%s", path, dir_entry->d_name);
2502 if ( len >= (
int)nFullPath )
2515 lstat(dFullPath, finfo);
2525 char *pDest = dup_d_name;
2526 char *pSrc = dir_entry->d_name;
2528 for ( ; *pSrc; pDest++, pSrc++ )
2530 *pDest = toupper(*pSrc);
2534 if ( fnmatch(fileSpec, dup_d_name, FNM_NOESCAPE | FNM_PATHNAME | FNM_PERIOD ) == 0 )
2536 *d_name = dir_entry->d_name;
2547 if ( fnmatch(fileSpec, dir_entry->d_name, FNM_NOESCAPE | FNM_PATHNAME | FNM_PERIOD) == 0 )
2549 *d_name = dir_entry->d_name;
2559 dir_entry = readdir(dir_handle);
2561 while( dir_entry != NULL );
2590 struct stat *finfo,
char **d_name,
bool caseless)
2593 char *dFullPath = fullPath;
2596 struct dirent *dir_entry = readdir(dir_handle);
2597 if( dir_entry == NULL )
2604 int len = snprintf(dFullPath, nFullPath,
"%s%s", path, dir_entry->d_name);
2605 if ( len >= (
int)nFullPath )
2613 dFullPath = (
char *)malloc(nFullPath *
sizeof(
char));
2614 if ( dFullPath == NULL )
2620 sprintf(dFullPath,
"%s%s", path, dir_entry->d_name);
2623 lstat(fullPath, finfo);
2625 if ( S_ISDIR(finfo->st_mode) )
2633 char *pDest = dup_d_name;
2634 char *pSrc = dir_entry->d_name;
2636 for ( ; *pSrc; pDest++, pSrc++ )
2638 *pDest = toupper(*pSrc);
2642 if ( fnmatch(fileSpec, dup_d_name, FNM_NOESCAPE | FNM_PATHNAME | FNM_PERIOD ) == 0 )
2644 *d_name = dir_entry->d_name;
2650 if ( fnmatch(fileSpec, dir_entry->d_name, FNM_NOESCAPE | FNM_PATHNAME | FNM_PERIOD) == 0 )
2652 *d_name = dir_entry->d_name;
2657 dir_entry = readdir(dir_handle);
2659 while( dir_entry != NULL );
2682 switch( toupper(*opts) )
2749 if ( strlen(opts) == 0 )
2755 if ( !
goodOpts(context, opts, options) )
2796 size_t len = strlen(fSpec);
2802 if ( len >= bufLen - 1)
2807 strcpy(fileSpec, fSpec);
2810 if ( len == 1 && fileSpec[0] ==
'*' )
2812 strcpy(fileSpec,
"./*");
2816 if ( fileSpec[len - 1] ==
'/' )
2818 strcat(fileSpec,
"*");
2822 if ( fileSpec[0] ==
'~' )
2831 if ( strlen(temp) >= bufLen )
2838 strcpy(fileSpec, temp);
2860 int len = strlen(fileSpec);
2869 while( fileSpec[slashPos] !=
'/' && slashPos >= 0 );
2871 if ( fileSpec[slashPos] ==
'/' )
2875 if ( fileSpec[slashPos + 1] !=
'\0' )
2877 l = strlen(&fileSpec[slashPos + 1]) + 1;
2885 strcpy(treeData->
dFNameSpec, &fileSpec[slashPos + 1]);
2896 l = strlen(&fileSpec[slashPos + 1]) + 1;
2904 strcpy(treeData->
dFNameSpec, &fileSpec[slashPos + 1]);
2907 *lastSlashPos = slashPos;
2925 char *dPath = *path;
2926 size_t nPath = *pathLen;
2928 if ( fileSpec[lastSlashPos] !=
'/' )
2932 while ( getcwd(dPath, nPath) == NULL )
2941 if ( strlen(dPath) + 1 > nPath )
2957 size_t l = lastSlashPos + 1 + 1;
2961 dPath = (
char *)malloc(nPath *
sizeof(
char));
2963 if ( dPath == NULL )
2969 strncpy(dPath, fileSpec, lastSlashPos + 1);
2971 *(dPath + lastSlashPos + 1) =
'\0';
2980 if ( chdir(dPath) == 0 )
2982 while ( getcwd(dPath, nPath) == NULL )
2988 int ignore = chdir(savedPath);
2993 if ( strlen(dPath) + 1 > nPath )
3003 if ( lastSlashPos > 0 )
3009 int ignore = chdir(savedPath);
3014 if ( nPath != *pathLen )
3062 if ( strcmp(fileSpec,
".") == 0 )
3064 strcpy(fileSpec,
"./*");
3066 else if ( strcmp(fileSpec,
"..") == 0 )
3068 strcpy(fileSpec,
"../*");
3078 if ( !
getPathSegment(c, fileSpec, path, pathLen, lastSlashPos) )
3129 struct tm *timestamp;
3146 struct tm stTimestamp;
3147 timestamp = localtime_r(&(finfo->st_mtime), &stTimestamp);
3149 timestamp = localtime(&(finfo->st_mtime));
3154 sprintf(treeData->
fileTime,
"%4d-%02d-%02d %02d:%02d:%02d %10lu ",
3155 timestamp->tm_year + 1900,
3156 timestamp->tm_mon + 1,
3167 sprintf(treeData->
fileTime,
"%02d/%02d/%02d/%02d/%02d %10lu ",
3168 (timestamp->tm_year) % 100,
3169 timestamp->tm_mon + 1,
3177 sprintf(treeData->
fileTime,
"%2d/%02d/%02d %2d:%02d%c %10lu ",
3178 timestamp->tm_mon+1,
3180 timestamp->tm_year % 100,
3181 timestamp->tm_hour < 13 ? timestamp->tm_hour : timestamp->tm_hour - 12,
3183 (timestamp->tm_hour < 12 || timestamp->tm_hour == 24) ?
'a' :
'p',
3189 sprintf(treeData->
fileAttr,
"%c%c%c%c%c%c%c%c%c%c ",
3191 (finfo->st_mode & S_IREAD) ?
'r' :
'-',
3192 (finfo->st_mode & S_IWRITE) ?
'w' :
'-',
3193 (finfo->st_mode & S_IEXEC) ?
'x' :
'-',
3194 (finfo->st_mode & S_IRGRP) ?
'r' :
'-',
3195 (finfo->st_mode & S_IWGRP) ?
'w' :
'-',
3196 (finfo->st_mode & S_IXGRP) ?
'x' :
'-',
3197 (finfo->st_mode & S_IROTH) ?
'r' :
'-',
3198 (finfo->st_mode & S_IWOTH) ?
'w' :
'-',
3199 (finfo->st_mode & S_IXOTH) ?
'x' :
'-');
3222 c->SetStemArrayElement(treeData->
files, treeData->
count, t);
3223 c->ReleaseLocalReference(t);
3291 bool caseless = options &
CASELESS;
3295 dir_handle = opendir(path);
3296 if ( dir_handle == NULL )
3314 closedir(dir_handle);
3319 sprintf(treeData->
dFoundFile,
"%s%s", path, fileName);
3322 if ( !
formatFile(c, treeData, options, &finfo) )
3324 closedir(dir_handle);
3332 closedir(dir_handle);
3333 dir_handle = opendir(path);
3335 if ( dir_handle == NULL )
3346 if ( strcmp(fileName,
".") == 0 || strcmp(fileName,
"..") == 0 )
3357 closedir(dir_handle);
3362 sprintf(treeData->
dFoundFile,
"%s%s", path, fileName);
3365 if ( !
formatFile(c, treeData, options, &finfo) )
3367 closedir(dir_handle);
3376 closedir(dir_handle);
3377 dir_handle = opendir(path);
3378 if ( dir_handle == NULL )
3388 char *dTmpDirName = tmpDirName;
3392 if (
linFindNextDir(c,
"*", path, dir_handle, &finfo, &fileName, 0) )
3397 if ( strcmp(fileName,
".") == 0 || strcmp(fileName,
"..") == 0 )
3403 len = snprintf(dTmpDirName, nTmpDirName,
"%s%s/", path, fileName);
3404 if ( len >= (
int)nTmpDirName )
3408 closedir(dir_handle);
3413 sprintf(dTmpDirName,
"%s%s/", path, fileName);
3418 closedir(dir_handle);
3426 while (
linFindNextDir(c,
"*", path, dir_handle, &finfo, &fileName, 0) );
3435 closedir(dir_handle);
3447 treeData->
files = files;
3518 OPTIONAL_CSTRING, targetAttr, OPTIONAL_CSTRING,
newAttr)
3541 if ( !
getPath(context, fileSpec, &dPath, &nPath, &treeData) )
3562 context->SetStemArrayElement(treeData.
files, 0, context->WholeNumber(treeData.
count));
3612 args[0].strlength > 512)
3617 if (args[1].strlength != 1)
3619 filler = args[1].
strptr[0];
3624 dir = (
char*) malloc(args[0].strlength+1);
3630 strcpy(dir, args[0].strptr);
3636 for (x = 0; tmp[x] != 0; x++)
3638 if (tmp[x] == filler)
3654 sprintf(numstr,
"%01u", (
int)num);
3657 sprintf(numstr,
"%02u", (
int)num);
3660 sprintf(numstr,
"%03u", (
int)num);
3663 sprintf(numstr,
"%04u", (
int)num);
3666 sprintf(numstr,
"%05u", (
int)num);
3672 for (x = 0; tmp[x] !=0; x++)
3674 if (tmp[x] == filler)
3676 tmp[x] = numstr[i++];
3686 while((*tmp !=
'/') && (*tmp !=
'\\') && (tmp > dir))
3695 array = tempnam(NULL,file);
3697 else if(*dir ==
'/'){
3699 array = tempnam(
"/",file);
3703 array = tempnam(NULL,file);
3710 array = tempnam(dir,file);
3713 if(strlen(array) > 255)
3715 free((
char *)retstr->
strptr);
3716 retstr->
strptr = (
char *) malloc(strlen(array) + 1);
3719 strcpy(retstr->
strptr, array);
3766 else if (((
size_t)pclass > 0) && ((
size_t)pclass <= 4)){
3772 priority = getpriority(PRIO_PROCESS, getpid());
3775 setpriority(PRIO_PROCESS, getpid(),-level);
3784 sprintf(retstr->
strptr,
"%d", rc);
3814 #if defined( HAVE_CATOPEN )
3818 const char default_message[] = {
"Error: Message catalog not open !\0"};
3820 const char not_found_message[] = {
"Error: Message not found !\0"};
3822 const char error_insertions[] = {
"Error: Unable to generate message \
3823 (wrong insertions)\0"};
3825 const char cat_not_found_message[] = {
"Error: Message catalog not found !\0"};
3830 const char * msgfile;
3835 if (numargs < 1 || numargs > 11 ||
3840 if (!
string2int(args[0].strptr, &msgnum) || msgnum < 0)
3847 msgfile = args[1].
strptr;
3851 #if defined( HAVE_SETLOCALE )
3852 setlocale(LC_ALL,
"en_US");
3855 #if defined( HAVE_CATOPEN )
3857 if((catalog = catopen(msgfile, NL_CAT_LOCALE)) == (nl_catd)-1){
3858 retstr->
strptr = (
char *)malloc(strlen(cat_not_found_message)+1);
3859 strcpy(retstr->
strptr, cat_not_found_message);
3860 retstr->
strlength = strlen(cat_not_found_message);
3865 msg = catgets(catalog, setnum, (
int)msgnum, default_message);
3868 msg = not_found_message;
3877 for(
int j=2; j < icount+2; j++)
3878 msg_length += args[j].strlength;
3879 msg_length += strlen(msg);
3880 msg_length -= icount*2;
3883 if(!(retstr->
strptr = (
char *)malloc(msg_length+100))){
3890 temp =
const_cast<char *
>(msg);
3892 while((temp = strstr(temp,
"&"))){
3893 if(isdigit(*(temp+1))){
3902 temp =
const_cast<char *
>(msg);
3903 while((temp = strstr(temp,
"%s"))){
3913 if(sprintf(retstr->
strptr, msg,args[2].
strptr) != msg_length)
3914 strcpy(retstr->
strptr, error_insertions);
3919 args[3].
strptr) != msg_length)
3920 strcpy(retstr->
strptr, error_insertions);
3926 args[4].
strptr) != msg_length)
3927 strcpy(retstr->
strptr, error_insertions);
3934 args[5].
strptr) != msg_length)
3935 strcpy(retstr->
strptr, error_insertions);
3943 args[6].
strptr) != msg_length)
3944 strcpy(retstr->
strptr, error_insertions);
3953 args[7].
strptr) != msg_length)
3954 strcpy(retstr->
strptr, error_insertions);
3964 args[8].
strptr) != msg_length)
3965 strcpy(retstr->
strptr, error_insertions);
3976 args[9].
strptr) != msg_length)
3977 strcpy(retstr->
strptr, error_insertions);
3989 args[10].
strptr) != msg_length)
3990 strcpy(retstr->
strptr, error_insertions);
3994 strcpy(retstr->
strptr, error_insertions);
3998 strcpy(retstr->
strptr, msg);
4008 const char cat_not_supported_message[] = {
"Error: Message catalog (catopen) not supported !\0"};
4010 retstr->
strptr = (
char *)malloc(strlen(cat_not_supported_message)+1);
4011 strcpy(retstr->
strptr, cat_not_supported_message);
4012 retstr->
strlength = strlen(cat_not_supported_message);
4041 #if defined( HAVE_CATOPEN )
4045 const char default_message[] = {
"Error: Message catalog not open !\0"};
4047 const char not_found_message[] = {
"Error: Message not found !\0"};
4049 const char error_insertions[] = {
"Error: Unable to generate message \
4050 (wrong insertions)\0"};
4052 const char cat_not_found_message[] = {
"Error: Message catalog not found !\0"};
4057 const char * msgfile;
4062 if (numargs < 1 || numargs > 12 ||
4068 if (!
string2int(args[0].strptr, &setnum) || setnum < 0)
4072 if (!
string2int(args[1].strptr, &msgnum) || msgnum < 0)
4079 msgfile = args[2].
strptr;
4083 #if defined( HAVE_CATOPEN )
4085 if((catalog = catopen(msgfile, NL_CAT_LOCALE)) == (nl_catd)-1){
4086 retstr->
strptr = (
char *)malloc(strlen(cat_not_found_message)+1);
4087 strcpy(retstr->
strptr, cat_not_found_message);
4088 retstr->
strlength = strlen(cat_not_found_message);
4093 msg = catgets(catalog, setnum, msgnum, default_message);
4096 msg =
const_cast<char *
>(not_found_message);
4105 for(
int j=3; j < icount+3; j++)
4106 msg_length += args[j].strlength;
4107 msg_length += strlen(msg);
4108 msg_length -= icount*2;
4111 if(!(retstr->
strptr = (
char *)malloc(msg_length+100))){
4120 while((temp = strstr(temp,
"&"))){
4121 if(isdigit(*(temp+1))){
4130 while((temp = strstr(temp,
"%s"))){
4141 if(sprintf(retstr->
strptr, msg,args[3].
strptr) != msg_length)
4142 strcpy(retstr->
strptr, error_insertions);
4147 args[4].
strptr) != msg_length)
4148 strcpy(retstr->
strptr, error_insertions);
4154 args[5].
strptr) != msg_length)
4155 strcpy(retstr->
strptr, error_insertions);
4162 args[6].
strptr) != msg_length)
4163 strcpy(retstr->
strptr, error_insertions);
4171 args[7].
strptr) != msg_length)
4172 strcpy(retstr->
strptr, error_insertions);
4181 args[8].
strptr) != msg_length)
4182 strcpy(retstr->
strptr, error_insertions);
4192 args[9].
strptr) != msg_length)
4193 strcpy(retstr->
strptr, error_insertions);
4204 args[10].
strptr) != msg_length)
4205 strcpy(retstr->
strptr, error_insertions);
4217 args[11].
strptr) != msg_length)
4218 strcpy(retstr->
strptr, error_insertions);
4222 strcpy(retstr->
strptr, error_insertions);
4226 strcpy(retstr->
strptr, msg);
4236 const char cat_not_supported_message[] = {
"Error: Message catalog (catopen) not supported !\0"};
4238 retstr->
strptr = (
char *)malloc(strlen(cat_not_supported_message)+1);
4239 strcpy(retstr->
strptr, cat_not_supported_message);
4240 retstr->
strlength = strlen(cat_not_supported_message);
4267 if (!strcasecmp(args[0].strptr,
"NOECHO"))
4269 else if (strcasecmp(args[0].strptr,
"ECHO"))
4301 RXFUNCBLOCK *funcblock;
4302 PRXINITFUNCPKG InitFunc;
4309 argstring = args[0].
strptr;
4311 if ( (arglength == 0 ) ||
4313 (!strchr( argstring,
'/' )) )
4316 if (!(InitFunc = (PRXINITFUNCPKG)load(argstring,0,NULL)))
4318 if ( InitFunc == NULL ) {
4319 fprintf(stderr,
" *** Unable to load library %s !\nError message: errno = %d;",\
4321 perror(
" REXXUTIL");
4328 rc = (*InitFunc)(&funcblock);
4331 fprintf(stderr,
"*** Library load routine gave error %d.\n",rc);
4341 for (j=0; funcblock[j].name != NULL; j++) {
4343 fprintf(stderr,
"REXXUTIL: PKGFunction %s \n", funcblock[j].name);
4345 if ( funcblock[j].
function && (rc == NULL) ) {
4347 argstring, funcblock[j].name);
4360 return SysAddFuncPkg(
4388 RXFUNCBLOCK *funcblock;
4389 PRXINITFUNCPKG InitFunc;
4396 argstring = args[0].
strptr;
4398 if ( (arglength == 0 ) ||
4402 if (!(InitFunc = (PRXINITFUNCPKG)load(argstring,0,NULL)))
4404 if ( InitFunc == NULL ) {
4405 fprintf(stderr,
" *** Unable to drop library %s !\nError message: errno = %d;",\
4407 perror(
" REXXUTIL");
4414 rc = (*InitFunc)(&funcblock);
4417 fprintf(stderr,
" *** Library drop routine gave error %d.\n",rc);
4427 for (j=0; funcblock[j].name != NULL; j++) {
4429 fprintf(stderr,
"REXXUTIL: PKGFunction %s \n", funcblock[j].name);
4431 if ( funcblock[j].
function && (rc == NULL) ) {
4445 return SysDropFuncPkg(
4472 sprintf(retstr->
strptr,
"%d", fork());
4498 sprintf(retstr->
strptr,
"%d", iStatus);
4527 else if (args[0].strptr[0] ==
'b' || args[0].strptr[0] ==
'B')
4530 else if (args[0].strptr[0] ==
'n' || args[0].strptr[0] ==
'N')
4535 perror(
"*** ERROR: Creating pipe");
4541 iStatus = fcntl(iaH[0], F_GETFL, NULL);
4542 iStatus |= O_NONBLOCK;
4544 if (fcntl(iaH[0], F_SETFL, iStatus) == -1) {
4545 perror(
"*** ERROR: Setting NONBLOCK flag");
4546 close(iaH[0]); close(iaH[1]);
4550 sprintf(retstr->
strptr,
"%d %d", iaH[0], iaH[1]);
4573 bool fCloseFile =
false;
4575 if ( (numargs > 1) ||
4584 handle = open(args[0].strptr, O_WRONLY | O_APPEND | O_CREAT, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP | S_IWOTH | S_IROTH);
4589 handle = STDOUT_FILENO;
4610 ignore = write(handle,
"Name=", strlen(
"Name="));
4611 ignore = write(handle, shvb.
shvname.strptr, shvb.
shvname.strlength);
4612 ignore = write(handle,
", Value='", 9);
4614 ignore = write(handle,
"'\n", 2);
4650 const char *dir_buf = NULL;
4652 bool alloc_Flag =
false;
4654 if ( (numargs < 1) || (numargs > 2) ||
4658 if(*(args[0].strptr) ==
'~')
4665 dir_buf = args[0].
strptr;
4668 if (stat64(dir_buf, &buf) < 0)
4677 switch (args[1].strptr[0])
4681 newtime = localtime(&(buf.st_atime));
4685 newtime = localtime(&(buf.st_mtime));
4693 newtime = localtime(&(buf.st_mtime));
4695 newtime->tm_year += 1900;
4696 newtime->tm_mon += 1;
4698 sprintf(retstr->
strptr,
"%4d-%02d-%02d %02d:%02d:%02d",
4707 if( (dir_buf) && (alloc_Flag ==
true) )
4708 free((
void *)dir_buf);
4731 struct utimbuf timebuf;
4735 const char *dir_buf = NULL;
4736 bool alloc_Flag =
false;
4742 if ( (numargs < 1) || (numargs > 3) ||
4747 if(*(args[0].strptr) ==
'~')
4754 dir_buf = args[0].
strptr;
4757 if (stat64(dir_buf, &buf) < 0)
4765 timebuf.modtime = ltime;
4766 if (utime(dir_buf, &timebuf) < 0)
4773 newtime = localtime(&(buf.st_mtime));
4778 if (sscanf(args[1].strptr,
"%4d-%2d-%2d", &newtime->tm_year,
4779 &newtime->tm_mon, &newtime->tm_mday) != 3)
4781 newtime->tm_year -= 1900;
4782 newtime->tm_mon -= 1;
4787 if (sscanf(args[2].strptr,
"%2d:%2d:%2d", &newtime->tm_hour,
4788 &newtime->tm_min, &newtime->tm_sec) != 3)
4791 ltime = mktime(newtime);
4792 timebuf.modtime = ltime;
4793 if (utime(dir_buf, &timebuf) < 0)
4799 if( (dir_buf) && (alloc_Flag ==
true) )
4800 free((
void *)dir_buf);
4809 size_t start,
size_t end,
size_t firstcol,
size_t lastcol);
4834 size_t firstCol = 0;
4839 if ( (numargs < 1) || (numargs > 7) ||
4844 memset(stemName, 0,
sizeof(stemName));
4845 strcpy(stemName, args[0].strptr);
4846 if (stemName[args[0].strlength-1] !=
'.')
4852 switch (args[1].strptr[0])
4869 switch (args[2].strptr[0])
4912 if (lastCol < firstCol)
4918 if (!
RexxStemSort(stemName, sortOrder, sortType, first, last, firstCol, lastCol)) {
4919 sprintf(retstr->
strptr,
"-1");
4924 sprintf(retstr->
strptr,
"0");
4953 RexxObjectPtr temp = context->GetStemArrayElement(toStem, 0);
4954 if (temp ==
NULLOBJECT || !context->StringSize(temp, &items))
4956 context->InvalidRoutine();
4961 if (start + count - 1 > items)
4963 context->InvalidRoutine();
4969 for ( index = start; index + count <= items; index++)
4972 RexxObjectPtr value = context->GetStemArrayElement(toStem, index + count);
4979 context->SetStemArrayElement(toStem, index, value);
4983 for (index = items - count + 1; index <= items; index++)
4985 context->DropStemArrayElement(toStem, index);
4988 context->SetStemArrayElement(toStem, 0, context->StringSize(items - count));
5010 RexxObjectPtr temp = context->GetStemArrayElement(toStem, 0);
5011 if (temp ==
NULLOBJECT || !context->StringSize(temp, &count))
5013 context->InvalidRoutine();
5018 if (position == 0 || (position > count + 1))
5020 context->InvalidRoutine();
5024 for (
size_t index = count; index >= position; index--)
5027 RexxObjectPtr value = context->GetStemArrayElement(toStem, index);
5034 context->SetStemArrayElement(toStem, index + 1, value);
5038 context->SetStemArrayElement(toStem, position, newValue);
5039 context->SetStemArrayElement(toStem, 0, context->WholeNumber(count + 1));
5062 OPTIONAL_stringsize_t, from, OPTIONAL_stringsize_t, to, OPTIONAL_stringsize_t, count,
5063 OPTIONAL_CSTRING, option)
5065 bool inserting =
false;
5082 context->InvalidRoutine();
5090 RexxObjectPtr temp = context->GetStemArrayElement(fromStem, 0);
5091 if (temp ==
NULLOBJECT || !context->StringSize(temp, &fromCount))
5093 context->InvalidRoutine();
5112 if ((count > (fromCount - from + 1)) || (fromCount == 0))
5114 context->InvalidRoutine();
5121 count = fromCount - from + 1;
5126 temp = context->GetStemArrayElement(toStem, 0);
5127 if (temp !=
NULLOBJECT && !context->StringSize(temp, &toCount))
5129 context->InvalidRoutine();
5134 if (to > toCount + 1)
5136 context->InvalidRoutine();
5143 for (
size_t index = toCount; index >= to; index--)
5146 RexxObjectPtr value = context->GetStemArrayElement(toStem, index);
5153 context->SetStemArrayElement(toStem, index + count, value);
5159 context->SetStemArrayElement(toStem, 0, context->StringSize(toCount));
5162 for (
size_t index = 0; index < count; index++)
5165 RexxObjectPtr value = context->GetStemArrayElement(fromStem, from + index);
5172 context->SetStemArrayElement(toStem, to + index, value);
5176 if (to + count - 1 > toCount)
5178 context->SetStemArrayElement(toStem, 0, context->StringSize(to + count - 1));
5203 unsigned int uiUsedCPUTime = 0;
5204 unsigned int uiUsedCPUmsec = 0;
5205 unsigned int uiUsedHours = 0;
5206 unsigned int uiUsedMinutes = 0;
5207 unsigned int uiUsedSeconds = 0;
5210 struct rusage struResUse;
5216 if ((numargs == 0) || (!strcasecmp(args[0].strptr,
"PID")))
5218 sprintf(retstr->
strptr,
"%d", getpid());
5223 if (!strcasecmp(args[0].strptr,
"PPID"))
5225 sprintf(retstr->
strptr,
"%d", getppid());
5230 if (!strcasecmp(args[0].strptr,
"PGID"))
5232 sprintf(retstr->
strptr,
"%d", getpgid(getpid()));
5237 if (!strcasecmp(args[0].strptr,
"PPRIO"))
5239 sprintf(retstr->
strptr,
"%d", getpriority(PRIO_PROCESS, 0));
5247 iRc = getrusage ( RUSAGE_SELF, &struResUse);
5250 sprintf(retstr->
strptr,
" System error; errno = %d", errno);
5254 if (!strcasecmp(args[0].strptr,
"PTIME"))
5256 uiUsedCPUmsec = (
unsigned int) struResUse.ru_utime.tv_usec/1000;
5257 uiUsedCPUmsec += (
unsigned int) struResUse.ru_stime.tv_usec/1000;
5258 if (uiUsedCPUmsec >= 1000 )
5260 uiUsedCPUTime = uiUsedCPUmsec / 1000;
5261 uiUsedCPUmsec = uiUsedCPUmsec % 1000;
5263 uiUsedCPUTime += (
unsigned int) struResUse.ru_utime.tv_sec;
5264 uiUsedCPUTime += (
unsigned int) struResUse.ru_stime.tv_sec;
5265 uiUsedHours = uiUsedCPUTime / 3600;
5266 uiUsedMinutes = uiUsedCPUTime / 60;
5267 if (uiUsedMinutes >= 60 ) uiUsedMinutes = uiUsedMinutes % 60;
5268 if (uiUsedCPUTime >= 60 ) uiUsedSeconds = uiUsedCPUTime % 60;
5269 else uiUsedSeconds = uiUsedCPUTime;
5271 sprintf(retstr->
strptr,
"CPU_Time Summary: %2d:%.2d:%.2d:%.3d Kernel:",
5272 uiUsedHours, uiUsedMinutes, uiUsedSeconds, uiUsedCPUmsec );
5274 uiUsedCPUmsec = (
unsigned int) struResUse.ru_stime.tv_usec/1000;
5275 uiUsedCPUTime = (
unsigned int) struResUse.ru_stime.tv_sec;
5276 uiUsedHours = uiUsedCPUTime / 3600;
5277 uiUsedMinutes = uiUsedCPUTime / 60;
5278 if (uiUsedMinutes >= 60 ) uiUsedMinutes = uiUsedMinutes % 60;
5279 if (uiUsedCPUTime >= 60 ) uiUsedSeconds = uiUsedCPUTime % 60;
5280 else uiUsedSeconds = uiUsedCPUTime;
5282 sprintf(timebuf,
" %2d:%.2d:%.2d:%.3d User:", uiUsedHours,
5283 uiUsedMinutes, uiUsedSeconds, uiUsedCPUmsec );
5284 strcat(retstr->
strptr, timebuf);
5286 uiUsedCPUmsec = (
unsigned int) struResUse.ru_utime.tv_usec/1000;
5287 uiUsedCPUTime = (
unsigned int) struResUse.ru_utime.tv_sec;
5288 uiUsedHours = uiUsedCPUTime / 3600;
5289 uiUsedMinutes = uiUsedCPUTime / 60;
5290 if (uiUsedMinutes >= 60 ) uiUsedMinutes = uiUsedMinutes % 60;
5291 if (uiUsedCPUTime >= 60 ) uiUsedSeconds = uiUsedCPUTime % 60;
5292 else uiUsedSeconds = uiUsedCPUTime;
5294 sprintf(timebuf,
" %2d:%.2d:%.2d:%.3d", uiUsedHours,
5295 uiUsedMinutes, uiUsedSeconds, uiUsedCPUmsec );
5296 strcat(retstr->
strptr, timebuf);
5302 if (!strcasecmp(args[0].strptr,
"PMEM"))
5304 sprintf(retstr->
strptr,
"Max_Memory_RSS: %ld", struResUse.ru_maxrss);
5309 if (!strcasecmp(args[0].strptr,
"PSWAPS"))
5311 sprintf(retstr->
strptr,
"Memory_swaps: %ld", struResUse.ru_nswap);
5316 if (!strcasecmp(args[0].strptr,
"PRCVDSIG"))
5318 sprintf(retstr->
strptr,
"Received_signals: %ld", struResUse.ru_nsignals);
5340 char *errmsg = NULL;
5347 errnum = atoi(args[0].strptr);
5348 errmsg = strerror( errnum );
5349 if (errmsg == NULL )
5350 retstr->
strptr[0] =
'\0';
5353 if (strlen(errmsg) >= retstr->
strlength)
5354 retstr->
strptr = (
char *) malloc(strlen(errmsg + 1));
5355 strcpy(retstr->
strptr,errmsg);
5376 sprintf(retstr->
strptr,
"%d.%d.%d", ORX_VER, ORX_REL, ORX_MOD);
5403 int close(
bool returnError=
true);
5411 int closeStatus = 0;
5436 operator char *()
const {
return value; }
5448 char actualpath1[PATH_MAX+1];
5449 char actualpath2[PATH_MAX+1];
5450 if (realpath(path1, actualpath1) == NULL)
return false;
5451 if (realpath(path2, actualpath2) == NULL)
return false;
5452 return strcmp(actualpath1, actualpath2) == 0;
5464 AutoFree filenameCopy = strdup(filename);
5465 if (filenameCopy != NULL)
5467 AutoFree directory = strdup(dirname(filenameCopy));
5468 if (directory != NULL)
5470 char *newFilename = tempnam(directory, NULL);
5471 if (newFilename != NULL)
return newFilename;
5487 if (timestampsPreserved != NULL) *timestampsPreserved =
false;
5488 if (modePreserved != NULL) *modePreserved =
false;
5490 if (
SamePaths(fromFile, toFile))
return EEXIST;
5492 struct stat64 fromStat;
5493 if (stat64(fromFile, &fromStat) == -1)
return errno;
5494 AutoClose fromHandle = open64(fromFile, O_RDONLY);
5495 if (fromHandle == -1)
return errno;
5497 struct stat64 toStat;
5498 bool toFileCreated = (stat64(toFile, &toStat) == -1);
5499 AutoClose toHandle = open64(toFile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
5500 if (toHandle == -1)
return errno;
5505 int count = read(fromHandle, &buffer,
IBUF_LEN);
5506 if (count == -1)
return errno;
5507 if (count == 0)
break;
5508 if (write(toHandle, buffer, count) == -1)
return errno;
5511 if (fromHandle.
close() == -1)
return errno;
5512 if (toHandle.
close() == -1)
return errno;
5514 if (preserveTimestamps)
5516 struct utimbuf timebuf;
5517 timebuf.actime = fromStat.st_atime;
5518 timebuf.modtime = fromStat.st_mtime;
5519 if (utime(toFile, &timebuf) == 0)
5521 if (timestampsPreserved != NULL) *timestampsPreserved =
true;
5525 if (toFileCreated || preserveMode)
5527 if (chmod(toFile, fromStat.st_mode) == 0)
5529 if (modePreserved != NULL) *modePreserved =
true;
5543 if (timestampsPreserved != NULL) *timestampsPreserved =
false;
5544 if (modePreserved != NULL) *modePreserved =
false;
5546 if (
SamePaths(fromFile, toFile))
return EEXIST;
5548 struct stat64 fromStat;
5549 if (lstat64(fromFile, &fromStat) == -1)
return errno;
5550 bool fromFileIsSymbolicLink = S_ISLNK(fromStat.st_mode);
5552 struct stat64 toStat;
5553 bool toFileExists = (lstat64(toFile, &toStat) == 0);
5554 bool toFileIsSymbolicLink = (toFileExists && S_ISLNK(toStat.st_mode));
5557 if (toFileExists && (fromFileIsSymbolicLink || toFileIsSymbolicLink))
5562 if (force ==
false)
return EEXIST;
5565 if (errInfo != 0)
return errInfo;
5568 if (fromFileIsSymbolicLink)
5570 off_t pathSize = fromStat.st_size;
5571 AutoFree pathBuffer = (
char *)malloc(pathSize+1);
5572 if (pathBuffer == NULL)
return errno;
5573 if (readlink(fromFile, pathBuffer, pathSize) == -1)
return errno;
5574 pathBuffer[pathSize] =
'\0';
5575 if (toFileNewname != NULL && rename(toFile, toFileNewname) == -1)
return errno;
5576 if (symlink(pathBuffer, toFile) == -1)
5578 int errInfo = errno;
5580 if (toFileNewname != NULL) rename(toFileNewname, toFile);
5587 if (toFileNewname != NULL && rename(toFile, toFileNewname) == -1)
return errno;
5592 if (toFileNewname != NULL) rename(toFileNewname, toFile);
5597 if (toFileNewname != NULL) unlink(toFileNewname);
5623 if (
SamePaths(fromFile, toFile))
return EEXIST;
5624 if (rename(fromFile, toFile) == 0)
return 0;
5625 if (errno != EXDEV)
return errno;
5631 if (errInfo != 0)
return errInfo;
5632 if (rename(fromFile, fromFileNewname) == -1)
return errno;
5634 if (rename(fromFileNewname, fromFile) == -1)
return errno;
5639 if (copyStatus != 0)
return copyStatus;
5644 return unlink(fromFile);
5664 struct stat64 finfo;
5666 int rc = stat64(filename, &finfo);
5668 return rc == 0 && (S_ISREG(finfo.st_mode) || S_ISBLK(finfo.st_mode));
5683 struct stat64 finfo;
5685 int rc = stat64(filename, &finfo);
5686 return rc == 0 && S_ISDIR(finfo.st_mode);
5701 struct stat64 finfo;
5703 int rc = lstat64(filename, &finfo);
5704 return rc == 0 && S_ISLNK(finfo.st_mode);
5719 struct stat64 finfo;
5721 return stat64(filename, &finfo) == 0;
5725 #ifdef XX__cplusplus
RexxReturnCode RexxEntry RexxVariablePool(PSHVBLOCK pshvblock)
int close(bool returnError=true)
AutoClose & operator=(int fd)
AutoFree & operator=(char *p)
#define argumentExists(i)
#define REXX_INTERPRETER_4_0_0
#define REXX_CLASSIC_ROUTINE(n, e)
#define argumentOmitted(i)
#define REXX_LAST_ROUTINE()
#define REXX_TYPED_ROUTINE(n, e)
#define STANDARD_PACKAGE_HEADER
#define Rexx_Error_Invalid_argument_range
#define Rexx_Error_Incorrect_call_user_defined
#define Rexx_Error_Invalid_argument_number
#define Rexx_Error_System_service_user_defined
#define Rexx_Error_Incorrect_call_null
RexxReturnCode REXXENTRY RexxDeregisterFunction(CONSTANT_STRING)
RexxReturnCode REXXENTRY RexxLoadMacroSpace(size_t, CONSTANT_STRING *, CONSTANT_STRING)
RexxReturnCode REXXENTRY RexxAddMacro(CONSTANT_STRING, CONSTANT_STRING, size_t)
RexxReturnCode REXXENTRY RexxFreeMemory(void *)
struct _RexxStringObject * RexxStringObject
RexxReturnCode REXXENTRY RexxSaveMacroSpace(size_t, CONSTANT_STRING *, CONSTANT_STRING)
RexxReturnCode REXXENTRY RexxRegisterFunctionDll(CONSTANT_STRING, CONSTANT_STRING, CONSTANT_STRING)
RexxReturnCode REXXENTRY RexxQueryMacro(CONSTANT_STRING, unsigned short *)
struct _RexxObjectPtr * RexxObjectPtr
RexxReturnCode REXXENTRY RexxReorderMacro(CONSTANT_STRING, size_t)
RexxReturnCode REXXENTRY RexxClearMacroSpace(void)
RexxReturnCode REXXENTRY RexxDropMacro(CONSTANT_STRING)
struct _RexxStemObject * RexxStemObject
#define RXMACRO_SEARCH_BEFORE
#define RXMACRO_SEARCH_AFTER
CONSTANT_RXSTRING shvname
struct _SHVBLOCK * shvnext
RexxThreadContext * threadContext
char fileTime[FILETIME_BUF_LEN]
char fNameSpec[FNAMESPEC_BUF_LEN]
char foundFile[FOUNDFILE_BUF_LEN]
char foundFileLine[FOUNDFILELINE_BUF_LEN]
char fileAttr[FILEATTR_BUF_LEN]
size_t RexxEntry SysSearchPath(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
const char * mystrstr(const char *haystack, const char *needle, size_t hlen, size_t nlen, bool sensitive)
size_t RexxEntry SysVersion(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
int OpenFile(const char *file, GetFileData *filedata)
int CopyFile_DereferenceSymbolicLinks(CSTRING fromFile, CSTRING toFile, bool preserveTimestamps, bool preserveMode, bool *timestampsPreserved=NULL, bool *modePreserved=NULL)
bool string2size_t(const char *string, size_t *number)
#define BUILDRXSTRING(t, s)
RexxPackageEntry rexxutil_package_entry
OOREXX_GET_PACKAGE(rexxutil)
size_t RexxEntry SysCreatePipe(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
static void stringTooLongException(RexxThreadContext *c, CSTRING funcName, size_t pos, size_t len, size_t realLen)
RexxRoutine6(int, SysStemCopy, RexxStemObject, fromStem, RexxStemObject, toStem, OPTIONAL_stringsize_t, from, OPTIONAL_stringsize_t, to, OPTIONAL_stringsize_t, count, OPTIONAL_CSTRING, option)
size_t RexxEntry SysSetPriority(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
size_t RexxEntry SysWait(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
void uninitTreeData(RXTREEDATA *treeData)
size_t RexxEntry SysGetMessage(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
struct _GetFileData GetFileData
static bool getFileNameSegment(RexxCallContext *c, char *fileSpec, RXTREEDATA *treeData, int *lastSlashPos)
bool string2int(const char *string, int *number)
struct RxSemData RXSEMDATA
#define FNAMESPEC_BUF_LEN
RexxRoutineEntry rexxutil_routines[]
char typeOfEntry(mode_t m)
size_t RexxEntry SysDumpVariables(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
bool linFindNextFile(RexxCallContext *c, const char *fileSpec, const char *path, DIR *dir_handle, struct stat *finfo, char **d_name, bool caseless)
int get_next_path(char **ppenv, char *path_buf)
struct RxTreeData RXTREEDATA
int MoveFile(CSTRING fromFile, CSTRING toFile)
static void badSFTOptsException(RexxThreadContext *c, size_t pos, CSTRING actual)
size_t RexxEntry SysGetFileDateTime(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
static bool recursiveFindFile(RexxCallContext *c, const char *path, RXTREEDATA *treeData, uint32_t options)
void strupr(char *string)
int getkey(char *ret, bool echo)
size_t RexxEntry SysStemSort(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
size_t RexxEntry SysLoadFuncs(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
size_t neededSize(size_t need, size_t have)
size_t RexxEntry SysCls(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
bool linFindNextDir(RexxCallContext *c, const char *fileSpec, const char *path, DIR *dir_handle, struct stat *finfo, char **d_name, bool caseless)
#define FOUNDFILE_BUF_LEN
void CloseFile(GetFileData *filedata)
size_t RexxEntry SysGetErrortext(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
struct _SORT_MEM * PSORTMEM
struct RxStemData RXSTEMDATA
RexxRoutine0(int, SysClearRexxMacroSpace)
size_t RexxEntry SysDropFuncs(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
#define FOUNDFILELINE_BUF_LEN
static bool goodOpts(RexxCallContext *c, CSTRING opts, uint32_t *pOpts)
#define SORT_CASESENSITIVE
void nullStringException(RexxThreadContext *c, CSTRING fName, size_t pos)
size_t RexxEntry SysMkDir(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
RexxRoutine5(uint32_t, SysFileTree, CSTRING, fSpec, RexxStemObject, files, OPTIONAL_CSTRING, opts, OPTIONAL_CSTRING, targetAttr, OPTIONAL_CSTRING, newAttr)
size_t RexxEntry SysGetKey(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
size_t RexxEntry SysUtilVersion(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
size_t RexxEntry RexxStemSort(const char *stemname, int order, int type, size_t start, size_t end, size_t firstcol, size_t lastcol)
int CopyFile_DontDereferenceSymbolicLinks(CSTRING fromFile, CSTRING toFile, bool force, bool preserveTimestamps, bool preserveMode, bool *timestampsPreserved=NULL, bool *modePreserved=NULL)
size_t RexxEntry SysQueryProcess(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
char * TemporaryFilename(CSTRING filename, int &errInfo)
size_t RexxEntry SysFileSearch(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
int GetLine(char *line, size_t size, GetFileData *filedata)
bool isAcceptableFile(mode_t m)
RexxRoutine3(int, SysAddRexxMacro, CSTRING, name, CSTRING, file, OPTIONAL_CSTRING, option)
RexxRoutine1(int, SysSleep, RexxStringObject, delay)
int SearchPath(int SearchFlag, const char *path, const char *filename, char *buf, size_t buf_size)
#define CURRENT_DIR_FIRST
char * resolve_tilde(const char *)
static bool getPath(RexxCallContext *c, char *fileSpec, char **path, size_t *pathLen, RXTREEDATA *treeData)
bool formatFile(RexxCallContext *c, RXTREEDATA *treeData, uint32_t options, struct stat *finfo)
bool SamePaths(CSTRING path1, CSTRING path2)
static bool getFileSpecFromArg(RexxCallContext *context, CSTRING fSpec, char *fileSpec, size_t bufLen, size_t argPos)
static bool getBiggerBuffer(RexxCallContext *c, char **dPath, size_t *nPath, size_t nStaticBuffer)
void restore_terminal(int signal)
size_t RexxEntry SysSetFileDateTime(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
static bool getOptionsFromArg(RexxCallContext *context, CSTRING opts, uint32_t *options, size_t argPos)
size_t RexxEntry SysRmDir(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
size_t RexxEntry SysTempFileName(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
static bool increaseBuffer(RexxCallContext *c, size_t need, RXTREEDATA *treeData, TreeDataBuffers whichBuffer)
RexxRoutine2(int, SysReorderRexxMacro, CSTRING, name, CSTRING, option)
void outOfMemoryException(RexxThreadContext *c)
size_t RexxEntry SysFileDelete(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
size_t RexxEntry SysFork(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
void initTreeData(RXTREEDATA *treeData, RexxStemObject files)
static bool getPathSegment(RexxCallContext *c, char *fileSpec, char **path, size_t *pathLen, int lastSlashPos)
size_t RexxEntry SysGetMessageX(const char *name, size_t numargs, CONSTRXSTRING args[], const char *queuename, PRXSTRING retstr)
int ReadNextBuffer(GetFileData *filedata)
static uint32_t newAttr(int32_t *mask, uint32_t attr)