HANDLE FindFirstFile(LPCSTR szPath,LPWIN32_FIND_DATA lpFindData) {
if (lpFindData == NULL || szPath == NULL)
return NULL;
CStdString strPath(szPath);
if (strPath.empty())
return INVALID_HANDLE_VALUE;
strPath.Replace("\\","/");
// if the file name is a directory then we add a * to look for all files in this directory
DIR *testDir = opendir(szPath);
if (testDir) {
strPath += "/*";
closedir(testDir);
}
int nFilePos = strPath.ReverseFind(XBMC_FILE_SEP);
CStdString strDir = ".";
CStdString strFiles = strPath;
if (nFilePos > 0) {
strDir = strPath.substr(0,nFilePos);
strFiles = strPath.substr(nFilePos + 1);
}
if (strFiles == "*.*")
strFiles = "*";
strFiles = CStdString("^") + strFiles + "$";
strFiles.Replace(".","\\.");
strFiles.Replace("*",".*");
strFiles.Replace("?",".");
strFiles.MakeLower();
int status;
regex_t re;
if (regcomp(&re, strFiles, REG_EXTENDED|REG_NOSUB) != 0) {
return(INVALID_HANDLE_VALUE);
}
struct dirent **namelist = NULL;
int n = scandir(strDir, &namelist, 0, alphasort);
CXHandle *pHandle = new CXHandle(CXHandle::HND_FIND_FILE);
pHandle->m_FindFileDir = strDir;
while (n-- > 0) {
CStdString strComp(namelist[n]->d_name);
strComp.MakeLower();
status = regexec(&re, strComp.c_str(), (size_t) 0, NULL, 0);
if (status == 0) {
pHandle->m_FindFileResults.push_back(namelist[n]->d_name);
}
free(namelist[n]);
}
if (namelist)
free(namelist);
regfree(&re);
if (pHandle->m_FindFileResults.size() == 0) {
delete pHandle;
return INVALID_HANDLE_VALUE;
}
FindNextFile(pHandle, lpFindData);
return pHandle;
}
int top_main(int argc, char **argv)
{
status_t *statuslist;
struct dirent **namelist;
int opt, num, interval, lines;
#if defined BB_FEATURE_AUTOWIDTH && defined BB_FEATURE_USE_TERMIOS
struct winsize win = { 0, 0, 0, 0 };
#endif
/* Default update rate is 5 seconds */
interval = 5;
/* Default to 25 lines - 5 lines for status */
lines = 25 - 5;
/* do normal option parsing */
while ((opt = getopt(argc, argv, "d:")) > 0) {
switch (opt) {
case 'd':
interval = atoi(optarg);
break;
default:
show_usage();
}
}
#if defined BB_FEATURE_AUTOWIDTH && defined BB_FEATURE_USE_TERMIOS
ioctl(fileno(stdout), TIOCGWINSZ, &win);
if (win.ws_row > 4)
lines = win.ws_row - 5;
#endif
/* change to proc */
if (chdir("/proc") < 0) {
perror_msg_and_die("chdir('/proc')");
}
/* read process IDs for all the processes from the procfs */
num = scandir(".", &namelist, filter_pids, num_sort);
if (num < 0) {
perror_msg_and_die("scandir('/proc')");
}
if (lines > num) {
lines = num;
}
/* read command line for each of the processes */
statuslist = read_info(num, namelist);
if (!statuslist) {
return EXIT_FAILURE;
}
while (1) {
/* read status for each of the processes */
read_status(num, statuslist);
/* display status */
display_status(lines, statuslist);
sleep(interval);
}
free(statuslist);
return EXIT_SUCCESS;
}
//TODO: append matches to some data structure instead of just printing them out
// then there can be sweet summaries of matches/files scanned/time/etc
int search_dir(pcre *re, const char* path, const int depth) {
//TODO: don't just die. also make max depth configurable
if(depth > MAX_SEARCH_DEPTH) {
log_err("Search depth greater than %i, giving up.", depth);
exit(1);
}
struct dirent **dir_list = NULL;
struct dirent *dir = NULL;
int results = 0;
FILE *fp = NULL;
int f_len;
size_t r_len;
char *buf = NULL;
int rv = 0;
char *dir_full_path = NULL;
size_t path_length = 0;
results = scandir(path, &dir_list, &ignorefile_filter, &alphasort);
if (results > 0) {
for (int i = 0; i < results; i++) {
dir = dir_list[i];
path_length = (size_t)(strlen(path) + strlen(dir->d_name) + 2); // 2 for slash and null char
dir_full_path = malloc(path_length);
dir_full_path = strncpy(dir_full_path, path, path_length);
dir_full_path = strncat(dir_full_path, "/", path_length);
dir_full_path = strncat(dir_full_path, dir->d_name, path_length);
load_ignore_patterns(dir_full_path);
free(dir);
free(dir_full_path);
}
}
free(dir_list);
results = scandir(path, &dir_list, &filename_filter, &alphasort);
if (results == 0)
{
log_debug("No results found");
free(dir_list);
return(0);
}
else if (results == -1) {
log_err("Error opening directory %s", path);
return(0);
}
for (int i=0; i<results; i++) {
dir = dir_list[i];
// XXX: this is copy-pasted from about 30 lines above
path_length = (size_t)(strlen(path) + strlen(dir->d_name) + 2); // 2 for slash and null char
dir_full_path = malloc(path_length);
dir_full_path = strncpy(dir_full_path, path, path_length);
dir_full_path = strncat(dir_full_path, "/", path_length);
dir_full_path = strncat(dir_full_path, dir->d_name, path_length);
log_debug("dir %s type %i", dir_full_path, dir->d_type);
//TODO: scan files in current dir before going deeper
if (dir->d_type == DT_DIR && opts.recurse_dirs) {
log_debug("searching dir %s", dir_full_path);
rv = search_dir(re, dir_full_path, depth + 1);
goto cleanup;
continue;
}
fp = fopen(dir_full_path, "r");
if (fp == NULL) {
log_err("Error opening file %s. Skipping...", dir_full_path);
goto cleanup;
continue;
}
rv = fseek(fp, 0, SEEK_END);
if (rv != 0) {
log_err("Error fseek()ing file %s. Skipping...", dir_full_path);
goto cleanup;
}
f_len = ftell(fp); //TODO: behave differently if file is HUGE. on 32 bit, anything > 2GB will screw up this program
if (f_len == 0) {
log_debug("file is empty. skipping");
goto cleanup;
}
rewind(fp);
buf = (char*) malloc(sizeof(char) * f_len + 1);
r_len = fread(buf, 1, f_len, fp);
buf[r_len] = '\0';
int buf_len = (int)r_len;
int buf_offset = 0;
int offset_vector[MAX_MATCHES_PER_FILE * 2]; //XXXX
int rc = 0;
char *match_start = NULL;
char *match_end = NULL;
int first_match = 1;
// In my profiling, most of the execution time is spent in this pcre_exec
while(buf_offset < buf_len && (rc = pcre_exec(re, NULL, buf, r_len, buf_offset, 0, offset_vector, sizeof(offset_vector))) >= 0 ) {
log_debug("Match found. File %s, offset %i bytes.", dir_full_path, offset_vector[0]);
match_start = buf + offset_vector[0];
match_end = buf + offset_vector[1];
buf_offset = offset_vector[1];
print_match(dir_full_path, buf, match_start, match_end, first_match);
first_match = 0;
}
free(buf);
cleanup:
if (fp != NULL) {
fclose(fp);
}
free(dir);
free(dir_full_path);
}
free(dir_list);
return(0);
}
static char * lhaMenu(void)
{
struct dirent **namelist;
int N,i,width;
char * menutxt=NULL;
void*h;
void (*getpdfsetlist)(char* s, size_t len)=NULL;
if(!dataPath) return NULL;
h=dlopen(NULL,RTLD_NOW);
getpdfsetlist=dlsym(h,"lhapdf_getpdfsetlist_");
if(!getpdfsetlist) getpdfsetlist=dlsym(h,"_lhapdf_getpdfsetlist_");
if(getpdfsetlist)
{ char buff[10000];
char *ch1,*ch2;
getpdfsetlist(buff,10000);
for(i=9999; i>=0 && buff[i]==' '; i--) ;
buff[i+1]=0;
i=strlen(buff);
width=0; N=0;
ch1=ch2=buff;
if(ch1[0]==0) return NULL;
for(;ch2!=buff+i; ch1=ch2+1,N++)
{ ch2=strchr(ch1,' ');
if(ch2==NULL) ch2=buff+i;
if(ch2-ch1>width) width=ch2-ch1;
}
menutxt=malloc(N*(width+2)+2);
N=0;
menutxt[0]=width+2;
for(ch1=buff;ch1; ch1=strchr(ch1,' '),N++)
{ char name[50];
while(ch1[0]==' ') ch1++;
sscanf(ch1,"%s",name);
sprintf(menutxt+1+N*(width+2)," %-*.*s ",width,width,name);
}
return menutxt;
}
N=scandir(dataPath, &namelist,filter ,alphasort);
if(N<=0) return NULL;
for(i=0,width=0;i<N;i++)
{ int l= strlen(namelist[i]->d_name);
if(width<l) width=l;
}
menutxt=malloc(N*(width+1)+2);
menutxt[0]=width+1; menutxt[1]=0;
for(i=0;i<N;i++)
{
sprintf(menutxt+1+(width+1)*i," %-*.*s",width,width,namelist[i]->d_name);
free(namelist[i]);
}
free(namelist);
menutxt[N*(width+1)+1]=0;
return menutxt;
}
int
populate_entries( struct pci_system * p )
{
struct dirent ** devices = NULL;
int n;
int i;
int err = 0;
n = scandir( SYS_BUS_PCI, & devices, scan_sys_pci_filter, alphasort );
if ( n > 0 ) {
p->num_devices = n;
p->devices = calloc( n, sizeof( struct pci_device_private ) );
if (p->devices != NULL) {
for (i = 0 ; i < n ; i++) {
uint8_t config[48];
pciaddr_t bytes;
unsigned dom, bus, dev, func;
struct pci_device_private *device =
(struct pci_device_private *) &p->devices[i];
sscanf(devices[i]->d_name, "%04x:%02x:%02x.%1u",
& dom, & bus, & dev, & func);
device->base.domain = dom;
device->base.bus = bus;
device->base.dev = dev;
device->base.func = func;
err = pci_device_linux_sysfs_read(& device->base, config, 0,
48, & bytes);
if ((bytes == 48) && !err) {
device->base.vendor_id = (uint16_t)config[0]
+ ((uint16_t)config[1] << 8);
device->base.device_id = (uint16_t)config[2]
+ ((uint16_t)config[3] << 8);
device->base.device_class = (uint32_t)config[9]
+ ((uint32_t)config[10] << 8)
+ ((uint32_t)config[11] << 16);
device->base.revision = config[8];
device->base.subvendor_id = (uint16_t)config[44]
+ ((uint16_t)config[45] << 8);
device->base.subdevice_id = (uint16_t)config[46]
+ ((uint16_t)config[47] << 8);
}
if (err) {
break;
}
}
}
else {
err = ENOMEM;
}
}
for (i = 0; i < n; i++)
free(devices[i]);
free(devices);
if (err) {
free(p->devices);
p->devices = NULL;
}
return err;
}
void
clean_q(struct printer *pp)
{
char *cp, *cp1, *lp;
struct dirent **queue;
size_t linerem;
int didhead, i, n, nitems, rmcp;
cln_queuecnt++;
didhead = 0;
if (generic_qselect == QSEL_BYNAME) {
printf("%s:\n", pp->printer);
didhead = 1;
}
lp = line;
cp = pp->spool_dir;
while (lp < &line[sizeof(line) - 1]) {
if ((*lp++ = *cp++) == 0)
break;
}
lp[-1] = '/';
linerem = sizeof(line) - (lp - line);
cln_foundcore = 0;
seteuid(euid);
nitems = scandir(pp->spool_dir, &queue, doselect, sortq);
seteuid(uid);
if (nitems < 0) {
if (!didhead) {
printf("%s:\n", pp->printer);
didhead = 1;
}
printf("\tcannot examine spool directory\n");
return;
}
if (cln_foundcore) {
if (!didhead) {
printf("%s:\n", pp->printer);
didhead = 1;
}
printf("\t** found a core file in %s !\n", pp->spool_dir);
}
if (nitems == 0)
return;
if (!didhead)
printf("%s:\n", pp->printer);
if (cln_debug) {
printf("\t** ----- Sorted list of files being checked:\n");
i = 0;
do {
cp = queue[i]->d_name;
printf("\t** [%3d] = %s\n", i, cp);
} while (++i < nitems);
printf("\t** ----- end of sorted list\n");
}
i = 0;
do {
cp = queue[i]->d_name;
rmcp = 0;
if (*cp == 'c') {
/*
* A control file. Look for matching data-files.
*/
/* XXX
* Note the logic here assumes that the hostname
* part of cf-filenames match the hostname part
* in df-filenames, and that is not necessarily
* true (eg: for multi-homed hosts). This needs
* some further thought...
*/
n = 0;
while (i + 1 < nitems) {
cp1 = queue[i + 1]->d_name;
if (*cp1 != 'd' || strcmp(cp + 3, cp1 + 3))
break;
i++;
n++;
}
if (n == 0) {
rmcp = 1;
}
} else if (*cp == 'e') {
/*
* Must be an errrs or email temp file.
*/
rmcp = 1;
} else {
/*
* Must be a df with no cf (otherwise, it would have
* been skipped above) or an rf or tf file (which can
* always be removed if it is old enough).
*/
rmcp = 1;
}
if (rmcp) {
if (strlen(cp) >= linerem) {
printf("\t** internal error: 'line' overflow!\n");
printf("\t** spooldir = %s\n", pp->spool_dir);
printf("\t** cp = %s\n", cp);
return;
}
strlcpy(lp, cp, linerem);
unlinkf(line);
}
} while (++i < nitems);
}
int load_plugin(const char *dir, const char* plugname) {
struct stat statbuf;
struct dirent **namelist;
int n, ret;
char *full_path, full_name[264];
DIR *plugindir;
ret = 0;
full_path = NULL;
plugin_list = NULL;
if (strlen(plugname) > 265) {
fprintf(stderr, " Error - Plugin name exceeds maximum length of 256 charakters: %s\n", plugname);
return(-1);
}
/* plugin directory must be configured */
if (!dir) {
fprintf(stderr, " Error - Plugin directory not set while trying to load plugin %s.\n", plugname);
exit(EXIT_FAILURE);
}
if ((plugindir = opendir(dir)) == NULL) {
fprintf(stderr, " Error - Unable to open plugin directory: %m.\n");
exit(EXIT_FAILURE);
}
DEBUG_FPRINTF(stdout, " Looking for plugin %s in %s\n", plugname, dir);
if ((n = scandir(dir, &namelist, 0, alphasort)) < 0) {
fprintf(stderr, " Error - Unable to scan plugin directory: %m.\n");
return(-1);
} else while(n--) {
stat(namelist[n]->d_name, &statbuf);
/* assemble full name */
memset(full_name, 0, 264);
strncpy(full_name, "htm_", 4);
strncpy(&full_name[4], plugname, strlen(plugname));
strncpy(&full_name[4+strlen(plugname)], ".so", 3);
if ((ret = fnmatch(full_name, namelist[n]->d_name, 0)) == 0) {
/* found the plugin */
if ((full_path = (char *) malloc(strlen(dir) + strlen(namelist[n]->d_name) + 2)) == NULL) {
perror(" Error - Unable to allocate memory");
exit(EXIT_FAILURE);
}
snprintf(full_path, strlen(dir)+strlen(namelist[n]->d_name)+2, "%s/%s", dir, namelist[n]->d_name);
DEBUG_FPRINTF(stdout, " Plugin found: %s\n", full_path);
config_plugin(full_path);
free(full_path);
free(namelist[n]);
break;
}
free(namelist[n]);
}
closedir(plugindir);
if (ret != 0) {
fprintf(stderr, " Error - Unable to load plugin %s: %m.\n", full_name);
exit(EXIT_FAILURE);
}
free(namelist);
return(1);
}
int recursive_delete(const char *d, const char *file, bool delfiles)
{
int n=-1;
int ret=RECDEL_OK;
struct dirent **dir;
struct stat statp;
char *directory=NULL;
if(!file)
{
if(!(directory=prepend_s(d, "", 0))) return RECDEL_ERROR;
}
else if(!(directory=prepend_s(d, file, strlen(file))))
{
log_out_of_memory(__FUNCTION__);
return RECDEL_ERROR;
}
if(lstat(directory, &statp))
{
// path does not exist.
free(directory);
return RECDEL_OK;
}
if((n=scandir(directory, &dir, 0, 0))<0)
{
logp("scandir %s: %s\n", directory, strerror(errno));
free(directory);
return RECDEL_ERROR;
}
while(n--)
{
char *fullpath=NULL;
if(dir[n]->d_ino==0
|| !strcmp(dir[n]->d_name, ".")
|| !strcmp(dir[n]->d_name, ".."))
{ free(dir[n]); continue; }
if(!(fullpath=prepend_s(directory,
dir[n]->d_name, strlen(dir[n]->d_name))))
break;
if(is_dir(fullpath))
{
int r;
if((r=recursive_delete(directory,
dir[n]->d_name, delfiles))==RECDEL_ERROR)
{
free(fullpath);
break;
}
// do not overwrite ret with OK if it previously
// had ENTRIES_REMAINING
if(r==RECDEL_ENTRIES_REMAINING) ret=r;
}
else if(delfiles)
{
if(unlink(fullpath))
{
logp("unlink %s: %s\n",
fullpath, strerror(errno));
ret=RECDEL_ENTRIES_REMAINING;
}
}
else
{
ret=RECDEL_ENTRIES_REMAINING;
}
free(fullpath);
free(dir[n]);
}
if(n>0)
{
ret=RECDEL_ERROR;
for(; n>0; n--) free(dir[n]);
}
free(dir);
if(ret==RECDEL_OK && rmdir(directory))
{
logp("rmdir %s: %s\n", directory, strerror(errno));
ret=RECDEL_ERROR;
}
free(directory);
return ret;
}
int getComList(char *ttylist)
{
int retval = 0;
struct dirent **namelist;
struct serial_struct serinfo;
char devicedir[1024];
char devfile[256];
char driver[64];
int n = 0, nn, fd;
ttylist[0] = '\0';
if ((nn = scandir(SYSDIR, &namelist, NULL, NULL)) > 0)
{
while (n < nn)
{
if (strcmp(namelist[n]->d_name,"..") && strcmp(namelist[n]->d_name,"."))
{
// Construct full absolute file path
sprintf(devicedir, "%s%s", SYSDIR, namelist[n]->d_name);
// Get the device driver
get_driver(devicedir, driver);
if (strlen(driver) > 0)
{
// Non empty drivers might be ok
//printf("Device: /dev/%s, Driver: %s\n", namelist[n]->d_name, driver);
sprintf(devfile, "/dev/%s", namelist[n]->d_name);
if (strstr(driver, "8250") != NULL)
{
// Check serial8250-devices separeately
if ((fd = open(devfile, O_RDWR | O_NONBLOCK | O_NOCTTY)) >= 0)
{
// If device open
if (ioctl(fd, TIOCGSERIAL, &serinfo) == 0)
{
// If can get get serial_info
if (serinfo.type != PORT_UNKNOWN)
{
// If device type is no PORT_UNKNOWN we accept the port
//printf("Device 8250 has port, accepted\n");
strcat(ttylist, "|");
strcat(ttylist, devfile);
}
}
close(fd);
}
}
else
{
// whatever has a driver and is not serial8250 is sure good
strcat(ttylist, "|");
strcat(ttylist, devfile);
}
}
}
free(namelist[n]);
n++;
}
free(namelist);
}
return (retval);
}
/* include a file or directory */
void include_file(YYLTYPE *yylloc, const char *name) {
struct stat st;
struct dirent **namelist;
char *fn;
int n;
struct sourceposition *pos;
pos = make_sourcepos(yylloc);
if (stat(name, &st)) {
if (errno == ENOENT &&
(index(name, '*') != NULL || index(name, '?') != NULL ||
index(name, '[') != NULL)) {
/* Globbing fiesta! */
glob_t glob_buf;
if (glob(name, 0, NULL, &glob_buf) != 0) {
filter_error(pos, "failed to glob \"%s\": %s", name, strerror(errno));
} else {
/* We go through the list of files backwards, because
* step_into_include_file() creates a stack of all the
* files processed and then works on them in a LIFO
* fashion -- which would make all of our rules files
* go backwards. Since I can't wrap my head around
* why that is, exactly, I'm hacking it up with
* this instead. Fixination appreciated.
*/
for (n = glob_buf.gl_pathc - 1; n >= 0; n--) {
if (stat(glob_buf.gl_pathv[n], &st)) {
filter_error(pos, "stat failed on globbed \"%s\": %s",
glob_buf.gl_pathv[n], strerror(errno));
} else if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
if (sourcefile_push(pos, glob_buf.gl_pathv[n])) {
filtergen_in = current_srcfile->f;
filtergen_lineno = current_srcfile->lineno;
// yycolumn = current_srcfile->column;
if (!filtergen_in) {
filter_error(pos, "failed to open %s", glob_buf.gl_pathv[n]);
} else {
filtergen_push_buffer_state(
filtergen__create_buffer(filtergen_in, YY_BUF_SIZE));
}
}
}
}
}
globfree(&glob_buf);
} else {
filter_error(pos, "stat failed on \"%s\": %s", name, strerror(errno));
}
} else {
if (S_ISDIR(st.st_mode)) {
char *b = strdup(name);
char *base = basename(b);
if (strcmp("/", base) == 0) {
filter_error(pos, "cannot include / path; skipping");
free(b);
return;
}
free(b);
if ((n = scandir(name, &namelist, NULL, alphasort)) < 0) {
filter_error(pos, "scandir failed on \"%s\": %s", name,
strerror(errno));
} else {
while (n--) {
/* FIXME: assumes d_name */
if (namelist[n]->d_name[0] == '.') {
free(namelist[n]);
continue;
}
if (asprintf(&fn, "%s/%s", name, namelist[n]->d_name) < 0) {
filter_error(
NULL, "internal error: asprintf failed constructing pathname "
"for included file \"%s\"",
namelist[n]->d_name);
free(fn);
} else {
include_file(yylloc, fn);
free(fn);
}
free(namelist[n]);
}
free(namelist);
}
} else {
if (sourcefile_push(pos, name)) {
filtergen_in = current_srcfile->f;
filtergen_lineno = current_srcfile->lineno;
// yycolumn = current_srcfile->column;
if (!filtergen_in) {
filter_error(pos, "failed to open %s", name);
} else {
filtergen_push_buffer_state(
filtergen__create_buffer(filtergen_in, YY_BUF_SIZE));
}
}
}
}
}
int main(
int argc,
char **argv
)
#endif
{
int fd;
int i;
int status;
off_t off;
struct dirent *d_not;
struct dirent **namelist;
struct stat s;
printf( "\n\n*** READDIR TEST ***\n" );
printf( "\nchdir to the root directory\n" );
status = chdir( "/" );
printf( "chdir() status : %d\n\n", status );
printf( "\nCreating a series of directories under /\n" );
i=0;
while ( strcmp(dnames[i], "END") != 0 )
{
status = mkdir( dnames[i], 0x1c0 );
printf("Creating directory: %s %d %d ", dnames[i], status, errno );
if ( errno == 0 )
printf(" Success\n");
else
printf(" Failure\n");
i++;
}
/*
* Create files under many and open the directory.
*/
printf("Create a lot of files\n");
status = mkdir( "/many", 0x1c0 );
status = chdir( "/many" );
for (i = 0; i<44; i++) {
printf("Create %s\n", many_files[i]);
fd = open (many_files[i], O_CREAT, S_IRWXU);
close (fd);
}
printf("Open /many and print the directory\n");
directory_not = opendir( "/many" );
printdir ( directory_not );
d_not = readdir( directory_not );
printf("open /b/myfile\n");
fd = open ("/b/my_file", O_CREAT, S_IRWXU);
rtems_test_assert( fd != -1 );
close (fd);
printf("scandir a file status: ");
status = scandir(
"/b/my_file",
&namelist,
select1,
NULL
);
printf("%d\n", status);
printf("Open /b/new_file\n");
fd = open( "/b/new_file", O_CREAT, S_IRWXU );
rtems_test_assert( fd != -1 );
printf("fcntl F_SETFD should return 0\n");
status = fcntl( fd, F_SETFD, 1 );
rtems_test_assert( status == 0 );
printf("fcntl F_SETFD should return 1\n");
status = fcntl( fd, F_GETFD, 1 );
rtems_test_assert( status == 1 );
#if 0
printf("fcntl F_DUPFD should return 0\n");
status = fcntl( fd, F_DUPFD, 0 );
rtems_test_assert ( status == 0 );
#else
printf("fcntl F_DUPFD should return 0 -- skip until implemented\n");
#endif
printf("fcntl F_GETFL returns current flags\n");
status = fcntl( fd, F_GETFL, 1 );
printf("fcntl F_GETFL returned 0x%x\n", status );
rtems_test_assert( status != -1 );
printf("fcntl F_SETFL to add O_APPEND and O_NONBLOCK\n");
status = fcntl( fd, F_SETFL, O_APPEND|O_NONBLOCK );
rtems_test_assert ( status != -1 );
printf("fcntl F_GETFL return current flags to see changes\n");
status = fcntl( fd, F_GETFL, 1 );
printf("fcntl F_GETFL returned 0x%x\n", status );
rtems_test_assert( status != -1 );
printf("fcntl F_GETLK should return -1\n");
status = fcntl( fd, F_GETLK, 1 );
rtems_test_assert ( status == -1 );
printf("fcntl F_SETLK should return -1\n");
status = fcntl( fd, F_SETLK, 1 );
rtems_test_assert ( status == -1 );
printf("fcntl F_SETLKW should return -1\n");
status = fcntl( fd, F_SETLKW, 1 );
rtems_test_assert ( status == -1 );
printf("fcntl F_SETOWN should return -1\n");
status = fcntl( fd, F_SETOWN, 1 );
rtems_test_assert ( status == -1 );
printf("fcntl F_GETOWN should return -1\n");
status = fcntl( fd, F_GETOWN, 1 );
rtems_test_assert ( status == -1 );
printf("fcntl invalid argument should return -1\n");
status = fcntl( fd, 0xb, 1 );
printf("Status %d\n",status);
rtems_test_assert( status == -1 );
printf("opendir and readdir /b/myfile\n");
directory_not = opendir ("/b/my_file");
d_not = readdir(directory_not);
printf("opendir and readdir\n");
directory_not = opendir ("/a");
d_not = readdir (directory_not);
printf("chdir to /b/myfile\n");
status = chdir ("/b/my_file");
rtems_test_assert (status == -1);
printf( "\nPerforming stat of directory /\n");
status = stat( "/", &s );
printf("status for stat : %d, size of directory: %" PRIdoff_t "\n\n", status, s.st_size);
puts( "\nOpen and print directory /" );
directory = opendir("/");
rtems_test_assert( directory );
printdir(directory);
printf("\nmkdir /d/my_dir\n");
status = mkdir( "/d/my_dir", 0x1c0 );
printf("Open /d/my_dir\n");
directory_not = opendir( "/d/my_dir" );
rtems_test_assert( directory_not );
printf( "remove /d/my_dir.\n" );
status = rmdir( "/d/my_dir" );
rtems_test_assert( status == 0 );
printf( "close /d/my_dir.\n" );
closedir( directory_not );
printf( "\nOpening directory /c\n" );
directory2 = opendir("/c");
rtems_test_assert( directory2 );
printdir(directory2);
status = closedir( directory2 );
printf( "\nOpening directory /c/y\n" );
directory3 = opendir("/c/y");
rtems_test_assert( directory3 );
printdir(directory3);
status = closedir( directory3 );
printf( "\nLSEEK to the start of the open directory\n" );
lseek( directory->dd_fd, 0, SEEK_SET );
printdir(directory);
lseek( directory->dd_fd, 0, SEEK_CUR );
lseek( directory->dd_fd, 0, SEEK_END );
lseek( directory->dd_fd, 0, -99 );
printf( "\nRewinding directory\n" );
rewinddir( directory );
printdir(directory);
#if 0
/* Newlib's implementation does not check for NULL */
printf( "Send rewinddir a NULL pointer\n");
rewinddir( NULL );
#endif
printf( "\nSeek directory\n" );
printf( "telldir() should report only sizeof(struct dirent) increments \n" );
printf( "in position. Sizeof(struct dirent): %ld\n",
(unsigned long) sizeof(struct dirent) );
rewinddir( directory );
for( off=0 ; off<=200 ; off=off + sizeof(struct dirent) / 4 ) {
seekdir( directory, off );
printf(
"seeked to %2d -- currently at %2d\n",
(int)off,
(int)telldir(directory)
);
}
printf( "Send seekdir a NULL pointer\n");
seekdir( NULL, off );
printf( "\nClosing directory\n" );
status = closedir( directory );
printf( "\nSCANDIR TEST\n");
printf( "\nselection rule 1\n");
printf( "scanning for any entry under directory /c\n\n");
status = scandir(
"/c",
&namelist,
select1,
NULL
);
printf("\nscandir status: %d\n", status );
for ( i=0; i<status; i++)
{
printf("Selected Node Name: %s\n", namelist[i]->d_name );
}
printf( "\nselection rule 2\n");
printf( "scanning for any entry under directory /c whose name = y\n\n");
status = scandir(
"/c",
&namelist,
select2,
NULL
);
printf("\nscandir status: %d\n", status );
for ( i=0; i<status; i++)
{
printf("Selected Node Name: %s\n", namelist[i]->d_name );
}
printf( "\nSCANDIR with sorting\n" );
printf( "\nselection rule 1\n");
printf( "scanning for any entry under directory /c\n");
printf( "sort in ascending order\n\n");
status = scandir(
"/c",
&namelist,
select1,
compare_ascending
);
printf("\nscandir status: %d\n", status );
for ( i=0; i<status; i++)
{
printf("Selected and Sorted Node Name: %s\n", namelist[i]->d_name );
}
printf( "\nSCANDIR with sorting\n" );
printf( "\nselection rule 1\n");
printf( "scanning for any entry under directory /c\n");
printf( "sort in descending order\n\n");
status = scandir(
"/c",
&namelist,
select1,
compare_descending
);
printf("scandir status: %d\n", status );
for ( i=0; i<status; i++)
{
printf("Selected and Sorted Node Name: %s\n", namelist[i]->d_name );
}
test_across_mount();
printf( "\n\n*** END OF READDIR TEST ***\n" );
rtems_test_exit(0);
}
int cgiMain() {
static char title[256] = "";
static char subtitle[256] = "";
char sorting[16] = "desc";
time_t now = time(NULL);
time_t start = time(NULL);
time_t expiration = time(NULL);
double available_secs = 0;
double remaining_secs = 0;
struct dirent **certstore_files = NULL;
int pagenumber = 1;
int certcounter = 0;
int tempcounter = 0;
int pagecounter = 0;
int dispcounter = 0;
int dispmaxlines = 0;
int certvalidity = 0;
div_t disp_calc;
div_t oddline_calc;
double percent = 0;
cert = X509_new();
certsubject = X509_NAME_new();
char **form_data = NULL; /* string array for query data */
/* get the current time */
now = time(NULL);
/* ------------------------------------------------------------------------- *
* If we are called without arguments, we display the cert search criteria *
* ------------------------------------------------------------------------- */
if (cgiFormEntries(&form_data) != cgiFormSuccess)
int_error("Error: Could not retrieve CGI form data.");
if(form_data[0] == NULL) {
start_tm = *gmtime(&now);
snprintf(title, sizeof(title), "Search existing Certificates");
pagehead(title);
fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"get\">");
fprintf(cgiOut, "<table>");
/* Search for Subject String */
fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Name</th></tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n");
fprintf(cgiOut, "<input type=\"radio\" value=\"dn\" name=\"search\" />");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "Distinguished Name Field:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
fprintf(cgiOut, "<select name=\"field\">");
fprintf(cgiOut, "<option value=\"countryName\">Country</option>");
fprintf(cgiOut, "<option value=\"stateOrProvinceName\">State</option>");
fprintf(cgiOut, "<option value=\"localityName\">Location</option>");
fprintf(cgiOut, "<option value=\"organizationName\">Organisation</option>");
fprintf(cgiOut, "<option value=\"organizationalUnitName\">Department</option>");
fprintf(cgiOut, "<option value=\"emailAddress\">E-Mail Addr</option>");
fprintf(cgiOut, "<option selected=\"selected\" value=\"commonName\">Common Name</option>");
fprintf(cgiOut, "<option value=\"surname\">Surname</option>");
fprintf(cgiOut, "<option value=\"givenName\">Given Name</option>");
fprintf(cgiOut, "</select>");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "Search String<br />[20 chars max]:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
fprintf(cgiOut, "<input type=\"text\" size=\"15\" name=\"dnvalue\" value=\"changeme.com\" />");
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n");
fprintf(cgiOut, "Search for certificates that have the given string in the selected DN field. ");
fprintf(cgiOut, "The search is case sensitive, so results for country=us can be different from country=US and country=Us.");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "</tr>\n");
/* Search for Expiration Date */
fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Expiration Date</th></tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n");
fprintf(cgiOut, "<input type=\"radio\" value=\"exp\" name=\"search\" checked=\"checked\" />");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "Expiration Date is<br />between Start Date:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &start_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"exp_startdate\" value=\"%s\" /> ", membio_buf);
strftime(membio_buf, sizeof(membio_buf), "%H:%M", &start_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"exp_starttime\" value=\"%s\" />", membio_buf);
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "and End Date<br />[default 90 days]:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
/* set second time 3 months (90 days) into the future: 86400s/d*90d=7776000s */
expiration = now + 7776000;
expiration_tm = *gmtime(&expiration);
strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &expiration_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"exp_enddate\" value=\"%s\" /> ", membio_buf);
strftime(membio_buf, sizeof(membio_buf), "%H:%M", &expiration_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"exp_endtime\" value=\"%s\" />", membio_buf);
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n");
fprintf(cgiOut, "Search for certificates that expire(d) between the selected start and end date. ");
fprintf(cgiOut, "By default, the search is pre-set to find certificates that expire in the next 3 months.");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "</tr>\n");
/* Search for Enabled Date */
fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Creation Date</th></tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n");
fprintf(cgiOut, "<input type=\"radio\" value=\"ena\" name=\"search\" />");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "Enabled Date is<br />between Start Date:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
/* set second time 3 months (90 days) into the past: 86400s/d*90d=7776000s */
expiration = now - 7776000;
expiration_tm = *gmtime(&expiration);
strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &expiration_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"ena_startdate\" value=\"%s\" /> ", membio_buf);
strftime(membio_buf, sizeof(membio_buf), "%H:%M", &expiration_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"ena_starttime\" value=\"%s\" />", membio_buf);
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "and End Date<br />[default now]:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &start_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"ena_enddate\" value=\"%s\" /> ", membio_buf);
strftime(membio_buf, sizeof(membio_buf), "%H:%M", &start_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"ena_endtime\" value=\"%s\" />", membio_buf);
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n");
fprintf(cgiOut, "Search for certificates that become valid between the selected start and end date. ");
fprintf(cgiOut, "By default, the search is pre-set to show certificates created in the past 3 months.");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "</tr>\n");
/* Search for Revocation Date */
fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Revocation Date</th></tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n");
fprintf(cgiOut, "<input type=\"radio\" value=\"rev\" name=\"search\" />");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "Revocation Date is<br />between Start Date:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
/* set second time 3 months (90 days) into the past: 86400s/d*90d=7776000s */
expiration = now - 7776000;
expiration_tm = *gmtime(&expiration);
strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &expiration_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"rev_startdate\" value=\"%s\" /> ", membio_buf);
strftime(membio_buf, sizeof(membio_buf), "%H:%M", &expiration_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"rev_starttime\" value=\"%s\"/>", membio_buf);
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "and End Date<br />[now]:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
strftime(membio_buf, sizeof(membio_buf), "%d.%m.%Y", &start_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"9\" name=\"rev_enddate\" value=\"%s\" /> ", membio_buf);
strftime(membio_buf, sizeof(membio_buf), "%H:%M", &start_tm);
fprintf(cgiOut, "<input type=\"text\" size=\"3\" name=\"rev_endtime\" value=\"%s\" />", membio_buf);
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n");
fprintf(cgiOut, "Search for certificates that have been revoked between the selected start and end date. ");
fprintf(cgiOut, " By default, the search is pre-set to show certificates revoked in the past 3 months.");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "</tr>\n");
/* Search for Serial Number */
fprintf(cgiOut, "<tr><th colspan=\"5\">Search by Serial Number</th></tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th class=\"cnt\" rowspan=\"2\">\n");
fprintf(cgiOut, "<input type=\"radio\" value=\"ser\" name=\"search\" />");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "Serial Number is<br />between Start Serial:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
fprintf(cgiOut, "<input type=\"text\" size=\"14\" name=\"startserial\" ");
fprintf(cgiOut, "value=\"%s\" style=\"text-align:right;\" />", startserstr);
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "<td class=\"type\">\n");
fprintf(cgiOut, "and End Serial<br />[max 10e11]:");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "<td class=\"center\">\n");
fprintf(cgiOut, "<input type=\"text\" size=\"14\" name=\"endserial\" ");
fprintf(cgiOut, "value=\"%s\" style=\"text-align:right;\" />", endserstr);
fprintf(cgiOut, "</td>");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<td class=\"desc\" colspan=\"4\">\n");
fprintf(cgiOut, "Search for certificates whose serial number is between the given ");
fprintf(cgiOut, "start and end serial number in decimal format. To find a particular certificate, set start and end serial to be equal.");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th colspan=\"5\">");
fprintf(cgiOut, "<input type=\"submit\" value=\"Search Certificates\" />");
fprintf(cgiOut, "</th>");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "</table>\n");
fprintf(cgiOut, "</form>\n");
pagefoot();
}
else {
/* ------------------------------------------------------------------- *
* check if we got the CGI form data *
* --------------------------------------------------------------------*/
if ( cgiFormString("search", search, sizeof(search))
!= cgiFormSuccess )
int_error("Error retrieving CGI form search type.");
else {
if (strcmp(search, "dn") == 0) {
if ( cgiFormString("field", field, sizeof(field))
!= cgiFormSuccess )
int_error("Error retrieving CGI form DN search field information.");
if ( cgiFormString("dnvalue", dnvalue, sizeof(dnvalue))
!= cgiFormSuccess )
int_error("Error retrieving CGI form DN search dnvalue information.");
snprintf(title, sizeof(title), "Search Certs by Subject");
snprintf(subtitle, sizeof(subtitle), "Certificates with DN %s=%s", field, dnvalue);
}
else if (strcmp(search, "exp") == 0) {
if ( cgiFormString("exp_startdate", exp_startdate, sizeof(exp_startdate))
!= cgiFormSuccess )
int_error("Error retrieving CGI form expiration start date.");
if ( cgiFormString("exp_starttime", exp_starttime, sizeof(exp_starttime))
!= cgiFormSuccess )
int_error("Error retrieving CGI form expiration start time.");
if ( cgiFormString("exp_enddate", exp_enddate, sizeof(exp_enddate))
!= cgiFormSuccess )
int_error("Error retrieving CGI form expiration end date.");
if ( cgiFormString("exp_endtime", exp_endtime, sizeof(exp_endtime))
!= cgiFormSuccess )
int_error("Error retrieving CGI form expiration end time.");
strncat(exp_startstr, exp_startdate, sizeof(exp_startstr)-1);
strncat(exp_startstr, " ", 1); /* add a space between date and time */
strncat(exp_startstr, exp_starttime, sizeof(exp_startstr)-strlen(exp_startstr)-1);
strncat(exp_endstr, exp_enddate, sizeof(exp_endstr)-1);
strncat(exp_endstr, " ", 1); /* add a space between date and time */
strncat(exp_endstr, exp_endtime, sizeof(exp_endstr)-strlen(exp_endstr)-1);
snprintf(title, sizeof(title), "Search Certs by Expiration");
snprintf(subtitle, sizeof(subtitle), "Certificates with expiration between %s and %s", exp_startstr, exp_endstr);
}
else if (strcmp(search, "ena") == 0) {
if ( cgiFormString("ena_startdate", ena_startdate, sizeof(ena_startdate))
!= cgiFormSuccess )
int_error("Error retrieving CGI form enable start date.");
if ( cgiFormString("ena_starttime", ena_starttime, sizeof(ena_starttime))
!= cgiFormSuccess )
int_error("Error retrieving CGI form enable start time.");
if ( cgiFormString("ena_enddate", ena_enddate, sizeof(ena_enddate))
!= cgiFormSuccess )
int_error("Error retrieving CGI form enable end date.");
if ( cgiFormString("ena_endtime", ena_endtime, sizeof(ena_endtime))
!= cgiFormSuccess )
int_error("Error retrieving CGI form enable end time.");
strncat(ena_startstr, ena_startdate, sizeof(ena_startstr)-1);
strncat(ena_startstr, " ", 1); /* add a space between date and time */
strncat(ena_startstr, ena_starttime, sizeof(ena_startstr)-strlen(ena_startstr)-1);
strncat(ena_endstr, ena_enddate, sizeof(ena_endstr)-1);
strncat(ena_endstr, " ", 1); /* add a space between date and time */
strncat(ena_endstr, ena_endtime, sizeof(ena_endstr)-strlen(ena_endstr)-1);
snprintf(title, sizeof(title), "Search Certs by Start Date");
snprintf(subtitle, sizeof(subtitle), "Certificates with start date between %s and %s", ena_startstr, ena_endstr);
}
else if (strcmp(search, "rev") == 0) {
if ( cgiFormString("rev_startdate", rev_startdate, sizeof(rev_startdate))
!= cgiFormSuccess )
int_error("Error retrieving CGI form enable start date.");
if ( cgiFormString("rev_starttime", rev_starttime, sizeof(rev_starttime))
!= cgiFormSuccess )
int_error("Error retrieving CGI form enable start time.");
if ( cgiFormString("rev_enddate", rev_enddate, sizeof(rev_enddate))
!= cgiFormSuccess )
int_error("Error retrieving CGI form enable end date.");
if ( cgiFormString("rev_endtime", rev_endtime, sizeof(rev_endtime))
!= cgiFormSuccess )
int_error("Error retrieving CGI form enable end time.");
strncat(rev_startstr, rev_startdate, sizeof(rev_startstr)-1);
strncat(rev_startstr, " ", 1); /* add a space between date and time */
strncat(rev_startstr, rev_starttime, sizeof(rev_startstr)-strlen(rev_startstr)-1);
strncat(rev_endstr, rev_enddate, sizeof(rev_endstr)-1);
strncat(rev_endstr, " ", 1); /* add a space between date and time */
strncat(rev_endstr, rev_endtime, sizeof(rev_endstr)-strlen(rev_endstr)-1);
snprintf(title, sizeof(title), "Search Revoked Certificates");
snprintf(subtitle, sizeof(subtitle), "Certificates revoked between %s and %s", rev_startstr, rev_endstr);
}
else if (strcmp(search, "ser") == 0) {
if ( cgiFormString("startserial", startserstr, sizeof(startserstr))
!= cgiFormSuccess )
int_error("Error retrieving CGI form start serial value.");
if ( cgiFormString("endserial", endserstr, sizeof(endserstr))
!= cgiFormSuccess )
int_error("Error retrieving CGI form end serial value.");
snprintf(title, sizeof(title), "Search Certs by Serial Number");
snprintf(subtitle, sizeof(subtitle), "Certificates with serial number between %s and %s", startserstr, endserstr);
}
else int_error("Error CGI form retrieving a valid search type.");
}
/* -------------------------------------------------------------------------- *
* We got CGI arguments, first we get a list of .pem files from the cert dir *
* ---------------------------------------------------------------------------*/
certcounter = scandir(CACERTSTORE, &certstore_files, file_select, hexsort);
// It can happen that our search does not return any certs. This is not an error.
//if(certcounter<=0) int_error("Error: No certificate files found.");
/* -------------------------------------------------------------------------- *
* calculate how many pages we get with MAXCERTDISPLAY *
* ---------------------------------------------------------------------------*/
if(certcounter<=MAXCERTDISPLAY) pagecounter = 1;
else {
disp_calc = div(certcounter, MAXCERTDISPLAY);
/* if the count of certs divided by MAXCERTDISPLAY has no remainder */
if(disp_calc.rem == 0) pagecounter = disp_calc.quot;
/* with a remainder, we must prepare an extra page for the rest */
else pagecounter = disp_calc.quot +1;
}
/* -------------------------------------------------------------------------- *
* Check if we have been subsequently called with a pagenumber & sort request *
* ---------------------------------------------------------------------------*/
if(cgiFormInteger("page", &pagenumber, 1) == cgiFormSuccess)
if(pagenumber > pagecounter || pagenumber <=0)
int_error("Error: Page does not exist.");
if(cgiFormString("sort", sorting, sizeof(sorting)) != cgiFormSuccess)
strncpy(sorting, "desc", sizeof(sorting));
/* -------------------------------------------------------------------------- *
* now we know how many certs we have in total and we can build the page(s). *
* For every MAXCERTDISPLAY certs we start a new page and cycle through by *
* calling ourself with the requested certs in range. *
* ---------------------------------------------------------------------------*/
if(strcmp(sorting, "asc") == 0) {
if(certcounter <= MAXCERTDISPLAY) {
dispmaxlines = certcounter;
tempcounter = 0;
}
else
if(pagenumber == pagecounter &&
( pagecounter * MAXCERTDISPLAY) - certcounter != 0) {
tempcounter = (pagecounter * MAXCERTDISPLAY) - MAXCERTDISPLAY;
dispmaxlines = certcounter - ((pagecounter-1) * MAXCERTDISPLAY);
}
else {
tempcounter = (pagenumber * MAXCERTDISPLAY) - MAXCERTDISPLAY;
dispmaxlines = MAXCERTDISPLAY;
}
}
if(strcmp(sorting, "desc") == 0) {
if(certcounter <= MAXCERTDISPLAY) {
dispmaxlines = certcounter;
tempcounter = certcounter;
}
else
if(pagenumber == pagecounter &&
( pagecounter * MAXCERTDISPLAY) - certcounter != 0) {
tempcounter = certcounter - ((pagecounter-1) * MAXCERTDISPLAY);
dispmaxlines = certcounter - ((pagecounter-1) * MAXCERTDISPLAY);
}
else {
tempcounter = certcounter - (pagenumber*MAXCERTDISPLAY) + MAXCERTDISPLAY;
dispmaxlines = MAXCERTDISPLAY;
}
}
/* -------------------------------------------------------------------------- *
* start the html output *
* ---------------------------------------------------------------------------*/
pagehead(title);
//debugging only:
//printf("Number of certs: %d\n", certcounter);
//printf("Num tempcounter: %d\n", tempcounter);
//printf("Number of pages: %d\n", pagecounter);
//printf("Div Quotient: %d\n", disp_calc.quot);
//printf("Div Remainder: %d\n", disp_calc.rem);
//fprintf(cgiOut, "</BODY></HTML>\n");
//exit(0);
/* -------------------------------------------------------------------------- *
* start the form output *
* ---------------------------------------------------------------------------*/
fprintf(cgiOut, "<h3>%s</h3>\n", subtitle);
fprintf(cgiOut, "<p></p>\n");
fprintf(cgiOut, "<table>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th width=\"20\">");
fprintf(cgiOut, "#");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<th width=\"495\">");
fprintf(cgiOut, "Certificate Subject Information");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<th width=\"60\" colspan=\"2\">");
fprintf(cgiOut, "Expires");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<th width=\"65\">");
fprintf(cgiOut, "Action");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "</tr>\n");
/* if our search did not return any certs, we display a note instead */
if(certcounter<=0) {
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<td class=\"even\" colspan=\"5\">");
fprintf(cgiOut, "Could not find any certificates for the given search criteria.");
fprintf(cgiOut, "</td>\n");
fprintf(cgiOut, "</tr>\n");
}
for(dispcounter=0; dispcounter < dispmaxlines; dispcounter++) {
/* zero certificate values and flags */
certvalidity = 0;
percent = 0;
available_secs = 0;
remaining_secs = 0;
cert = X509_new();
certsubject = X509_NAME_new();
if(strcmp(sorting, "desc") == 0) tempcounter--;
snprintf(certfilestr, sizeof(certfilestr), "%s/%s",
CACERTSTORE, certstore_files[tempcounter]->d_name);
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th rowspan=\"2\">");
fprintf(cgiOut, "%d", tempcounter+1);
fprintf(cgiOut, "</th>\n");
oddline_calc = div(tempcounter+1, 2);
if(oddline_calc.rem)
fprintf(cgiOut, "<td rowspan=\"2\" class=\"odd\">");
else
fprintf(cgiOut, "<td rowspan=\"2\" class=\"even\">");
if ( (certfile = fopen(certfilestr, "r")) != NULL) {
PEM_read_X509(certfile, &cert, NULL, NULL);
/* ---------------------------------------------------------- *
* Display the subject data. Use the UTF-8 flag to show *
* Japanese Kanji. This also needs the separator flag to work *
* ---------------------------------------------------------- */
certsubject = X509_get_subject_name(cert);
X509_NAME_print_ex_fp(cgiOut, certsubject, 0,
ASN1_STRFLGS_UTF8_CONVERT|XN_FLAG_SEP_CPLUS_SPC);
/* store certificate start date for later eval */
start_date = X509_get_notBefore(cert);
/* store certificate expiration date for later eval */
expiration_date = X509_get_notAfter(cert);
/* check the start and end dates in the cert */
if (X509_cmp_current_time (X509_get_notBefore (cert)) >= 0)
/* flag the certificate as not valid yet */
certvalidity = 0;
else
if (X509_cmp_current_time (X509_get_notAfter (cert)) <= 0)
/* flag the certificate as expired */
certvalidity = 0;
else
/* flag the certificate is still valid */
certvalidity = 1;
fclose(certfile);
}
else
fprintf(cgiOut, "Error: Can't open certificate file %s for reading.",
certfilestr);
fprintf(cgiOut, "</td>\n");
if(certvalidity == 0) {
/* expiration bar display column */
fprintf(cgiOut, "<th rowspan=\"2\">\n");
fprintf(cgiOut, "<table class=\"led\">\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, "</table>\n");
fprintf(cgiOut, "</th>\n");
/* remaining days before expiration column */
fprintf(cgiOut, "<th class=\"exnok\" rowspan=\"2\">");
fprintf(cgiOut, "Inval.<br />/Expd");
fprintf(cgiOut, "</th>\n");
}
if(certvalidity == 1) {
/* ------ START get the certificate lifetime in seconds ------ */
/* copy the start date into a string */
membio = BIO_new(BIO_s_mem());
ASN1_TIME_print(membio, start_date);
BIO_gets(membio, membio_buf, sizeof(membio_buf));
BIO_free(membio);
/* parse the start date string into a time struct */
memset (&start_tm, '\0', sizeof(start_tm));
strptime(membio_buf, "%h %d %T %Y %z", &start_tm);
start = mktime(&start_tm);
/* ------ START get the certificate remaining time in seconds ------ */
/* copy the expiration date into a string */
membio = BIO_new(BIO_s_mem());
ASN1_TIME_print(membio, expiration_date);
BIO_gets(membio, membio_buf, sizeof(membio_buf));
BIO_free(membio);
/* parse the expiration date string into a time struct */
memset (&expiration_tm, '\0', sizeof(expiration_tm));
strptime(membio_buf, "%h %d %T %Y %z", &expiration_tm);
/* get the current time */
expiration = mktime(&expiration_tm);
/* get the time difference between expiration time and current time */
remaining_secs = difftime(expiration, now);
/* ------ END get the certificate remaining time in seconds ------ */
/* get the time difference between start and expiration time */
available_secs = difftime(expiration, start);
/* ------ END get the certificate lifetime in seconds ------ */
/* ------ START calculate percentage of lifetime left ------ */
/* remaining_secs *100 */
/* ------------------- = X, rounded down with floor() */
/* available_secs */
percent = floor((remaining_secs*100)/available_secs);
/* ------ END calculate percentage of lifetime left ------ */
/* expiration bar display column */
fprintf(cgiOut, "<th rowspan=\"2\">");
fprintf(cgiOut, "<table class=\"led\">\n");
if (percent >= 90) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#00FF00></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
if (percent >= 80) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#00FF33></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
if (percent >= 70) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#99FF33></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
if (percent >= 60) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FFFF00></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
if (percent >= 50) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FFCC00></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
if (percent >= 40) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FF9900></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
if (percent >= 30) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FF6600></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
if (percent >= 20) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FF3300></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
if (percent >= 10) fprintf(cgiOut, " <tr><td class=\"led\" bgcolor=#FF0000></td></tr>\n");
else fprintf(cgiOut, " <tr><td class=\"led-off\"></td></tr>\n");
fprintf(cgiOut, "</table>\n");
fprintf(cgiOut, "</th>");
/* remaining days before expiration column */
//fprintf(cgiOut, membio_buf);
if (percent < 10) fprintf(cgiOut, "<th class=\"exnok\" rowspan=\"2\">\n");
else fprintf(cgiOut, "<th class=\"exok\" rowspan=\"2\">\n");
if(floor(remaining_secs/63072000) > 0) fprintf(cgiOut, "%.f<br />years", remaining_secs/31536000);
else if(floor(remaining_secs/86400) > 0 ) fprintf(cgiOut, "%.f<br />days", remaining_secs/86400);
else if(floor(remaining_secs/3600) > 0 ) fprintf(cgiOut, "%.f<br />hours", remaining_secs/3600);
else if(floor(remaining_secs/60) > 0 ) fprintf(cgiOut, "%.f<br />mins", remaining_secs/60);
else fprintf(cgiOut, "%.f<br />secs", remaining_secs);
fprintf(cgiOut, "</th>\n");
}
/* action column */
fprintf(cgiOut, "<th>");
fprintf(cgiOut, "<form action=\"getcert.cgi\" method=\"post\">\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"cfilename\" ");
fprintf(cgiOut, "value=\"%s\" />\n", certstore_files[tempcounter]->d_name);
fprintf(cgiOut, "<input type=\"hidden\" name=\"format\" value=\"pem\" />\n");
fprintf(cgiOut, "<input class=\"getcert\" type=\"submit\" value=\"Detail\" />\n");
fprintf(cgiOut, "</form>\n");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th>");
fprintf(cgiOut, "<form action=\"getcert.cgi\" method=\"post\">\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"cfilename\" ");
fprintf(cgiOut, "value=\"%s\" />\n", certstore_files[tempcounter]->d_name);
fprintf(cgiOut, "<input type=\"hidden\" name=\"format\" value=\"text\" />\n");
fprintf(cgiOut, "<input class=\"getcert\" type=\"submit\" value=\"Renew\" />\n");
fprintf(cgiOut, "</form>");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "</tr>\n");
if(strcmp(sorting, "asc") == 0) tempcounter++;
}
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th colspan=\"5\">");
fprintf(cgiOut, "Total # of certs: %d | ", certcounter);
fprintf(cgiOut, "Page %d of %d", pagenumber, pagecounter);
fprintf(cgiOut, "</th>");
fprintf(cgiOut, "</tr>");
fprintf(cgiOut, "</table>\n");
fprintf(cgiOut, "<p></p>\n");
fprintf(cgiOut, "<table>\n");
fprintf(cgiOut, "<tr>\n");
fprintf(cgiOut, "<th>");
fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">");
fprintf(cgiOut, "<input type=\"hidden\" name=\"sort\" ");
fprintf(cgiOut, "value=\"desc\" />\n");
resubmit();
fprintf(cgiOut, "<input type=\"submit\" name=\"sort\"");
fprintf(cgiOut, " value=\"Latest Certs first\" />");
fprintf(cgiOut, "</form>");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "<th>");
fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">");
fprintf(cgiOut, "<input type=\"hidden\" name=\"sort\" ");
fprintf(cgiOut, "value=\"asc\">\n");
resubmit();
fprintf(cgiOut, "<input type=\"submit\" name=\"sort\"");
fprintf(cgiOut, " value=\"Oldest Certs first\">");
fprintf(cgiOut, "</form>");
fprintf(cgiOut, "</th>\n");
// filler 1
fprintf(cgiOut, "<th width=\"15\">");
fprintf(cgiOut, " ");
fprintf(cgiOut, "</th>\n");
// goto page 1
fprintf(cgiOut, "<th width=\"5\">");
fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">");
resubmit();
fprintf(cgiOut, "<input type=\"submit\" value=\"<<\" />");
fprintf(cgiOut, "</form>");
fprintf(cgiOut, "</th>\n");
// goto page before
fprintf(cgiOut, "<th width=\"5\">");
fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">");
fprintf(cgiOut, "<input type=\"hidden\" name=\"certcounter\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", certcounter);
fprintf(cgiOut, "\" />\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"pagecounter\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", pagecounter);
fprintf(cgiOut, "\" />\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"page\" ");
fprintf(cgiOut, "value=\"");
tempcounter = 0;
if(pagenumber > 1) tempcounter = pagenumber - 1;
else tempcounter = 1;
fprintf(cgiOut, "%d", tempcounter);
fprintf(cgiOut, "\" />\n");
resubmit();
fprintf(cgiOut, "<input type=\"submit\" value=\"< 1\">");
fprintf(cgiOut, "</form>");
fprintf(cgiOut, "</th>\n");
// goto page after
fprintf(cgiOut, "<th width=\"5\">");
fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">");
fprintf(cgiOut, "<input type=\"hidden\" name=\"certcounter\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", certcounter);
fprintf(cgiOut, "\" />\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"pagecounter\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", pagecounter);
fprintf(cgiOut, "\" />\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"page\" ");
fprintf(cgiOut, "value=\"");
tempcounter = 0;
if(pagecounter > pagenumber) tempcounter = pagenumber + 1;
else tempcounter = pagecounter;
fprintf(cgiOut, "%d", tempcounter);
fprintf(cgiOut, "\" />\n");
resubmit();
fprintf(cgiOut, "<input type=\"submit\" value=\"1 >\" />");
fprintf(cgiOut, "</form>");
fprintf(cgiOut, "</th>\n");
// goto last page
fprintf(cgiOut, "<th width=\"5\">");
fprintf(cgiOut, "<form action=\"certsearch.cgi\" method=\"post\">");
fprintf(cgiOut, "<input type=\"hidden\" name=\"certcounter\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", certcounter);
fprintf(cgiOut, "\" />\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"pagecounter\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", pagecounter);
fprintf(cgiOut, "\" />\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"page\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", pagecounter);
fprintf(cgiOut, "\" />\n");
resubmit();
fprintf(cgiOut, "<input type=\"submit\" value=\">>\" />");
fprintf(cgiOut, "</form>");
fprintf(cgiOut, "</th>\n");
// goto page number
fprintf(cgiOut, "<th width=\"120\">\n");
fprintf(cgiOut, "<form class=\"setpage\" action=\"certsearch.cgi\" method=\"post\">\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"certcounter\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", certcounter);
fprintf(cgiOut, "\" />\n");
fprintf(cgiOut, "<input type=\"hidden\" name=\"pagecounter\" ");
fprintf(cgiOut, "value=\"");
fprintf(cgiOut, "%d", pagecounter);
fprintf(cgiOut, "\" />\n");
resubmit();
fprintf(cgiOut, "<input class=\"goto\" type=\"submit\" value=\"Goto\" />\n");
fprintf(cgiOut, " ");
fprintf(cgiOut, "<input class=\"page\" type=\"text\" name=\"page\" ");
fprintf(cgiOut, "value=\"%d\" />\n", pagecounter);
fprintf(cgiOut, "</form>\n");
fprintf(cgiOut, "</th>\n");
fprintf(cgiOut, "</tr>\n");
fprintf(cgiOut, "</table>\n");
/* ---------------------------------------------------------------------------*
* end the html output *
* ---------------------------------------------------------------------------*/
pagefoot();
}
return(0);
}
int destroy_instance_backing (ncInstance * instance, int do_destroy_files)
{
int ret = OK;
int total_prereqs = 0;
char path [MAX_PATH];
virtualMachine * vm = &(instance->params);
// find and detach iSCSI targets, if any
for (int i=0; i<EUCA_MAX_VBRS && i<vm->virtualBootRecordLen; i++) {
virtualBootRecord * vbr = &(vm->virtualBootRecord[i]);
if (vbr->locationType==NC_LOCATION_IQN) {
if (disconnect_iscsi_target (vbr->resourceLocation)) {
logprintfl(EUCAERROR, "[%s] error: failed to disconnect iSCSI target attached to %s\n", instance->instanceId, vbr->backingPath);
}
}
}
// see if instance directory is there (sometimes startup fails before it is created)
set_path (path, sizeof (path), instance, NULL);
if (check_path (path))
return ret;
// to ensure that we are able to delete all blobs, we chown files back to 'eucalyptus'
// (e.g., libvirt on KVM on Maverick chowns them to libvirt-qemu while
// VM is running and then chowns them to root after termination)
set_path (path, sizeof (path), instance, "*");
if (diskutil_ch (path, EUCALYPTUS_ADMIN, NULL, BACKING_FILE_PERM)) {
logprintfl (EUCAWARN, "[%s] error: failed to chown files before cleanup\n", instance->instanceId);
}
if (do_destroy_files) {
char work_regex [1024]; // {userId}/{instanceId}/.*
set_id2 (instance, "/.*", work_regex, sizeof (work_regex));
if (blobstore_delete_regex (work_bs, work_regex) == -1) {
logprintfl (EUCAERROR, "[%s] error: failed to remove some artifacts in %s\n", instance->instanceId, path);
}
// remove the known leftover files
unlink (instance->xmlFilePath);
unlink (instance->libvirtFilePath);
unlink (instance->consoleFilePath);
if (strlen (instance->floppyFilePath)) {
unlink (instance->floppyFilePath);
}
set_path (path, sizeof (path), instance, "instance.checkpoint");
unlink (path);
for (int i=0; i < EUCA_MAX_VOLUMES; ++i) {
ncVolume * volume = &instance->volumes[i];
snprintf (path, sizeof (path), EUCALYPTUS_VOLUME_XML_PATH_FORMAT, instance->instancePath, volume->volumeId);
unlink (path);
}
// bundle instance will leave additional files
// let's delete every file in the directory
struct dirent **files;
int n = scandir(instance->instancePath, &files, 0, alphasort);
char toDelete[MAX_PATH];
if (n>0){
while (n--) {
struct dirent *entry = files[n];
if( entry !=NULL && strncmp(entry->d_name, ".",1)!=0 && strncmp(entry->d_name, "..", 2)!=0){
snprintf(toDelete, MAX_PATH, "%s/%s", instance->instancePath, entry->d_name);
unlink(toDelete);
free(entry);
}
}
free(files);
}
}
// Finally try to remove the directory.
// If either the user or our code introduced
// any new files, this last step will fail.
set_path (path, sizeof (path), instance, NULL);
if (rmdir (path) && do_destroy_files) {
logprintfl (EUCAWARN, "[%s] warning: failed to remove backing directory %s\n", instance->instanceId, path);
}
return ret;
}
void UDirectory::update()
{
if(exists(path_))
{
std::string lastName;
bool endOfDir = false;
if(iFileName_ != fileNames_.end())
{
//Record the last file name
lastName = *iFileName_;
}
else if(fileNames_.size())
{
lastName = *fileNames_.rbegin();
endOfDir = true;
}
fileNames_.clear();
#ifdef WIN32
WIN32_FIND_DATA fileInformation;
#ifdef UNICODE
wchar_t * pathAll = createWCharFromChar((path_+"\\*").c_str());
HANDLE hFile = ::FindFirstFile(pathAll, &fileInformation);
delete [] pathAll;
#else
HANDLE hFile = ::FindFirstFile((path_+"\\*").c_str(), &fileInformation);
#endif
if(hFile != INVALID_HANDLE_VALUE)
{
do
{
#ifdef UNICODE
char * fileName = createCharFromWChar(fileInformation.cFileName);
fileNames_.push_back(fileName);
delete [] fileName;
#else
fileNames_.push_back(fileInformation.cFileName);
#endif
} while(::FindNextFile(hFile, &fileInformation) == TRUE);
::FindClose(hFile);
std::vector<std::string> vFileNames = uListToVector(fileNames_);
std::sort(vFileNames.begin(), vFileNames.end(), sortCallback);
fileNames_ = uVectorToList(vFileNames);
}
#else
int nameListSize;
struct dirent ** nameList = 0;
nameListSize = scandir(path_.c_str(), &nameList, 0, sortCallback);
if(nameList && nameListSize>0)
{
for (int i=0;i<nameListSize;++i)
{
fileNames_.push_back(nameList[i]->d_name);
free(nameList[i]);
}
free(nameList);
}
#endif
//filter extensions...
std::list<std::string>::iterator iter = fileNames_.begin();
bool valid;
while(iter!=fileNames_.end())
{
valid = false;
if(extensions_.size() == 0 &&
iter->compare(".") != 0 &&
iter->compare("..") != 0)
{
valid = true;
}
for(unsigned int i=0; i<extensions_.size(); ++i)
{
if(UFile::getExtension(*iter).compare(extensions_[i]) == 0)
{
valid = true;
break;
}
}
if(!valid)
{
iter = fileNames_.erase(iter);
}
else
{
++iter;
}
}
iFileName_ = fileNames_.begin();
if(!lastName.empty())
{
bool found = false;
for(std::list<std::string>::iterator iter=fileNames_.begin(); iter!=fileNames_.end(); ++iter)
{
if(lastName.compare(*iter) == 0)
{
found = true;
iFileName_ = iter;
break;
}
}
if(endOfDir && found)
{
++iFileName_;
}
else if(endOfDir && fileNames_.size())
{
iFileName_ = --fileNames_.end();
}
}
}
}
Node::Node(string name) throw (myExceptions){
int shmid, datagramport = -1, streamport, identifier, count;
char folder[100];
struct dirent **files;
struct data *d;
myExceptions e;
if ((shmid = shmget(KEY, 200, 0666)) == -1) {
shmid = shmget(KEY, 200, 0666 | IPC_CREAT);
if ((d = (struct data*)shmat(shmid, 0, 0)) == NULL) {
perror("attach");
e.setmsg("Error in shared memory attachment");
throw e;
}
d->portlist[0][0] = 10000; d->portlist[0][1] = 1;
d->portlist[1][0] = 10002; d->portlist[1][1] = 0;
d->portlist[2][0] = 10004; d->portlist[2][1] = 0;
d->portlist[3][0] = 10006; d->portlist[3][1] = 0;
d->portlist[4][0] = 10008; d->portlist[4][1] = 0;
d->portlist[5][0] = 10010; d->portlist[5][1] = 0;
d->portlist[6][0] = 10012; d->portlist[6][1] = 0;
d->portlist[7][0] = 10014; d->portlist[7][1] = 0;
d->portlist[8][0] = 10016; d->portlist[8][1] = 0;
d->portlist[9][0] = 10018; d->portlist[9][1] = 0;
d->port = datagramport = 10000;
strcpy(d->name, (char*)name.c_str());
}
else {
if ((d = (struct data*)shmat(shmid, 0, 0)) == NULL) {
perror("attach");
e.setmsg("Error in shared memory attachment");
throw e;
}
for (int i = 0; i < 10; ++i) {
if (d->portlist[i][1] == 0) {
datagramport = d->portlist[i][0];
d->portlist[i][1] = 1;
break;
}
}
}
streamport = datagramport + 1;
identifier = dohash(datagramport);
enode = address(dohash(d->port), d->port, d->name);
node = address(identifier, datagramport, name);
datagram = Connect(DATAGRAM, datagramport);
stream = Connect(STREAM, streamport);
sprintf(folder, "/Users/Sabyasachee/%d", datagramport);
strcat(folder, "shared");
if (access(folder, F_OK) != 0) {
if (mkdir(folder, 0777) == -1) {
perror("mkdir");
e.setmsg("Error in creating directory");
throw e;
}
}
count = scandir(folder, &files, file_select, alphasort);
for (int i = 0; i < count; ++i) {
filelist.push_back(files[i]->d_name);
}
state = NEW;
shmdt(d);
}
/**
* Return number of log files in a dir and the name of the oldest file.
* @param indata, see gnolfh_in_t
* @param outdata, char *oldest_file
* @param max_outsize, Max size for oldest_file string
*
* @return int, number of logfiles or -1 if error
*/
int get_number_of_log_files_hdl(void *indata, void *outdata, size_t max_outsize)
{
struct dirent **namelist;
int n, old_date = -1, old_time = -1, old_ind = -1, files, i, failed = 0;
char path[PATH_MAX];
gnolfh_in_t *params_in;
char *oldest_file;
int rc = 0;
TRACE_ENTER();
params_in = (gnolfh_in_t *) indata;
oldest_file = (char *) outdata;
/* Initialize the filter */
n = snprintf(file_prefix, SA_MAX_NAME_LENGTH, "%s", params_in->file_name);
if (n >= SA_MAX_NAME_LENGTH) {
rc = -1;
LOG_WA("file_prefix > SA_MAX_NAME_LENGTH");
goto done_exit;
}
n = snprintf(path, PATH_MAX, "%s/%s",
params_in->logsv_root_dir, params_in->pathName);
if (n >= PATH_MAX) {
LOG_WA("path > PATH_MAX");
rc = -1;
goto done_exit;
}
files = n = scandir(path, &namelist, filter_func, alphasort);
if (n == -1 && errno == ENOENT) {
rc = 0;
goto done_exit;
}
if (n < 0) {
LOG_WA("scandir:%s - %s", strerror(errno), path);
rc = -1;
goto done_exit;
}
if (n == 0) {
rc = files;
goto done_exit;
}
while (n--) {
TRACE_3("%s", namelist[n]->d_name);
if (check_oldest(namelist[n]->d_name, params_in->file_name,
strlen(params_in->file_name), &old_date, &old_time)) {
old_ind = n;
} else {
failed++; /* wrong format */
}
}
if (old_ind != -1) {
TRACE_1("oldest: %s", namelist[old_ind]->d_name);
n = snprintf(oldest_file, max_outsize, "%s/%s",
path, namelist[old_ind]->d_name);
if (n >= max_outsize) {
LOG_WA("oldest_file > max_outsize");
rc = -1;
goto done_free;
} else {
rc = (files - failed);
}
} else {
TRACE("Only file/files with wrong format found");
}
done_free:
/* Free scandir allocated memory */
for (i = 0; i < files; i++)
free(namelist[i]);
free(namelist);
done_exit:
TRACE_LEAVE();
return rc;
}
/*----------------------------------------------------------------------------------------------------------------------*/
void DisplayFiles()
{
GtkWidget *HBox,*But,*Label;
struct dirent **NameList;
gchar LStr[LONG_TEXT_FIELD+5],DStr[LONG_TEXT_FIELD+8],FullPath[NAME_MAX+255+5];
struct stat StatBuf;
gint i,N,NRow,Row,Col;
GList *Node;
if (FileX->N) //Get rid of the existing table elements
{
Node=g_list_last(GTK_TABLE(FileX->Table)->children); //Glist is in reverse order! So this is the first element
for (i=0;i<FileX->N;++i) { gtk_widget_destroy(((GtkTableChild *)Node->data)->widget); Node=g_list_previous(Node); }
}
N=scandir(FileX->Path,&NameList,NULL,alphasort);
for (i=0,FileX->N=0;i<N;++i) //First collect the subdirectory names
{
if (FileX->N==MAX_DIR_ENTRIES) continue; //Terminate the list if there are too many entries
if (NameList[i]->d_name[0]=='.') continue; //Avoid hidden directories
sprintf(FullPath,"%s%c%s",FileX->Path,'/',NameList[i]->d_name);
stat(FullPath,&StatBuf);
if (S_ISDIR(StatBuf.st_mode)) { strcpy(FileX->Names[FileX->N],NameList[i]->d_name); ++FileX->N; }
}
for (i=0,FileX->Files=0;i<N;++i) //Now collect files names that match the file type
{
if (FileX->N==MAX_DIR_ENTRIES) continue; //Terminate the list if there are too many entries
if (NameList[i]->d_name[0]=='.') continue; //Avoid hidden files
sprintf(FullPath,"%s%c%s",FileX->Path,'/',NameList[i]->d_name);
stat(FullPath,&StatBuf);
if ( S_ISREG(StatBuf.st_mode) && FileFilter(NameList[i]->d_name,FileX->Mask) )
{ strcpy(FileX->Names[FileX->N],NameList[i]->d_name); ++FileX->N; ++FileX->Files; }
}
NRow=FileX->N/3+((FileX->N%3)>0);
gtk_table_resize(GTK_TABLE(FileX->Table),NRow,3);
for (Row=0;Row<NRow;++Row) for (Col=0;Col<3;++Col) //Populate the table to display folders and files
{
i=3*Row+Col; if (i>=FileX->N) continue;
But=gtk_button_new(); gtk_widget_set_usize(GTK_WIDGET(But),152,0);
gtk_table_attach(GTK_TABLE(FileX->Table),But,Col,Col+1,Row,Row+1,GTK_FILL,GTK_SHRINK,0,0);
gtk_signal_connect(GTK_OBJECT(But),"button_press_event",GTK_SIGNAL_FUNC(FSelect),GINT_TO_POINTER(i));
HBox=gtk_hbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(But),HBox);
sprintf(FullPath,"%s%c%s",FileX->Path,'/',FileX->Names[i]);
stat(FullPath,&StatBuf);
if (S_ISDIR(StatBuf.st_mode)) //It is a directory
{
SetStyleRecursively(But,FolderStyle);
AbbreviateFileName(LStr,FileX->Names[i],20); sprintf(DStr,"[%s]",LStr);
Label=gtk_label_new(DStr); SetStyleRecursively(Label,FolderStyle);
gtk_box_pack_start(GTK_BOX(HBox),Label,FALSE,FALSE,3);
}
else //It is a file of matching file type
{
SetStyleRecursively(But,FileStyle);
AbbreviateFileName(LStr,FileX->Names[i],20);
Label=gtk_label_new(LStr); SetStyleRecursively(Label,FileStyle);
gtk_box_pack_start(GTK_BOX(HBox),Label,FALSE,FALSE,0);
}
}
if (N>-1) free(NameList);
gtk_widget_show_all(FileX->Table);
}
static int uv__fs_readdir_filter(struct dirent* dent) {
#else
static int uv__fs_readdir_filter(const struct dirent* dent) {
#endif
return strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0;
}
/* This should have been called uv__fs_scandir(). */
static ssize_t uv__fs_readdir(uv_fs_t* req) {
struct dirent **dents;
int saved_errno;
size_t off;
size_t len;
char *buf;
int i;
int n;
n = scandir(req->path, &dents, uv__fs_readdir_filter, alphasort);
if (n == -1 || n == 0)
return n;
len = 0;
for (i = 0; i < n; i++)
len += strlen(dents[i]->d_name) + 1;
buf = malloc(len);
if (buf == NULL) {
errno = ENOMEM;
n = -1;
goto out;
}
off = 0;
for (i = 0; i < n; i++) {
len = strlen(dents[i]->d_name) + 1;
memcpy(buf + off, dents[i]->d_name, len);
off += len;
}
req->ptr = buf;
out:
saved_errno = errno;
{
for (i = 0; i < n; i++)
free(dents[i]);
free(dents);
}
errno = saved_errno;
return n;
}
static ssize_t uv__fs_readlink(uv_fs_t* req) {
ssize_t len;
char* buf;
len = pathconf(req->path, _PC_PATH_MAX);
if (len == -1) {
#if defined(PATH_MAX)
len = PATH_MAX;
#else
len = 4096;
#endif
}
buf = malloc(len + 1);
if (buf == NULL) {
errno = ENOMEM;
return -1;
}
len = readlink(req->path, buf, len);
if (len == -1) {
free(buf);
return -1;
}
buf[len] = '\0';
req->ptr = buf;
return 0;
}
int recursive_hardlink(const char *src, const char *dst, struct conf **confs)
{
int n=-1;
int ret=0;
struct dirent **dir;
char *tmp=NULL;
char *fullpatha=NULL;
char *fullpathb=NULL;
//logp("in rec hl: %s %s\n", src, dst);
if(!(tmp=prepend_s(dst, "dummy"))) return -1;
if(mkpath(&tmp, dst))
{
logp("could not mkpath for %s\n", tmp);
free_w(&tmp);
return -1;
}
free_w(&tmp);
if((n=scandir(src, &dir, 0, 0))<0)
{
logp("recursive_hardlink scandir %s: %s\n",
src, strerror(errno));
return -1;
}
while(n--)
{
struct stat statp;
if(dir[n]->d_ino==0
|| !strcmp(dir[n]->d_name, ".")
|| !strcmp(dir[n]->d_name, ".."))
{ free(dir[n]); continue; }
free_w(&fullpatha);
free_w(&fullpathb);
if(!(fullpatha=prepend_s(src, dir[n]->d_name))
|| !(fullpathb=prepend_s(dst, dir[n]->d_name)))
break;
#ifdef _DIRENT_HAVE_D_TYPE
// Faster evaluation on most systems.
if(dir[n]->d_type==DT_DIR)
{
if(recursive_hardlink(fullpatha, fullpathb, confs))
break;
}
else
#endif
// Otherwise, we have to do an lstat() anyway, because we
// will need to check the number of hardlinks in do_link().
if(lstat(fullpatha, &statp))
{
logp("could not lstat %s\n", fullpatha);
}
else if(S_ISDIR(statp.st_mode))
{
if(recursive_hardlink(fullpatha, fullpathb, confs))
break;
}
else
{
//logp("hardlinking %s to %s\n", fullpathb, fullpatha);
if(write_status(CNTR_STATUS_SHUFFLING, fullpathb,
get_cntr(confs))
|| do_link(fullpatha, fullpathb, &statp, confs,
0 /* do not overwrite target */))
break;
}
free(dir[n]);
}
if(n>0)
{
ret=-1;
for(; n>0; n--) free(dir[n]);
}
free(dir);
free_w(&fullpatha);
free_w(&fullpathb);
return ret;
}
void directory_listing(void *data,int sock)
{
struct dirent **namelist;
struct stat buf;
int i,n,ret=0,j=0,f_size=0;
char dir_req[100],list[200],l_modi_GMT[75],l_modi_GMT_2[75],*ptr,*ptr2,file_size[30];
strcpy(dir_req,data);
ptr=strstr(dir_req,"index.html");
if(ptr!=NULL)
{
while(ptr[j]!='\0')
{
ptr[j]='\0';
j++;
}
}
n = scandir(dir_req, &namelist, 0, alphasort);
if (n <= 0)
{
// perror("scandir");
send(sock, "NOT FOUND", sizeof(char)*9, 0);
}
else
{
for (i = 0; i < n; i++)
{
if((namelist[i]->d_name)[0]=='.')
continue;
memset(list,0,sizeof(char)*200);
memset(file_size,0,sizeof(char)*30);
strcpy(list,namelist[i]->d_name);
ptr2=namelist[i]->d_name;
ret = stat(ptr2, &buf); //check if file present
if(ret==0)
{
f_size=buf.st_size;
sprintf(file_size ,"%d",f_size);
printf("file_size is %s ",file_size);
strcpy(l_modi_GMT,asctime(gmtime(&(buf.st_mtime))));
strncpy(l_modi_GMT_2,l_modi_GMT,strlen(l_modi_GMT)-5);
}
strcat(list,"\t");
strcat(list,l_modi_GMT_2);
strcat(list,"\t");
strcat(list,file_size);
strcat(list,"\0");
send(sock, list, sizeof(char)*strlen(list), 0);
send(sock, "\n", sizeof(char)*1, 0);
free(namelist[i]);
}
strcpy(q2->head->status,"200");
free(namelist);
}
}
/*
Show and process a file selection dialog.
Returns path/name user selected or NULL if user canceled
input: zip_path = pointer's pointer to buffer to contain file path
within a selected zip file, or NULL if browsing zip files is disallowed.
bAllowNew: TRUE if the user is allowed to insert new file names.
*/
char* SDLGui_FileSelect(const char *path_and_name, char **zip_path, bool bAllowNew)
{
struct dirent **files = NULL;
char *pStringMem;
char *retpath;
char *home, *path, *fname; /* The actual file and path names */
bool reloaddir = TRUE; /* Do we have to reload the directory file list? */
int retbut;
int oldcursorstate;
int selection = -1; /* The actual selection, -1 if none selected */
char *zipfilename; /* Filename in zip file */
char *zipdir;
bool browsingzip = FALSE; /* Are we browsing an archive? */
zip_dir *zipfiles = NULL;
SDL_Event sdlEvent;
ypos = 0;
refreshentries = TRUE;
entries = 0;
/* Allocate memory for the file and path name strings: */
pStringMem = malloc(4 * FILENAME_MAX);
path = pStringMem;
fname = pStringMem + FILENAME_MAX;
zipdir = pStringMem + 2 * FILENAME_MAX;
zipfilename = pStringMem + 3 * FILENAME_MAX;
zipfilename[0] = 0;
fname[0] = 0;
path[0] = 0;
SDLGui_CenterDlg(fsdlg);
if (bAllowNew)
{
fsdlg[SGFSDLG_FILENAME].type = SGEDITFIELD;
fsdlg[SGFSDLG_FILENAME].flags |= SG_EXIT;
}
else
{
fsdlg[SGFSDLG_FILENAME].type = SGTEXT;
fsdlg[SGFSDLG_FILENAME].flags &= ~SG_EXIT;
}
/* Prepare the path and filename variables */
if (path_and_name && path_and_name[0])
{
strncpy(path, path_and_name, FILENAME_MAX);
path[FILENAME_MAX-1] = '\0';
}
if (!File_DirExists(path))
{
File_SplitPath(path, path, fname, NULL);
if (!(File_DirExists(path) || getcwd(path, FILENAME_MAX)))
{
perror("SDLGui_FileSelect: non-existing path and CWD failed");
return NULL;
}
}
File_MakeAbsoluteName(path);
File_MakeValidPathName(path);
File_ShrinkName(dlgpath, path, DLGPATH_SIZE);
File_ShrinkName(dlgfname, fname, DLGFNAME_SIZE);
/* Save old mouse cursor state and enable cursor */
oldcursorstate = SDL_ShowCursor(SDL_QUERY);
if (oldcursorstate == SDL_DISABLE)
SDL_ShowCursor(SDL_ENABLE);
do
{
if (reloaddir)
{
files = files_free(files);
if (browsingzip)
{
files = ZIP_GetFilesDir(zipfiles, zipdir, &entries);
}
else
{
/* Load directory entries: */
entries = scandir(path, &files, 0, alphasort);
}
/* Remove hidden files from the list if necessary: */
if (!(fsdlg[SGFSDLG_SHOWHIDDEN].state & SG_SELECTED))
{
DlgFileSelect_RemoveHiddenFiles(files);
}
if (entries < 0)
{
fprintf(stderr, "SDLGui_FileSelect: Path not found.\n");
free(pStringMem);
return NULL;
}
/* reload always implies refresh */
reloaddir = FALSE;
refreshentries = TRUE;
}/* reloaddir */
/* Update the file name strings in the dialog? */
if (refreshentries)
{
if (!DlgFileSelect_RefreshEntries(files, path, browsingzip))
{
free(pStringMem);
return NULL;
}
refreshentries = FALSE;
}
/* Show dialog: */
retbut = SDLGui_DoDialog(fsdlg, &sdlEvent);
/* Has the user clicked on a file or folder? */
if (retbut>=SGFSDLG_ENTRY1 && retbut<=SGFSDLG_ENTRY16 && retbut-SGFSDLG_ENTRY1+ypos<entries)
{
char *tempstr;
tempstr = malloc(FILENAME_MAX);
if (!tempstr)
{
perror("Error while allocating temporary memory in SDLGui_FileSelect()");
free(pStringMem);
return NULL;
}
if (browsingzip == TRUE)
{
if (!strcat_maxlen(tempstr, FILENAME_MAX,
zipdir, files[retbut-SGFSDLG_ENTRY1+ypos]->d_name))
{
fprintf(stderr, "SDLGui_FileSelect: Path name too long!\n");
free(pStringMem);
return NULL;
}
/* directory? */
if (File_DoesFileNameEndWithSlash(tempstr))
{
/* handle the ../ directory */
if (strcmp(files[retbut-SGFSDLG_ENTRY1+ypos]->d_name, "../") == 0)
{
/* close the zip file */
if (strcmp(tempstr, "../") == 0)
{
/* free zip file entries */
ZIP_FreeZipDir(zipfiles);
zipfiles = NULL;
/* Copy the path name to the dialog */
File_ShrinkName(dlgpath, path, DLGPATH_SIZE);
browsingzip = FALSE;
}
else
{
/* remove "../" and previous dir from path */
File_PathShorten(tempstr, 2);
correct_zip_root(tempstr);
strcpy(zipdir, tempstr);
File_ShrinkName(dlgpath, zipdir, DLGPATH_SIZE);
}
}
else /* not the "../" directory */
{
strcpy(zipdir, tempstr);
File_ShrinkName(dlgpath, zipdir, DLGPATH_SIZE);
}
reloaddir = TRUE;
/* Copy the path name to the dialog */
selection = -1; /* Remove old selection */
zipfilename[0] = '\0';
dlgfname[0] = 0;
ypos = 0;
}
else
{
/* not dir, select a file in the zip */
selection = retbut-SGFSDLG_ENTRY1+ypos;
strcpy(zipfilename, files[selection]->d_name);
File_ShrinkName(dlgfname, zipfilename, DLGFNAME_SIZE);
}
}
else /* not browsingzip */
{
if (!strcat_maxlen(tempstr, FILENAME_MAX,
path, files[retbut-SGFSDLG_ENTRY1+ypos]->d_name))
{
fprintf(stderr, "SDLGui_FileSelect: Path name too long!\n");
free(pStringMem);
return NULL;
}
if (File_DirExists(tempstr))
{
File_HandleDotDirs(tempstr);
File_AddSlashToEndFileName(tempstr);
/* Copy the path name to the dialog */
File_ShrinkName(dlgpath, tempstr, DLGPATH_SIZE);
strcpy(path, tempstr);
reloaddir = TRUE;
selection = -1; /* Remove old selection */
dlgfname[0] = 0;
ypos = 0;
}
else if (ZIP_FileNameIsZIP(tempstr) && zip_path != NULL)
{
/* open a zip file */
zipfiles = ZIP_GetFiles(tempstr);
if (zipfiles != NULL && browsingzip == FALSE)
{
selection = retbut-SGFSDLG_ENTRY1+ypos;
strcpy(fname, files[selection]->d_name);
File_ShrinkName(dlgfname, fname, DLGFNAME_SIZE);
browsingzip = TRUE;
zipdir[0] = '\0'; /* zip root */
File_ShrinkName(dlgpath, zipdir, DLGPATH_SIZE);
reloaddir = TRUE;
ypos = 0;
}
}
else
{
/* Select a file */
selection = retbut-SGFSDLG_ENTRY1+ypos;
strcpy(fname, files[selection]->d_name);
File_ShrinkName(dlgfname, fname, DLGFNAME_SIZE);
}
} /* not browsingzip */
free(tempstr);
}
else /* Has the user clicked on another button? */
{
switch(retbut)
{
case SGFSDLG_UPDIR: /* Change path to parent directory */
if (browsingzip)
{
/* close the zip file? */
if (!zipdir[0])
{
/* free zip file entries */
ZIP_FreeZipDir(zipfiles);
browsingzip = FALSE;
zipfiles = NULL;
File_ShrinkName(dlgpath, path, DLGPATH_SIZE);
}
else
{
/* remove last dir from zipdir path */
File_PathShorten(zipdir, 1);
correct_zip_root(zipdir);
File_ShrinkName(dlgpath, zipdir, DLGPATH_SIZE);
zipfilename[0] = '\0';
}
} /* not a zip file: */
else
{
File_PathShorten(path, 1);
File_ShrinkName(dlgpath, path, DLGPATH_SIZE);
}
reloaddir = TRUE;
break;
case SGFSDLG_HOMEDIR: /* Change to home directory */
home = getenv("HOME");
if (home == NULL)
break;
if (browsingzip)
{
/* free zip file entries */
ZIP_FreeZipDir(zipfiles);
zipfiles = NULL;
browsingzip = FALSE;
}
strcpy(path, home);
File_AddSlashToEndFileName(path);
File_ShrinkName(dlgpath, path, DLGPATH_SIZE);
reloaddir = TRUE;
break;
case SGFSDLG_ROOTDIR: /* Change to root directory */
if (browsingzip)
{
/* free zip file entries */
ZIP_FreeZipDir(zipfiles);
zipfiles = NULL;
browsingzip = FALSE;
}
path[0] = PATHSEP; path[1] = '\0';
strcpy(dlgpath, path);
reloaddir = TRUE;
break;
case SGFSDLG_UP: /* Scroll up */
DlgFileSelect_ScrollUp();
SDL_Delay(10);
break;
case SGFSDLG_DOWN: /* Scroll down */
DlgFileSelect_ScrollDown();
SDL_Delay(10);
break;
case SGFSDLG_FILENAME: /* User entered new filename */
strcpy(fname, dlgfname);
break;
case SGFSDLG_SHOWHIDDEN: /* Show/hide hidden files */
reloaddir = TRUE;
ypos = 0;
break;
case SDLGUI_UNKNOWNEVENT:
DlgFileSelect_HandleSdlEvents(&sdlEvent);
break;
} /* switch */
if (reloaddir)
{
/* Remove old selection */
selection = -1;
fname[0] = 0;
dlgfname[0] = 0;
ypos = 0;
}
} /* other button code */
} /* do */
while (retbut!=SGFSDLG_OKAY && retbut!=SGFSDLG_CANCEL
&& retbut!=SDLGUI_QUIT && retbut != SDLGUI_ERROR && !bQuitProgram);
if (oldcursorstate == SDL_DISABLE)
SDL_ShowCursor(SDL_DISABLE);
files_free(files);
if (browsingzip)
{
/* free zip file entries */
ZIP_FreeZipDir(zipfiles);
zipfiles = NULL;
}
if (retbut == SGFSDLG_OKAY)
{
if (zip_path)
*zip_path = zip_get_path(zipdir, zipfilename, browsingzip);
retpath = File_MakePath(path, fname, NULL);
}
else
retpath = NULL;
free(pStringMem);
return retpath;
}
PatchMgr::PatchMgr()
{
// load patches
#ifdef WIN32
Log.Notice("PatchMgr", "Loading Patches...");
char Buffer[MAX_PATH*10];
char Buffer2[MAX_PATH*10];
char Buffer3[MAX_PATH*10];
WIN32_FIND_DATA fd;
HANDLE fHandle;
MD5Hash md5;
Patch * pPatch;
DWORD size,sizehigh;
HANDLE hFile;
uint32 srcversion;
char locality[5];
uint32 i;
if(!GetCurrentDirectory(MAX_PATH*10, Buffer))
return;
strcpy(Buffer2,Buffer);
strcat(Buffer, "\\ClientPatches\\*.*");
fHandle = FindFirstFile(Buffer, &fd);
if(fHandle == INVALID_HANDLE_VALUE)
return;
do
{
snprintf(Buffer3,MAX_PATH*10,"%s\\ClientPatches\\%s",Buffer2,fd.cFileName);
if(sscanf(fd.cFileName,"%4s%u.", locality, &srcversion) != 2)
continue;
hFile = CreateFile(Buffer3, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_ARCHIVE, NULL);
if(hFile == INVALID_HANDLE_VALUE)
continue;
Log.Notice("PatchMgr", "Found patch for b%u locale `%s`.", srcversion,locality);
pPatch = new Patch;
size = GetFileSize(hFile, &sizehigh);
pPatch->FileSize = size;
pPatch->Data = new uint8[size];
pPatch->Version = srcversion;
for(i = 0; i < 4; ++i)
pPatch->Locality[i] = static_cast<char>(tolower(locality[i]));
pPatch->Locality[4] = 0;
pPatch->uLocality = *(uint32*)pPatch->Locality;
if(pPatch->Data== NULL)
{
// shouldn't really happen
delete pPatch;
CloseHandle(hFile);
continue;
}
// read the whole file
ASSERT(ReadFile(hFile, pPatch->Data, pPatch->FileSize, &size, NULL));
ASSERT(size == pPatch->FileSize);
// close the handle, no longer needed
CloseHandle(hFile);
// md5hash the file
md5.Initialize();
md5.UpdateData(pPatch->Data, pPatch->FileSize);
md5.Finalize();
memcpy(pPatch->MD5, md5.GetDigest(), MD5_DIGEST_LENGTH);
// add the patch to the patchlist
m_patches.push_back(pPatch);
} while(FindNextFile(fHandle,&fd));
FindClose(fHandle);
#else
/*
*nix patch loader
*/
Log.Notice("PatchMgr", "Loading Patches...");
char Buffer[MAX_PATH*10];
char Buffer2[MAX_PATH*10];
char Buffer3[MAX_PATH*10];
struct dirent ** list;
int filecount;
int read_fd;
MD5Hash md5;
Patch * pPatch;
int size;
uint32 srcversion;
char locality[5];
uint32 i;
struct stat sb;
strcpy(Buffer, "./ClientPatches");
strcpy(Buffer2,Buffer);
filecount = scandir("./ClientPatches", &list, 0, 0);
if(filecount <= 0 || list== NULL)
{
Log.Error("PatchMgr", "No patches found.");
return;
}
while(filecount--)
{
snprintf(Buffer3,MAX_PATH*10,"./ClientPatches/%s",list[filecount]->d_name);
if(sscanf(list[filecount]->d_name,"%4s%u.", locality, &srcversion) != 2)
continue;
read_fd = open(Buffer3, O_RDONLY);
if(read_fd <= 0)
{
printf("Cannot open %s\n", Buffer3);
continue;
}
if(fstat(read_fd, &sb) < 0)
{
printf("Cannot stat %s\n", Buffer3);
continue;
}
Log.Notice("PatchMgr", "Found patch for b%u locale `%s` (%u bytes).", srcversion,locality, sb.st_size);
pPatch = new Patch;
size = sb.st_size;
pPatch->FileSize = size;
pPatch->Data = new uint8[size];
pPatch->Version = srcversion;
for(i = 0; i < 4; ++i)
pPatch->Locality[i] = tolower(locality[i]);
pPatch->Locality[4] = 0;
pPatch->uLocality = *(uint32*)pPatch->Locality;
if(pPatch->Data== NULL)
{
// shouldn't really happen
delete pPatch;
close(read_fd);
continue;
}
// read the whole file
ASSERT(read(read_fd, pPatch->Data, size) == size);
// close handle
close(read_fd);
// md5hash the file
md5.Initialize();
md5.UpdateData(pPatch->Data, pPatch->FileSize);
md5.Finalize();
memcpy(pPatch->MD5, md5.GetDigest(), MD5_DIGEST_LENGTH);
// add the patch to the patchlist
m_patches.push_back(pPatch);
free(list[filecount]);
}
free(list);
#endif
}
//
// denis - BaseFileSearchDir
// Check single paths for a given file with a possible extension
// Case insensitive, but returns actual file name
//
std::string BaseFileSearchDir(std::string dir, std::string file, std::string ext, std::string hash = "")
{
std::string found;
if(dir[dir.length() - 1] != PATHSEPCHAR)
dir += PATHSEP;
std::transform(hash.begin(), hash.end(), hash.begin(), toupper);
std::string dothash = ".";
if(hash.length())
dothash += hash;
else
dothash = "";
// denis - list files in the directory of interest, case-desensitize
// then see if wanted wad is listed
#ifdef UNIX
struct dirent **namelist = 0;
int n = scandir(dir.c_str(), &namelist, 0, alphasort);
for(int i = 0; i < n && namelist[i]; i++)
{
std::string d_name = namelist[i]->d_name;
M_Free(namelist[i]);
if(!found.length())
{
if(d_name == "." || d_name == "..")
continue;
std::string tmp = d_name;
std::transform(tmp.begin(), tmp.end(), tmp.begin(), toupper);
if(file == tmp || (file + ext) == tmp || (file + dothash) == tmp || (file + ext + dothash) == tmp)
{
std::string local_file = (dir + d_name).c_str();
std::string local_hash = W_MD5(local_file.c_str());
if(!hash.length() || hash == local_hash)
{
found = d_name;
}
else if(hash.length())
{
Printf (PRINT_HIGH, "WAD at %s does not match required copy\n", local_file.c_str());
Printf (PRINT_HIGH, "Local MD5: %s\n", local_hash.c_str());
Printf (PRINT_HIGH, "Required MD5: %s\n\n", hash.c_str());
}
}
}
}
M_Free(namelist);
#else
std::string all_ext = dir + "*";
//all_ext += ext;
WIN32_FIND_DATA FindFileData;
HANDLE hFind = FindFirstFile(all_ext.c_str(), &FindFileData);
DWORD dwError = GetLastError();
if (hFind == INVALID_HANDLE_VALUE)
{
Printf (PRINT_HIGH, "FindFirstFile failed for %s\n", all_ext.c_str());
Printf (PRINT_HIGH, "GetLastError: %d\n", dwError);
return "";
}
do
{
if(FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
std::string tmp = FindFileData.cFileName;
std::transform(tmp.begin(), tmp.end(), tmp.begin(), toupper);
if(file == tmp || (file + ext) == tmp || (file + dothash) == tmp || (file + ext + dothash) == tmp)
{
std::string local_file = (dir + FindFileData.cFileName).c_str();
std::string local_hash = W_MD5(local_file.c_str());
if(!hash.length() || hash == local_hash)
{
found = FindFileData.cFileName;
break;
}
else if(hash.length())
{
Printf (PRINT_HIGH, "WAD at %s does not match required copy\n", local_file.c_str());
Printf (PRINT_HIGH, "Local MD5: %s\n", local_hash.c_str());
Printf (PRINT_HIGH, "Required MD5: %s\n\n", hash.c_str());
}
}
} while(FindNextFile(hFind, &FindFileData));
dwError = GetLastError();
// Note: As documented, FindNextFile sets ERROR_NO_MORE_FILES as the error
// code, but when this function "fails" it does not set it we have to assume
// that it completed successfully (this is actually bad practice, because
// it says in the docs that it does not set ERROR_SUCCESS, even though
// GetLastError returns 0) WTF DO WE DO?!
if(dwError != ERROR_SUCCESS && dwError != ERROR_NO_MORE_FILES)
Printf (PRINT_HIGH, "FindNextFile failed. GetLastError: %d\n", dwError);
FindClose(hFind);
#endif
return found;
}
int SDLEngine::Run(void*)
{
std::cout << "input folder: " << input_folder << std::endl;
bool gray = false;
fcount = scandir(input_folder.c_str(), &filelist, ppm_select, alphasort);
if (fcount <= 0)
{
fcount = scandir(input_folder.c_str(), &filelist, pgm_select, alphasort);
gray = true;
}
if (fcount <= 0)
{
std::cout << "There are no .ppm or .pgm files in this folder! Maybe you have to convert the images first e.g. using" << std::endl
<< " mogrify -format ppm *.jpg" << std::endl;
return 0;
}
std::cout << "found " << fcount << " files" << std::endl;
char filename[255];
sprintf(filename, "%s/init.txt", input_folder.c_str());
std::ifstream aStream(filename);
if(!aStream || aStream.eof())
{
std::cout << "please create the file \"" << filename << "\" specifying the initial bounding box (x1,y1,x2,y2)" << std::endl;
return 0;
}
char line[255];
int x1,y1,x2,y2,imgid, width,height;
std::vector<ObjectBox> boxes;
while(aStream.getline(line,255))
{
x1 = y1 = x2 = y2 = imgid = 0;
int i = 0;
for(;line[i] >= '0' && line[i] <= '9'; i++)
x1 = x1*10 + (line[i] - '0');
for(i++;line[i] >= '0' && line[i] <= '9'; i++)
y1 = y1*10 + (line[i] - '0');
for(i++;line[i] >= '0' && line[i] <= '9'; i++)
x2 = x2*10 + (line[i] - '0');
for(i++;line[i] >= '0' && line[i] <= '9'; i++)
y2 = y2*10 + (line[i] - '0');
if(line[i] == ',')
for(i++;line[i] >= '0' && line[i] <= '9'; i++)
imgid = imgid*10 + (line[i] - '0');
ObjectBox b = {(float)x1,(float)y1,(float)(x2-x1),(float)(y2-y1),imgid};
boxes.push_back(b);
}
aStream.close();
std::cout << "output folder: " << output_folder << std::endl;
DIR * dir = opendir(output_folder.c_str());
if (dir == 0)
{
std::cout << "\tdoes not exist -> try to create it" << std::endl;
if(system(("mkdir "+output_folder).c_str()))
{
std::cout << "\t failed to create directory" << std::endl;
return 0;
}
}
closedir(dir);
sprintf(filename, "%s/%s", input_folder.c_str(), filelist[0]->d_name);
int z;
unsigned char* dummy = gray ? readFromPGM<unsigned char>(filename, width, height) :
readFromPPM<unsigned char>(filename, width, height, z);
delete[] dummy;
// Initialize MultiObjectTLD
MOTLDSettings s(gray ? COLOR_MODE_GRAY : COLOR_MODE_RGB);
// s.bbMin = 18;
MultiObjectTLD p(width, height, s);
std::vector<ObjectBox> addBoxes;
std::vector<ObjectBox>::iterator boxIt = boxes.begin();
if(ivScreen != NULL)
SDL_FreeSurface(ivScreen);
ivScreen = SDL_SetVideoMode( width, height, 0, SDL_HWSURFACE | SDL_DOUBLEBUF); // | SDL_RESIZABLE
SDL_WM_SetCaption("MultiObjectTLD", 0 );
sprintf(filename, "%s/output.txt", output_folder.c_str());
std::ofstream outStream(filename);
for (int i=0; i < fcount && (!MAX_FILE_NUMBER || i<MAX_FILE_NUMBER); ++i)
{
// first load the image
sprintf(filename, "%s/%s", input_folder.c_str(), filelist[i]->d_name);
int xS, yS, z;
unsigned char* img = gray ? readFromPGM<unsigned char>(filename, xS, yS) :
readFromPPM<unsigned char>(filename, xS, yS, z);
// then process it with MultiObjectTLD
p.processFrame(img);
while(boxIt != boxes.end() && boxIt->objectId == i)
{
addBoxes.push_back(*boxIt);
boxIt++;
}
if(addBoxes.size() > 0){
p.addObjects(addBoxes);
addBoxes.clear();
}
// and save debug image to file
sprintf(filename, "%s/%s", output_folder.c_str(), filelist[i]->d_name);
p.writeDebugImage(img,filename);
displaymax = i;
// print current box to output file
if(p.getValid())
{
ObjectBox b = p.getObjectBox();
if(i > 0)
outStream << std::endl;
outStream << b.x << "," << b.y << "," << (b.x + b.width) << "," << (b.y + b.height);
}
else
outStream << std::endl << "NaN,NaN,NaN,NaN";
delete[] img;
if(ivQuit)
break;
}
outStream.close();
std::cout << "MultiObjectTLD finished!" << std::endl;
return 0;
}
static size_t write_fru(char *eeprom)
{
gint result;
const char *serial, *file;
char *ser_num, *filename;
time_t frutime;
FILE *fp = NULL;
size_t i;
time_t tmp;
struct tm *tmp2;
char buf[256];
int j, n;
struct dirent **namelist;
GtkListStore *store;
n = scandir(FRU_FILES, &namelist, 0, alphasort);
/* No fru files, don't bother */
if (n < 0) {
printf("didn't find FRU_Files in %s at %s(%s)\n", FRU_FILES, __FILE__, __func__);
return 0;
}
g_object_set(dialogs.serial_num, "secondary_text", eeprom, NULL);
filename = g_malloc(PATH_MAX);
ser_num = malloc(128);
memset(ser_num, 0, 128);
fp = fopen(".serialnum", "r");
if (fp) {
i = fread(ser_num, 1, 128, fp);
if (!ferror(fp) && (i == 128 || feof(fp)))
gtk_entry_set_text(GTK_ENTRY(serial_num), (const gchar*)&ser_num[1]);
fclose(fp);
}
store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(fru_file_list)));
gtk_list_store_clear(store);
for (j = 0; j < n; j++) {
if (namelist[j]->d_type == DT_REG && str_endswith(namelist[j]->d_name, ".bin"))
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(fru_file_list), namelist[j]->d_name);
free(namelist[j]);
}
free(namelist);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(fru_file_list), "Other...");
gtk_combo_box_set_active(GTK_COMBO_BOX(fru_file_list), ser_num[0]);
free(ser_num);
frutime = mins_since_jan_1_1996();
tmp = min2date(frutime);
tmp2 = gmtime(&tmp);
strftime(buf, sizeof(buf), "%a %b %d %H:%M %Y", tmp2);
gtk_entry_set_text(GTK_ENTRY(fru_date), buf);
get_serial_and_file:
result = gtk_dialog_run(GTK_DIALOG(dialogs.serial_num));
i = 0;
switch (result) {
case GTK_RESPONSE_OK:
serial = gtk_entry_get_text(GTK_ENTRY(serial_num));
if (strlen(serial) == 0) {
create_blocking_popup(GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"", "Serial number required");
goto get_serial_and_file;
}
file = gtk_combo_box_get_active_text(GTK_COMBO_BOX(fru_file_list));
if (strncmp(file, "Other...", 8) != 0) {
snprintf(filename, PATH_MAX, FRU_FILES "%s", file);
} else {
/* manually choose fru file */
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new("Select FRU file",
GTK_WINDOW(dialogs.serial_num),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
}
gtk_widget_destroy(dialog);
}
if (filename) {
fflush(NULL);
sprintf(buf, "fru-dump -i %s -o %s -s %s -d %d 2>&1",
filename, eeprom, serial, (unsigned int)frutime);
#if DEBUG
printf("%s\n", buf);
#else
fp = popen(buf, "r");
#endif
if (!fp) {
printf("can't execute \"%s\"\n", buf);
} else {
i = 0;
while(fgets(buf, sizeof(buf), fp) != NULL){
/* fru-dump not installed */
if (strstr(buf, "not found"))
printf("no fru-tools installed\n");
if (strstr(buf, "wrote") && strstr(buf, "bytes to") && strstr(buf, eeprom))
i = 1;
}
pclose(fp);
}
fp = fopen(".serialnum", "w");
if (fp) {
fprintf(fp, "%c%s", gtk_combo_box_get_active(GTK_COMBO_BOX(fru_file_list)), serial);
fclose(fp);
}
}
break;
case GTK_RESPONSE_DELETE_EVENT:
break;
default:
printf("unknown response %d in %s\n", result, __func__);
break;
}
gtk_widget_hide(GTK_WIDGET(dialogs.serial_num));
g_free(filename);
return i;
}
return -1;
}
int db_files_select(const struct dirent *file) {
int i;
for (i = 0; db_name[i]; i++) if (db_name[i] != file->d_name[i]) return 0;
while (1) switch (file->d_name[i]) {
case '\0': return 1;
case '0' ... '9': i++;
continue;
default: return 0;
}
}
int ret = scandir (dir, files, db_files_select, db_files_sort);
pthread_mutex_unlock(&mutex);
return ret;
}
/// Projde databázi a opraví atributy typu Pointer z id uzlů na pointery.
static void fix_pointers(Database *D, IdToNode *nodes) {
ndictFor(var, nodes) {
Node *node = var->value;
node_get_type(node)->init_pointers(nodes, node);
} ndictForEnd;
}
static int scan_sys_cache_info (void) {
long page_size = sysconf (_SC_PAGESIZE);
if (page_size <= 0) {
error (0, errno, "unable to get pagesize");
return -1;
}
/* versionsort sort by index number */
struct dirent ** list;
int nb_dir = scandir (SYSPATH, &list, scandir_filter, alphasort);
if (nb_dir < 0) {
error (0, errno, "scandir(%s)", SYSPATH);
return -1;
}
// alloc table (will set found to 0)
caches = calloc (nb_dir, sizeof (struct cache_info));
if (caches == NULL)
error (EXIT_FAILURE, errno, "calloc");
nb_cache_levels = nb_dir;
for (int i = 0; i < nb_dir; i++) {
const char * d = list[i]->d_name;
int ok;
char buf[BUF_SIZE];
struct cache_info cinfo;
// ensure type includes Data
if (read_sys_cache_file (d, "type", buf) == -1)
continue;
if (strcmp (buf, "Data") == 0)
cinfo.type = "Data";
else if (strcmp (buf, "Unified") == 0)
cinfo.type = "Unified";
else
continue;
// read size, assoc, level
if (read_sys_cache_file (d, "size", buf) == -1)
continue;
cinfo.size = str2size (buf, &ok);
if (!(ok && cinfo.size > 0))
continue;
if (read_sys_cache_file (d, "ways_of_associativity", buf) == -1)
continue;
cinfo.assoc = checked_strtoul (buf, &ok, NULL);
if (! (ok && cinfo.assoc > 0))
continue;
if (read_sys_cache_file (d, "level", buf) == -1)
continue;
int level = checked_strtoul (buf, &ok, NULL);
if (! (ok && level < nb_cache_levels))
continue;
cinfo.nb_colors = cinfo.size / (page_size * cinfo.assoc);
cinfo.found = 1;
caches[level] = cinfo;
}
return 0;
}
int GetiLOGen() {
int count = 0, k = 0;
struct dirent ** devices;
char *d_dir = "/sys/module/hpilo/drivers/pci:hpilo/";
char buffer[256];
int ilogen = 0;
count = scandir(d_dir, &devices, pci_dev_filter, alphasort );
for (k = 0; k < count; k++) {
unsigned char config[256];
int config_fd;
strncpy(buffer, d_dir, sizeof(buffer) - 1);
strncat(buffer, devices[k]->d_name, 255 - strlen(buffer));
strncat(buffer, "/config", 255 - strlen(buffer));
if ((config_fd = open(buffer, O_RDONLY)) != -1) {
if (read(config_fd, config, 256) == 256 ) {
/* Check for iLO3 and later */
if ((config[45] == 0x10) && (config[44] == 0x3c)) {
/* This is a HP iLO */
if (config[47] == 0x33) {
switch (config[46]) {
case 0x04:
/* It's an iLO */
ilogen = 0;
break;
case 0x05:
/* It's an iLO */
ilogen = 1;
break;
case 0x09:
/* It's either an iLO2 or iLO3 */
switch (config[8]) {
case 3:
ilogen = 2;
break;
case 4:
ilogen = 3;
break;
default:
ilogen = 1;
}
break;
case 0x0e:
ilogen = 3;
break;
case 0x81:
ilogen = 4;
break;
default:
ilogen = config[8] - 1;
}
}
}
}
close(config_fd);
}
free(devices[k]);
}
free(devices);
return ilogen;
}
static LIST* create_list_from_dir(char *dir) {
DIR *dir_p;
G_GAME_LIST *t;
struct dirent *dirent_p;
char filename[strlen(dir)+256];
LIST *l=NULL;
struct stat filestat;
struct DIRENT **namelist;
int nbf, i;
/*
if (dir[strlen(dir)-1]=='/')
dir[strlen(dir)-1]=0;
*/
if ((nbf = scandir(dir, &namelist, NULL/*game_selection*/, my_alphasort )) != -1) {
for (i = 0; i < nbf; i++) {
#ifdef __QNXNTO__
if (strcmp(namelist[i]->d_name, "..") == 0)
continue;
else if (strcmp(namelist[i]->d_name, ".") == 0)
continue;
else if (stricmp(namelist[i]->d_name, "romrc.d") == 0)
continue;
else if (stricmp(namelist[i]->d_name, "shots") == 0)
continue;
#endif
sprintf(filename, "%s/%s", dir, namelist[i]->d_name);
lstat(filename, &filestat);
if (S_ISDIR(filestat.st_mode))
{
t=malloc(sizeof(G_GAME_LIST));
t->dir=malloc(strlen(namelist[i]->d_name)*sizeof(char)+2);
sprintf(t->dir,"%s",namelist[i]->d_name);
t->dr=NULL;
t->file=NULL;
l=list_prepend(l,t);
}
else if (game_only==SDL_TRUE)
{
DRIVER *dr;
if ((dr=get_driver_for_zip(filename))!=NULL)
{
t=malloc(sizeof(G_GAME_LIST));
t->dir=NULL;
t->file=strdup(namelist[i]->d_name);
t->dr=dr;
l=list_prepend(l,t);
//printf("GAME %s\n",t->dr->longname);
}
}
else
{
t=malloc(sizeof(G_GAME_LIST));
t->file=strdup(namelist[i]->d_name);
t->dir=NULL;
t->dr=NULL;
l=list_prepend(l,t);
//printf("FILE %s\n",t->file);
}
}
}
if (nbf==-1) {
/* the dir is unreadable, we create pseudo dir . and .. */
t=malloc(sizeof(G_GAME_LIST));
t->dir=strdup("..");
t->dr=NULL;
t->file=NULL;
l=list_prepend(l,t);
t=malloc(sizeof(G_GAME_LIST));
t->dir=strdup(".");
t->dr=NULL;
t->file=NULL;
l=list_prepend(l,t);
}
return l;
}
int recursive_hardlink(const char *src, const char *dst, const char *client, struct cntr *p1cntr, struct cntr *cntr, struct config *conf)
{
int n=-1;
int ret=0;
struct dirent **dir;
char *tmp=NULL;
//logp("in rec hl: %s %s\n", src, dst);
if(!(tmp=prepend_s(dst, "dummy", strlen("dummy"))))
return -1;
if(mkpath(&tmp, dst))
{
logp("could not mkpath for %s\n", tmp);
free(tmp);
return -1;
}
free(tmp);
if((n=scandir(src, &dir, 0, 0))<0)
{
logp("recursive_hardlink scandir %s: %s\n",
src, strerror(errno));
return -1;
}
while(n--)
{
struct stat statp;
char *fullpatha=NULL;
char *fullpathb=NULL;
if(dir[n]->d_ino==0
|| !strcmp(dir[n]->d_name, ".")
|| !strcmp(dir[n]->d_name, ".."))
{ free(dir[n]); continue; }
if(!(fullpatha=prepend_s(src,
dir[n]->d_name, strlen(dir[n]->d_name)))
|| !(fullpathb=prepend_s(dst,
dir[n]->d_name, strlen(dir[n]->d_name))))
{
if(fullpatha) free(fullpatha);
if(fullpathb) free(fullpathb);
break;
}
if(lstat(fullpatha, &statp))
{
logp("could not lstat %s\n", fullpatha);
}
else if(S_ISDIR(statp.st_mode))
{
if(recursive_hardlink(fullpatha, fullpathb, client,
p1cntr, cntr, conf))
{
free(fullpatha);
free(fullpathb);
break;
}
}
else
{
//logp("hardlinking %s to %s\n", fullpathb, fullpatha);
write_status(client, STATUS_SHUFFLING, fullpathb,
p1cntr, cntr);
if(do_link(fullpatha, fullpathb, &statp, conf,
FALSE /* do not overwrite target */))
{
free(fullpatha);
free(fullpathb);
break;
}
}
free(fullpatha);
free(fullpathb);
free(dir[n]);
}
if(n>0)
{
ret=-1;
for(; n>0; n--) free(dir[n]);
}
free(dir);
return ret;
}
