/* \brief helper function for importers.
* helps finding texture files.
* maybe we could have a _default_ texture for missing files? */
char* _glhckImportTexturePath(const char* odd_texture_path, const char* model_path)
{
char *textureFile, *modelFolder, *modelPath;
char textureInModelFolder[2048];
CALL(0, "%s, %s", odd_texture_path, model_path);
/* these are must to check */
if (!odd_texture_path || !odd_texture_path[0])
goto fail;
/* lets try first if it contains real path to the texture */
textureFile = (char*)odd_texture_path;
/* guess not, lets try basename it */
if (access(textureFile, F_OK) != 0)
textureFile = gnu_basename((char*)odd_texture_path);
else {
RET(0, "%s", textureFile);
return _glhckStrdup(textureFile);
}
/* hrmm, we could not even basename it?
* I think we have a invalid path here Watson! */
if (!textureFile)
goto fail; /* Sherlock, you are a genius */
/* these are must to check */
if (!model_path || !model_path[0])
goto fail;
/* copy original path */
if (!(modelPath = _glhckStrdup(model_path)))
goto fail;
/* grab the folder where model resides */
modelFolder = dirname(modelPath);
/* ok, maybe the texture is in same folder as the model? */
snprintf(textureInModelFolder, sizeof(textureInModelFolder)-1, "%s/%s", modelFolder, textureFile);
/* free this */
_glhckFree(modelPath);
/* gah, don't give me missing textures damnit!! */
if (access(textureInModelFolder, F_OK) != 0)
goto fail;
/* return, remember to free */
RET(0, "%s", textureInModelFolder);
return _glhckStrdup(textureInModelFolder);
fail:
RET(0, "%p", NULL);
return NULL;
}
static char *srcline_from_fileline(const char *file, unsigned int line)
{
char *srcline;
if (!file)
return NULL;
if (!srcline_full_filename)
file = gnu_basename(file);
if (asprintf(&srcline, "%s:%u", file, line) < 0)
return NULL;
return srcline;
}
// Treat pattern as a shell glob pattern and blacklist matching files
static void globbing(OPERATION op, const char *pattern, const char *noblacklist[], size_t noblacklist_len) {
assert(pattern);
glob_t globbuf;
// Profiles contain blacklists for files that might not exist on a user's machine.
// GLOB_NOCHECK makes that okay.
int globerr = glob(pattern, GLOB_NOCHECK | GLOB_NOSORT, NULL, &globbuf);
if (globerr) {
fprintf(stderr, "Error: failed to glob pattern %s\n", pattern);
exit(1);
}
size_t i, j;
for (i = 0; i < globbuf.gl_pathc; i++) {
char *path = globbuf.gl_pathv[i];
assert(path);
// /home/me/.* can glob to /home/me/.. which would blacklist /home/
const char *base = gnu_basename(path);
if (strcmp(base, ".") == 0 || strcmp(base, "..") == 0)
continue;
// noblacklist is expected to be short in normal cases, so stupid and correct brute force is okay
bool okay_to_blacklist = true;
for (j = 0; j < noblacklist_len; j++) {
int result = fnmatch(noblacklist[j], path, FNM_PATHNAME);
if (result == FNM_NOMATCH)
continue;
else if (result == 0) {
okay_to_blacklist = false;
break;
}
else {
fprintf(stderr, "Error: failed to compare path %s with pattern %s\n", path, noblacklist[j]);
exit(1);
}
}
if (okay_to_blacklist)
disable_file(op, path);
else if (arg_debug)
printf("Not blacklist %s\n", path);
}
globfree(&globbuf);
}
void profile_read(const char *fname) {
EUID_ASSERT();
// exit program if maximum include level was reached
if (include_level > MAX_INCLUDE_LEVEL) {
fprintf(stderr, "Error: maximum profile include level was reached\n");
exit(1);
}
// check file
invalid_filename(fname);
if (strlen(fname) == 0 || is_dir(fname)) {
fprintf(stderr, "Error: invalid profile file\n");
exit(1);
}
if (access(fname, R_OK)) {
// if the file ends in ".local", do not exit
const char *base = gnu_basename(fname);
char *ptr = strstr(base, ".local");
if (ptr && strlen(ptr) == 6)
return;
fprintf(stderr, "Error: cannot access profile file\n");
exit(1);
}
// allow debuggers
if (arg_allow_debuggers) {
char *tmp = strrchr(fname, '/');
if (tmp && *(tmp + 1) != '\0') {
tmp++;
if (strcmp(tmp, "disable-devel.inc") == 0)
return;
}
}
// open profile file:
FILE *fp = fopen(fname, "r");
if (fp == NULL) {
fprintf(stderr, "Error: cannot open profile file %s\n", fname);
exit(1);
}
int msg_printed = 0;
// read the file line by line
char buf[MAX_READ + 1];
int lineno = 0;
while (fgets(buf, MAX_READ, fp)) {
++lineno;
// remove empty space - ptr in allocated memory
char *ptr = line_remove_spaces(buf);
if (ptr == NULL)
continue;
// comments
if (*ptr == '#' || *ptr == '\0') {
free(ptr);
continue;
}
// process quiet
if (strcmp(ptr, "quiet") == 0) {
arg_quiet = 1;
free(ptr);
continue;
}
if (!msg_printed) {
if (!arg_quiet)
fprintf(stderr, "Reading profile %s\n", fname);
msg_printed = 1;
}
// process include
if (strncmp(ptr, "include ", 8) == 0) {
include_level++;
// extract profile filename and new skip params
char *newprofile = ptr + 8; // profile name
// expand ${HOME}/ in front of the new profile file
char *newprofile2 = expand_home(newprofile, cfg.homedir);
// recursivity
profile_read((newprofile2)? newprofile2:newprofile);
include_level--;
if (newprofile2)
free(newprofile2);
free(ptr);
continue;
}
// verify syntax, exit in case of error
if (profile_check_line(ptr, lineno, fname))
profile_add(ptr);
// we cannot free ptr here, data is extracted from ptr and linked as a pointer in cfg structure
// else {
// free(ptr);
// }
#ifdef HAVE_GCOV
__gcov_flush();
#endif
}
fclose(fp);
}
int
main (int argc, char **argv)
{
struct ev_loop *loop;
struct timeval tv[2];
char dirname[10];
char *shmdata;
int rundir, rundirs[NUM_PROCS], sharedir;
int pagesize;
int i, j;
// use the default event loop unless you have special needs
loop = ev_default_loop (EVBACKEND_EPOLL); //EVFLAG_AUTO);
rundir = get_rundir();
pagesize = getpagesize();
// Prepare shared data directory
if ((mkdirat(rundir, SHARE_DIR_NAME, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) != 0) {
fprintf(stderr, "could not make share directory: %s\n", strerror(errno));
return -1;
}
if ((sharedir = openat(rundir, SHARE_DIR_NAME, O_DIRECTORY)) < 0) {
fprintf(stderr, "could not open share directory: %s\n", strerror(errno));
return -1;
}
// Prepare worker rundirs
for (i=0; i<NUM_PROCS; ++i) {
sprintf(dirname, "%d", i);
if ((mkdirat(rundir, dirname, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)) != 0) {
fprintf(stderr, "worker %d: could not make runtime directory: %s\n", i, strerror(errno));
return -1;
}
if ((rundirs[i] = openat(rundir, dirname, O_DIRECTORY)) < 0) {
fprintf(stderr, "worker %d: could not open runtime directory: %s\n", i, strerror(errno));
return -1;
}
if ((mkfifoat(rundirs[i], "inputfile", S_IRUSR | S_IWUSR)) != 0) {
fprintf(stderr, "%s: could not create FIFO: %s\n", "inputfile", strerror(errno));
}
}
// Memory map some data;
for (j=0; j<NUM_SHMS; ++j) {
// Maybe just use ids for shared SHM names
shms[j] = openat(sharedir, "dbfile", O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
ftruncate(shms[j], pagesize);
shmdata = mmap((caddr_t)0, pagesize, PROT_WRITE, MAP_SHARED, shms[j], 0);
strcpy(shmdata, "Very important DB data.");
// Now "share" it
for (i=0; i<NUM_PROCS; ++i) {
linkat(sharedir, "dbfile", rundirs[i], "dbfile", 0);
}
}
//ev_set_timeout_collect_interval (loop, 0.0001);
//ev_set_io_collect_interval (loop, 0.0001);
// Start children
for (i=0; i<NUM_PROCS; ++i) {
pid_t pid = fork();
if (pid == 0) {
// Child
fchdir(rundirs[i]);
if (execle(argv[1], gnu_basename(argv[1]), "outputfile", "dbfile", "inputfile", NULL, NULL)) {
fputs("Could not exec: ", stderr);
fputs(strerror(errno), stderr);
fputc('\n', stderr);
exit(EXIT_FAILURE);
}
}
else if (pid > 0) {
// Parent
}
}
// Initialize watchers
for (i=0; i<NUM_PROCS; ++i) {
ev_io *wio = &input_watcher[i];
fifos[i] = openat(rundirs[i], "inputfile", O_WRONLY);
wio->data = (void*)i;
ev_io_init(wio, input_cb, fifos[i], EV_WRITE);
ev_io_start(loop, wio);
}
ev_child *wchld = &child_watcher;
ev_child_init(wchld, child_cb, 0, 1);
ev_child_start(loop, wchld);
// now wait for events to arrive
gettimeofday(tv+0, NULL);
ev_loop (loop, 0);
gettimeofday(tv+1, NULL);
// unloop was called, so exit
long t = (tv[1].tv_sec - tv[0].tv_sec) * 1000000
+ (tv[1].tv_usec - tv[0].tv_usec);
printf("\nTime taken: %lfs (%lfms average)\n\n",
((double)t) / 1000000.0,
((double)t) * NUM_PROCS / NUM_JOBS);
// Hang up
/*
puts("Closing pipes...");
for (i=0; i<NUM_PROCS; ++i) {
close(fifos[i]);
}
*/
puts("Waiting for children processes to terminate...");
pid_t pid;
do {
pid = wait(NULL);
if(pid == -1 && errno != ECHILD) {
perror("Error during wait()");
abort();
}
} while (pid > 0);
// Cleanup shms
puts("Cleaning SHMs...");
for (j=0; j<NUM_SHMS; ++j) {
ftruncate(shms[j], 0);
close(shms[i]);
}
// Finally...
puts("Done.");
return 0;
}
