char *
os_locate(
const char *name,
os_int32 permission)
{
char *result = NULL;
const char *fsep;
char *path;
char *fullName;
os_result osr;
std_splitList dirs;
int dirsSize;
char *curDir;
int i;
if (name) {
fsep = os_fileSep();
/* If the command contains an absolute or relative path,
* only check the permissions, otherwise search the file
* in the PATH environment */
if ((*name == '.') ||
(strncmp(name, fsep, strlen(fsep)) == 0)) {
osr = os_access(name, permission);
if (osr == os_resultSuccess) {
result = os_strdup(name);
}
} else {
/* No relative path in name, so walk over the
* whole path */
path = os_getenv(PATH_ENVVAR);
dirs = std_splitListNew(path, OS_PATHSEPCHAR);
dirsSize = std_splitListSize(dirs);
for (i=0; (i<dirsSize) && !result; i++) {
curDir = std_splitListGet(dirs, i);
fullName = (char *)os_malloc(
strlen(curDir) + strlen(fsep) + strlen(name) + 1);
if (fullName) {
os_strcpy(fullName, curDir);
os_strcat(fullName, fsep);
os_strcat(fullName, name);
/* Check file permissions. Do not have to check if file
* exists, since permission check fails when the file
* does not exist. */
osr = os_access(fullName, permission);
if (osr == os_resultSuccess) {
result = fullName;
} else {
os_free(fullName);
}
}
}
std_splitListFree(dirs);
}
}
return result;
}
int can_do_skas(void)
{
#ifdef UML_CONFIG_MODE_SKAS
struct ptrace_faultinfo fi;
void *stack;
int pid, n, ret = 1;
printf("Checking for the skas3 patch in the host...");
pid = start_ptraced_child(&stack);
n = ptrace(PTRACE_FAULTINFO, pid, 0, &fi);
if(n < 0){
if(errno == EIO)
printf("not found\n");
else printf("No (unexpected errno - %d)\n", errno);
ret = 0;
}
else printf("found\n");
init_registers(pid);
stop_ptraced_child(pid, stack, 1, 1);
printf("Checking for /proc/mm...");
if(os_access("/proc/mm", OS_ACC_W_OK) < 0){
printf("not found\n");
ret = 0;
}
else printf("found\n");
return(ret);
#else
return(0);
#endif
}
/* Checks if path is an existing directory faster than is_dir() does this at the
* cost of less accurate results (fails on non-sufficient rights).
* Automatically deferences symbolic links. Returns non-zero if path points to
* a directory, otherwise zero is returned. */
static int
is_dir_fast(const char path[])
{
#if !defined(_WIN32) && !defined(__APPLE__) && !defined(BSD)
/* Optimization idea: is_dir() ends up using stat() call, which in turn has
* to:
* 1) resolve path to an inode number;
* 2) find and load inode for the directory.
* Checking "path/." for existence is a "hack" to omit 2).
* Negative answer of this method doesn't guarantee directory absence, but
* positive answer provides correct answer faster than is_dir() would. */
const size_t len = strlen(path);
char path_to_selfref[len + 1 + 1 + 1];
strcpy(path_to_selfref, path);
path_to_selfref[len] = '/';
path_to_selfref[len + 1] = '.';
path_to_selfref[len + 2] = '\0';
return os_access(path_to_selfref, F_OK) == 0;
#else
/* Some systems report that "/path/to/file/." is directory... */
return 0;
#endif
}
/* OS_IRAFPATH -- Portable version of the kernel irafpath() function, used
* if only the standard directories LIB and HLIB need to be searched.
*/
char *
os_irafpath (
char *sysfile /* filename from include statement */
)
{
register char *ip, *op;
register int n;
static char outfname[SZ_PATHNAME+1];
char fname[SZ_PATHNAME+1];
int i;
strcpy (outfname, sysfile);
for (i=0; libs[i][0] != EOS; i++) {
strcpy (fname, libs[i]);
strcat (fname, sysfile);
if (os_access (fname, 0,0) == YES) {
n = SZ_PATHNAME;
for (ip=fname, op=outfname; --n >= 0 && (*op = *ip++); op++)
;
*op = EOS;
break;
}
}
return (outfname);
}
/* Checks whether path/file exists. If path is NULL, filename is assumed to
* contain full path. */
static int
path_exists_internal(const char path[], const char filename[], int deref)
{
char full[PATH_MAX];
if(path == NULL)
{
copy_str(full, sizeof(full), filename);
}
else
{
snprintf(full, sizeof(full), "%s/%s", path, filename);
}
/* At least on Windows extra trailing slash can mess up the check, so get rid
* of it. */
if(!is_root_dir(full))
{
chosp(full);
}
if(!deref)
{
struct stat st;
return os_lstat(full, &st) == 0;
}
return os_access(full, F_OK) == 0;
}
/*
* util_file_exists -- checks whether file exists
*/
int
util_file_exists(const char *path)
{
LOG(3, "path \"%s\"", path);
if (os_access(path, F_OK) == 0)
return 1;
if (errno != ENOENT) {
ERR("!os_access \"%s\"", path);
return -1;
}
/*
* ENOENT means that some component of a pathname does not exists.
*
* XXX - we should also call os_access on parent directory and
* if this also results in ENOENT -1 should be returned.
*
* The problem is that we would need to use realpath, which fails
* if file does not exist.
*/
return 0;
}
/*
* backup_nonpoolset_requirements -- (internal) check backup requirements
*/
static int
backup_nonpoolset_requirements(PMEMpoolcheck *ppc, location *loc)
{
LOG(3, "backup_path %s", ppc->backup_path);
if (os_access(ppc->backup_path, F_OK)) {
if (errno == ENOENT) {
errno = 0;
return 0;
} else {
return CHECK_ERR(ppc,
"unable to access the backup destination: %s",
ppc->backup_path);
}
}
if ((size_t)util_file_get_size(ppc->backup_path) !=
ppc->pool->set_file->size) {
ppc->result = CHECK_RESULT_ERROR;
return CHECK_ERR(ppc,
"destination of the backup does not match the size of the source pool file: %s",
ppc->backup_path);
}
if (CHECK_WITHOUT_FIXING(ppc)) {
location_release(loc);
loc->step = CHECK_STEP_COMPLETE;
return 0;
}
CHECK_ASK(ppc, Q_OVERWRITE_EXISTING_FILE,
"destination of the backup already exists.|Do you want to overwrite it?");
return check_questions_sequence_validate(ppc);
}
/*
* do_added_parts_exist -- (internal) check if any part of the replicas that are
* to be added (marked as broken) already exists
*/
static int
do_added_parts_exist(struct pool_set *set,
struct poolset_health_status *set_hs)
{
for (unsigned r = 0; r < set->nreplicas; ++r) {
/* skip unbroken (i.e. not being added) replicas */
if (!replica_is_replica_broken(r, set_hs))
continue;
struct pool_replica *rep = REP(set, r);
/* skip remote replicas */
if (rep->remote)
continue;
for (unsigned p = 0; p < rep->nparts; ++p) {
/* check if part file exists */
int oerrno = errno;
if (os_access(rep->part[p].path, F_OK) == 0 &&
!rep->part[p].is_dev_dax) {
LOG(1, "part file %s exists",
rep->part[p].path);
return 1;
}
errno = oerrno;
}
}
return 0;
}
/*
* ut_access -- an access that cannot return -1
*/
int
ut_access(const char *file, int line, const char *func, const char *path,
int mode)
{
int retval = os_access(path, mode);
if (retval != 0)
ut_fatal(file, line, func, "!access: %s: %d", path, mode);
return retval;
}
/* Opens file specified by its path on the given line number. */
static void
open_selected_file(const char path[], int line_num)
{
if(os_access(path, R_OK) == 0)
{
(void)vim_view_file(path, line_num, -1, 1);
}
else
{
show_error_msgf("Can't read file", "File \"%s\" is not readable", path);
}
}
/* Returns non-zero if file can be executed, otherwise zero is returned. */
static int
is_executable(const char full_path[], const dir_entry_t *curr, int dont_execute,
int runnable)
{
int executable;
#ifndef _WIN32
executable = curr->type == FT_EXEC ||
(runnable && os_access(full_path, X_OK) == 0 && S_ISEXE(curr->mode));
#else
executable = curr->type == FT_EXEC;
#endif
return executable && !dont_execute && cfg.auto_execute;
}
static void
test_open_in_different_process(int argc, char **argv, int sleep)
{
pid_t pid = fork();
PMEMobjpool *pop;
char *path = argv[1];
if (pid < 0)
UT_FATAL("fork failed");
if (pid == 0) {
/* child */
if (sleep)
usleep(sleep);
while (os_access(path, R_OK))
usleep(100 * 1000);
pop = pmemobj_open(path, LAYOUT);
if (pop)
UT_FATAL("pmemobj_open after fork should not succeed");
if (errno != EWOULDBLOCK)
UT_FATAL("!pmemobj_open after fork failed but for "
"unexpected reason");
exit(0);
}
pop = pmemobj_create(path, LAYOUT, PMEMOBJ_MIN_POOL,
S_IWUSR | S_IRUSR);
if (!pop)
UT_FATAL("!create");
int status;
if (waitpid(pid, &status, 0) < 0)
UT_FATAL("!waitpid failed");
if (!WIFEXITED(status))
UT_FATAL("child process failed");
pmemobj_close(pop);
UNLINK(path);
}
/*
* check_and_open_poolset_part_files -- (internal) for each part in a poolset
* check if the part files are accessible, and if not, mark it as broken
* in a helping structure; then open the part file
*/
static int
check_and_open_poolset_part_files(struct pool_set *set,
struct poolset_health_status *set_hs, unsigned flags)
{
LOG(3, "set %p, set_hs %p, flags %u", set, set_hs, flags);
for (unsigned r = 0; r < set->nreplicas; ++r) {
struct pool_replica *rep = set->replica[r];
struct replica_health_status *rep_hs = set_hs->replica[r];
if (rep->remote) {
if (util_replica_open_remote(set, r, 0)) {
LOG(1, "cannot open remote replica no %u", r);
return -1;
}
unsigned nlanes = REMOTE_NLANES;
int ret = util_poolset_remote_open(rep, r,
rep->repsize, 0,
rep->part[0].addr,
rep->resvsize, &nlanes);
if (ret)
rep_hs->flags |= IS_BROKEN;
continue;
}
for (unsigned p = 0; p < rep->nparts; ++p) {
if (os_access(rep->part[p].path, R_OK|W_OK) != 0) {
LOG(1, "part file %s is not accessible",
rep->part[p].path);
errno = 0;
rep_hs->part[p] |= IS_BROKEN;
if (is_dry_run(flags))
continue;
}
if (util_part_open(&rep->part[p], 0, 0)) {
LOG(1, "opening part %s failed",
rep->part[p].path);
errno = 0;
rep_hs->part[p] |= IS_BROKEN;
}
}
}
return 0;
}
/* OS_SYSFILE -- Return the pathname of a system library file. The library
* search order is
*
* IRAFULIB libraries, if any
* HSI system libraries (lib, hlib, hbin, etc.)
* pkglibs applications libraries, if any
*
* Hence, the IRAFULIB mechanism may be used to make use of custom copies
* of system files (libraries or global include files), whereas the `pkglibs'
* mechanism is provided to extend the system library search path to include
* applications specified libraries. These are intended to be the global
* libraries of installed layered packages, rather than private user libraries
* (the IRAFULIB mechanism is better for the latter).
*/
int
os_sysfile (
char *sysfile, /* filename from include statement */
char *fname, /* receives filename */
int maxch
)
{
register char *ip, *op;
char *files, *ip_save;
/* Search the standard system libraries and exit if the named
* file is found.
*/
strncpy (fname, irafpath(sysfile), maxch);
fname[maxch-1] = EOS;
if (strcmp (fname, sysfile) != 0)
return (strlen (fname));
/* Search the designated package libraries, if any.
*/
if ( (files = os_getenv ("pkglibs")) ) {
for (ip=files; *ip; ) {
/* Get the next library name from the list. */
while (isspace(*ip) || *ip == ',')
ip++;
for (op=fname; *ip && !isspace(*ip) && *ip != ','; op++)
*op = *ip++;
*op = EOS;
/* Append the target filename. */
for (ip_save=ip, (ip=sysfile); (*op++ = *ip++); )
;
ip = ip_save;
/* Exit if the file exists. */
if (os_access (fname, 0, 0))
return (strlen (fname));
}
}
return (ERR);
}
void
write_info_file(void)
{
char info_file[PATH_MAX];
char tmp_file[PATH_MAX];
(void)snprintf(info_file, sizeof(info_file), "%s/vifminfo", cfg.config_dir);
(void)snprintf(tmp_file, sizeof(tmp_file), "%s_%u", info_file, get_pid());
if(os_access(info_file, R_OK) != 0 || copy_file(info_file, tmp_file) == 0)
{
update_info_file(tmp_file);
if(rename_file(tmp_file, info_file) != 0)
{
LOG_ERROR_MSG("Can't replace vifminfo file with its temporary copy");
(void)remove(tmp_file);
}
}
}
static void Expose(menuFrameWork_t *self)
{
time_t now = time(NULL);
struct tm *tm = localtime(&now);
if (tm) {
m_demos.year = tm->tm_year;
}
// check that target directory exists
if (strcmp(m_demos.browse, "/")
&& ui_listalldemos->integer == 0
&& os_access(va("%s%s", fs_gamedir, m_demos.browse), F_OK)) {
strcpy(m_demos.browse, "/");
}
BuildList();
// move cursor to previous position
MenuList_SetValue(&m_demos.list, m_demos.selection);
}
/* Checks whether path/file exists. If path is NULL, filename is assumed to
* contain full path. */
static int
path_exists_internal(const char path[], const char filename[], int deref)
{
const char *path_to_check;
char full[PATH_MAX];
if(path == NULL)
{
path_to_check = filename;
}
else
{
snprintf(full, sizeof(full), "%s/%s", path, filename);
path_to_check = full;
}
if(!deref)
{
struct stat st;
return os_lstat(path_to_check, &st) == 0;
}
return os_access(path_to_check, F_OK) == 0;
}
/*
* pool_set_part_copy -- make a copy of the poolset part
*/
int
pool_set_part_copy(struct pool_set_part *dpart, struct pool_set_part *spart,
int overwrite)
{
LOG(3, "dpart %p spart %p", dpart, spart);
int result = 0;
os_stat_t stat_buf;
if (os_fstat(spart->fd, &stat_buf)) {
ERR("!util_stat");
return -1;
}
size_t smapped = 0;
void *saddr = pmem_map_file(spart->path, 0, 0, S_IREAD, &smapped, NULL);
if (!saddr)
return -1;
size_t dmapped = 0;
int is_pmem;
void *daddr;
if (!os_access(dpart->path, F_OK)) {
if (!overwrite) {
errno = EEXIST;
result = -1;
goto out_sunmap;
}
daddr = pmem_map_file(dpart->path, 0, 0, S_IWRITE, &dmapped,
&is_pmem);
} else {
if (errno == ENOENT) {
errno = 0;
daddr = pmem_map_file(dpart->path, dpart->filesize,
PMEM_FILE_CREATE | PMEM_FILE_EXCL,
stat_buf.st_mode, &dmapped, &is_pmem);
} else {
result = -1;
goto out_sunmap;
}
}
if (!daddr) {
result = -1;
goto out_sunmap;
}
ASSERT(dmapped >= smapped);
if (is_pmem) {
pmem_memcpy_persist(daddr, saddr, smapped);
} else {
memcpy(daddr, saddr, smapped);
pmem_msync(daddr, smapped);
}
pmem_unmap(daddr, dmapped);
out_sunmap:
pmem_unmap(saddr, smapped);
return result;
}
/*
* pool_copy -- make a copy of the pool
*/
int
pool_copy(struct pool_data *pool, const char *dst_path, int overwrite)
{
struct pool_set_file *file = pool->set_file;
int dfd;
if (!os_access(dst_path, F_OK)) {
if (!overwrite) {
errno = EEXIST;
return -1;
}
dfd = util_file_open(dst_path, NULL, 0, O_RDWR);
} else {
if (errno == ENOENT) {
errno = 0;
dfd = util_file_create(dst_path, file->size, 0);
} else {
return -1;
}
}
if (dfd < 0)
return -1;
int result = 0;
os_stat_t stat_buf;
if (os_stat(file->fname, &stat_buf)) {
result = -1;
goto out_close;
}
if (fchmod(dfd, stat_buf.st_mode)) {
result = -1;
goto out_close;
}
void *daddr = mmap(NULL, file->size, PROT_READ | PROT_WRITE,
MAP_SHARED, dfd, 0);
if (daddr == MAP_FAILED) {
result = -1;
goto out_close;
}
if (pool->params.type != POOL_TYPE_BTT) {
void *saddr = pool_set_file_map(file, 0);
memcpy(daddr, saddr, file->size);
goto out_unmap;
}
void *buf = malloc(RW_BUFFERING_SIZE);
if (buf == NULL) {
ERR("!malloc");
result = -1;
goto out_unmap;
}
if (pool_btt_lseek(pool, 0, SEEK_SET) == -1) {
result = -1;
goto out_free;
}
ssize_t buf_read = 0;
void *dst = daddr;
while ((buf_read = pool_btt_read(pool, buf, RW_BUFFERING_SIZE))) {
if (buf_read == -1)
break;
memcpy(dst, buf, (size_t)buf_read);
dst = (void *)((ssize_t)dst + buf_read);
}
out_free:
free(buf);
out_unmap:
munmap(daddr, file->size);
out_close:
(void) os_close(dfd);
return result;
}
/* fileOpen callback
return idl_explore to state that the rest of the file needs to be processed
*/
static idl_action
idl_fileOpen (
idl_scope scope,
const char *name,
void *userData)
{
idl_tmplExp te;
c_char tmplFileName [1024];
c_char *tmplPath;
c_char *orbPath = NULL;
int tmplFile;
struct os_stat_s tmplStat;
unsigned int nRead;
os_char* tmpName;
os_uint32 i;
OS_UNUSED_ARG(scope);
OS_UNUSED_ARG(userData);
tmplPath = os_getenv ("OSPL_TMPL_PATH");
if (tmplPath == NULL) {
printf ("OSPL_TMPL_PATH not defined\n");
return (idl_abort);
}
/* Prepare file header template */
if (idl_getLanguage() == IDL_LANG_LITE_CXX) {
snprintf(tmplFileName, sizeof(tmplFileName), "%s%cliteCxxMainInclude", tmplPath, OS_FILESEPCHAR);
} else {
orbPath = os_getenv ("OSPL_ORB_PATH");
if (orbPath == NULL) {
printf ("OSPL_ORB_PATH not defined\n");
return (idl_abort);
}
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ccorbaCxxMainInclude", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR);
}
/* QAC EXPECT 3416; No unexpected side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
return (idl_abort);
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_macroSet = idl_macroSetNew();
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("basename", name));
if(clientheader != NULL)
{
tmpName = os_strdup(name);
for(i = 0; i < strlen(tmpName); i++)
{
tmpName[i] = (os_char) toupper (tmpName[i]);
}
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("basename_upper", tmpName));
os_free(tmpName);
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("clientheaderdefine", "#define CCPP_USE_CUSTOM_SUFFIX_"));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("clientheaderundef", "#undef CCPP_USE_CUSTOM_SUFFIX_"));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("clientheader", clientheader));
} else
{
/* dds2071: Define some default macro values.. for the client header .h
* was chosen as an arbitrary default
*/
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("basename_upper", ""));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("clientheaderdefine", ""));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("clientheaderundef", ""));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("clientheader", ".h"));
}
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
return idl_abort;
}
os_int32
ut_dirOutNew(
const os_char *name)
{
os_int32 result;
os_result status;
char dirName[OS_PATH_MAX];
struct os_stat statBuf;
os_uint32 i;
memset(dirName, 0, OS_PATH_MAX);
if (name) {
result = 1;
for (i = 0; i < strlen(name) && result; i++) {
if ((name[i] == OS_FILESEPCHAR) && (i != 0)) {
status = os_stat(dirName, &statBuf);
if (status != os_resultSuccess) {
os_mkdir(dirName, S_IRWXU | S_IRWXG | S_IRWXO);
status = os_stat(dirName, &statBuf);
}
if (!OS_ISDIR (statBuf.stat_mode)) {
#ifdef WIN32
if ((strlen(dirName) == 2) && (dirName[1] == ':')) {
/*This is a device like for instance: 'C:'*/
} else {
printf("'%s' is not a directory\n", dirName);
result = 0;
ut_outputdir = NULL;
}
#else
printf("'%s' is not a directory\n", dirName);
result = 0;
ut_outputdir = NULL;
#endif
}
}
dirName[i] = name[i];
}
if (result) {
if (dirName[i-1] != OS_FILESEPCHAR) {
status = os_stat(dirName, &statBuf);
if (status != os_resultSuccess) {
os_mkdir(dirName, S_IRWXU | S_IRWXG | S_IRWXO);
status = os_stat(dirName, &statBuf);
}
ut_outputdir = os_strdup(name);
if (!OS_ISDIR(statBuf.stat_mode)) {
#ifdef WIN32
if ((strlen(dirName) == 2) && (dirName[1] == ':')) {
/*This is a device like for instance: 'C:'. Check if it exists...*/
dirName[2] = OS_FILESEPCHAR;
status = os_stat(dirName, &statBuf);
if (status == os_resultFail) {
printf("'%s' is not available", dirName);
result = 0;
ut_outputdir = NULL;
}
} else {
printf("'%s' is not a directory.\n", ut_outputdir);
result = 0;
ut_outputdir = NULL;
}
#else
printf("'%s' is not a directory\n", dirName);
result = 0;
ut_outputdir = NULL;
#endif
}
} else {
ut_outputdir = (os_char *)os_malloc(strlen(name)+1);
snprintf(ut_outputdir, strlen(name), "%s", name);
}
}
} else {
result = 0;
ut_outputdir = NULL;
}
if (result) {
status = os_access(ut_outputdir, 2); /* Check whether dir is writable */
if (status != os_resultSuccess) {
#ifdef WIN32
if ((strlen(dirName) == 2) && (dirName[1] == ':')) {
/*This is a device like for instance: 'C:'. Check if it exists...*/
dirName[2] = OS_FILESEPCHAR;
status = os_stat(dirName, &statBuf);
if (status == os_resultFail) {
printf("'%s' cannot be found", dirName);
result = 0;
ut_outputdir = NULL;
}
} else {
printf("Specified output directory '%s' is not writable.\n", ut_outputdir);
result = 0;
ut_outputdir = NULL;
}
#else
printf("Specified output directory '%s' is not writable.\n", ut_outputdir);
result = 0;
ut_outputdir = NULL;
#endif
}
}
return result;
}
/** \brief Figure out the identity of the current process
*
* os_procFigureIdentity determines the numeric, and if possible named
* identity of a process. It will first check if the environment variable
* SPLICE_PROCNAME is set (which is always the case if the process is started
* via os_procCreate). If so, that value will be returned. Otherwise it will be
* attempted to determine the commandline which started the process through the
* procfs. If that fails, the PID will be returned.
*
* \param procIdentity Pointer to a char-buffer to which the result can be
* written. If a name could be resolved, the result will
* have the format "name <PID>". Otherwise it will just
* be "<PID>".
* \param procIdentitySize Size of the buffer pointed to by procIdentitySize
* \return same as snprintf returns
*/
os_int32
os_procFigureIdentity(
char *procIdentity,
os_uint32 procIdentitySize)
{
os_int32 size = 0;
char *process_name;
size_t r = 0;
int missingBytes = 0;
process_name = os_getenv("SPLICE_PROCNAME");
if (process_name != NULL) {
size = snprintf(procIdentity, procIdentitySize, "%s <%d>",
process_name, os_procIdToInteger(os_procIdSelf()));
} else {
char *procPath;
procPath = (char*) os_malloc(_OS_PROCESS_DEFAULT_CMDLINE_LEN_);
if (procPath) {
size = snprintf(procPath, _OS_PROCESS_DEFAULT_CMDLINE_LEN_,
_OS_PROCESS_PROCFS_PATH_FMT_, os_procIdToInteger(os_procIdSelf()));
if (size >= _OS_PROCESS_DEFAULT_CMDLINE_LEN_) { /* pid is apparently longer */
char *tmp = (char*) os_realloc(procPath, size + 1);
if (tmp) {
procPath = tmp;
size = snprintf(procPath, size + 1, _OS_PROCESS_PROCFS_PATH_FMT_,
os_procIdToInteger(os_procIdSelf()));
} else {
/* Memory-claim failed, revert to default (just pid) */
size = 0;
}
}
/* procPath is set */
if (size > 0) {
if (os_access(procPath, OS_ROK) == os_resultSuccess) {
FILE *proc = fopen(procPath, "r");
if (proc) {
do {
r += fread((void*)&procIdentity[r], 1L, procIdentitySize-r,proc);
} while( ferror(proc) && errno == EINTR );
/* Only count characters till the first null */
r = os_strnlen( procIdentity, r );
if ( r == procIdentitySize )
{
char altbuffer[16];
int usefullRead;
/* Buffer is full null terminate it */
procIdentity[r-1] = '\0';
/* There may be more bytes - count them*/
do {
int p=0;
do {
p += fread((void*)&altbuffer, 1L,
sizeof(altbuffer)-p,proc);
} while( ferror(proc) && errno == EINTR );
usefullRead=os_strnlen(&altbuffer[0], sizeof(altbuffer));
missingBytes+=usefullRead;
} while ( usefullRead == sizeof(altbuffer) );
/* Account for space before pid */
missingBytes++;
}
else if ( r > 1 ) {
/* Add a space before the pid */
procIdentity[r++] = ' ';
}
fclose(proc);
}
}
}
os_free(procPath);
}
size = snprintf(&procIdentity[r], procIdentitySize-r,
"<%d>", os_procIdToInteger(os_procIdSelf()));
size = size+r+missingBytes;
}
return size;
}
static int
idl_genTypeSeqHolder(
idl_scope scope,
const char *name,
idl_typeSpec typeSpec)
{
idl_tmplExp te;
c_char tmplFileName[1024];
c_char pname[1024];
c_char *tmplPath;
c_char *orbPath;
int tmplFile;
struct os_stat_s tmplStat;
unsigned int nRead;
tmplPath = os_getenv("OSPL_TMPL_PATH");
orbPath = os_getenv("OSPL_ORB_PATH");
if (tmplPath == NULL) {
printf("OSPL_TMPL_PATH not defined\n");
return -1;
}
if (orbPath == NULL) {
printf("OSPL_ORB_PATH not defined\n");
return -1;
}
idlpp_macroSet = idl_macroSetNew();
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("type-name", idl_javaId(name)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("actual-type-name", idl_typeSpecName(typeSpec)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scoped-type-name", idl_scopeStackJava(scope, ".", name)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scoped-actual-type-name", idl_corbaJavaTypeFromTypeSpec(typeSpec)));
snprintf(pname, sizeof (pname), "%sSeqHolder", idl_javaId(name));
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
return -1;
}
/* Prepare typeSupport class */
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ctmplSeqHolder.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf("No template found or protection violation (%s)\n", tmplFileName);
return -1;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
return 0;
}
/*
* backup_poolset_requirements -- (internal) check backup requirements
*/
static int
backup_poolset_requirements(PMEMpoolcheck *ppc, location *loc)
{
LOG(3, "backup_path %s", ppc->backup_path);
if (ppc->pool->set_file->poolset->nreplicas > 1) {
CHECK_INFO(ppc,
"backup of a poolset with multiple replicas is not supported");
goto err;
}
if (pool_set_parse(&loc->set, ppc->backup_path)) {
CHECK_INFO(ppc, "invalid poolset backup file: %s",
ppc->backup_path);
goto err;
}
if (loc->set->nreplicas > 1) {
CHECK_INFO(ppc,
"backup to a poolset with multiple replicas is not supported");
goto err_poolset;
}
ASSERTeq(loc->set->nreplicas, 1);
struct pool_replica *srep = ppc->pool->set_file->poolset->replica[0];
struct pool_replica *drep = loc->set->replica[0];
if (srep->nparts != drep->nparts) {
CHECK_INFO(ppc,
"number of part files in the backup poolset must match number of part files in the source poolset");
goto err_poolset;
}
int overwrite_required = 0;
for (unsigned p = 0; p < srep->nparts; p++) {
if (srep->part[p].filesize != drep->part[p].filesize) {
CHECK_INFO(ppc,
"size of the part %u of the backup poolset does not match source poolset",
p);
goto err_poolset;
}
if (os_access(drep->part[p].path, F_OK)) {
if (errno == ENOENT) {
errno = 0;
continue;
} else {
CHECK_INFO(ppc,
"unable to access the part of the destination poolset: %s",
ppc->backup_path);
goto err_poolset;
}
}
overwrite_required = true;
if ((size_t)util_file_get_size(drep->part[p].path) !=
srep->part[p].filesize) {
CHECK_INFO(ppc,
"destination of the backup part does not match size of the source part file: %s",
drep->part[p].path);
goto err_poolset;
}
}
if (CHECK_WITHOUT_FIXING(ppc)) {
location_release(loc);
loc->step = CHECK_STEP_COMPLETE;
return 0;
}
if (overwrite_required) {
CHECK_ASK(ppc, Q_OVERWRITE_EXISTING_PARTS,
"part files of the destination poolset of the backup already exist.|"
"Do you want to overwrite them?");
}
return check_questions_sequence_validate(ppc);
err_poolset:
location_release(loc);
err:
ppc->result = CHECK_RESULT_ERROR;
return CHECK_ERR(ppc, "unable to backup poolset");
}
static idl_action
idl_fileOpen(
idl_scope scope,
const char *name,
void *userData)
{
idl_tmplExp te;
c_char tmplFileName[1024];
c_char *tmplPath;
c_char *orbPath;
int tmplFile;
struct os_stat_s tmplStat;
unsigned int nRead;
OS_UNUSED_ARG(scope);
OS_UNUSED_ARG(userData);
tmplPath = os_getenv("OSPL_TMPL_PATH");
orbPath = os_getenv("OSPL_ORB_PATH");
if (tmplPath == NULL) {
printf ("OSPL_TMPL_PATH not defined\n");
return (idl_abort);
}
if (orbPath == NULL) {
printf ("OSPL_ORB_PATH not defined\n");
return (idl_abort);
}
/* Prepare file header template */
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ccorbaCxxStreamsClassSpecHeader", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
return (idl_abort);
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_macroSet = idl_macroSetNew();
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
/* Expand file header */
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("basename", name));
/* set dll stuff */
idl_macroSetAdd(idlpp_macroSet,
idl_macroNew(IDL_DLL_TMPLMACRO_MACRO_NAME, idl_dllGetMacro()));
idl_macroSetAdd(idlpp_macroSet,
idl_macroNew(IDL_DLL_TMPLMACRO_HEADER_NAME, idl_dllGetHeader()));
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
/* Prepare class definition template */
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ccorbaCxxStreamsClassSpec", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
return (idl_abort);
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_indent_level = 0;
return idl_explore;
/* QAC EXPECT 2006; overview does not get better with one exit */
}
static int
os_createLogDir (const char *name)
{
int result;
os_result status;
char dirName[OS_PATH_MAX];
struct os_stat statBuf;
unsigned long i;
memset(dirName, 0, OS_PATH_MAX);
result = 0;
if(name)
{
result = 1;
for(i=0; name[i] != '\0' && result; i++)
{
if((name[i] == OS_FILESEPCHAR) && (i != 0))
{
status = os_stat(dirName, &statBuf);
if (status != os_resultSuccess)
{
os_mkdir(dirName, S_IRWXU | S_IRWXG | S_IRWXO);
status = os_stat(dirName, &statBuf);
}
if (status != os_resultSuccess || !OS_ISDIR (statBuf.stat_mode))
{
#ifdef WIN32
if((strlen(dirName) == 2) && (dirName[1] == ':'))
{
/*This is a device like for instance: 'C:'*/
}
else
{
result = 0;
}
#else
result = 0;
#endif
}
}
dirName[i] = name[i];
}
if(result)
{
if(dirName[i-1] != OS_FILESEPCHAR)
{
status = os_stat(dirName, &statBuf);
if (status != os_resultSuccess)
{
os_mkdir(dirName, S_IRWXU | S_IRWXG | S_IRWXO);
status = os_stat(dirName, &statBuf);
}
if (status != os_resultSuccess || !OS_ISDIR (statBuf.stat_mode))
{
#ifdef WIN32
if((strlen(dirName) == 2) && (dirName[1] == ':'))
{
/*This is a device like for instance: 'C:'. Check if it exists...*/
dirName[2] = OS_FILESEPCHAR;
status = os_stat(dirName, &statBuf);
if(status == os_resultFail)
{
result = 0;
}
}
else
{
result = 0;
}
#else
result = 0;
#endif
}
}
}
}
else
{
result = 0;
}
/* os_access write access check fails for kernel mode vxworks 6.8 and 6.9
* even for writeable directories.
*/
#if !( defined (VXWORKS_68) || defined (VXWORKS_69) ) || !defined (_WRS_KERNEL)
if(result)
{
status = os_access(name, 2); /*Check whether dir is writable*/
if(status != os_resultSuccess)
{
#ifdef WIN32
if((strlen(dirName) == 2) && (dirName[1] == ':'))
{
/*This is a device like for instance: 'C:'. Check if it exists...*/
dirName[2] = OS_FILESEPCHAR;
status = os_stat(dirName, &statBuf);
if(status == os_resultFail)
{
result = 0;
}
}
else
{
result = 0;
}
#else
result = 0;
#endif
}
}
#endif
return result;
}
static int
idl_genInterface(
idl_scope scope,
const char *name,
char *class_base,
idl_typeSpec typeSpec,
c_bool generateInterfaceClass)
{
idl_tmplExp te;
c_char tmplFileName[1024];
c_char pname[1024];
c_char *tmplPath;
c_char *orbPath;
int tmplFile;
struct os_stat_s tmplStat;
unsigned int nRead;
os_char *redirects;
char *scopedMetaTypeName;
const char *internalTypeName;
const char *keyList;
char *scopeStackJavaDot = idl_scopeStackJava(scope, ".", name);
char *scopeStackJavaSlash = idl_scopeStackJava(scope, "/", name);
char *typeSpecName = idl_typeSpecName(typeSpec);
char *javaId = idl_javaId(name);
int result = 0;
tmplPath = os_getenv("OSPL_TMPL_PATH");
orbPath = os_getenv("OSPL_ORB_PATH");
if (tmplPath == NULL) {
printf("OSPL_TMPL_PATH not defined\n");
result = -1;
goto err_exit;
}
if (orbPath == NULL) {
printf("OSPL_ORB_PATH not defined\n");
result = -1;
goto err_exit;
}
idlpp_macroSet = idl_macroSetNew();
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("type-name", javaId));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("actual-type-name", typeSpecName));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scoped-type-name", scopeStackJavaDot));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("java-class-name", scopeStackJavaSlash));
redirects = idl_packageRedirects ();
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("java-package-redirects", redirects));
os_free(redirects);
scopedMetaTypeName = idl_scopeStack(scope, "::", name);
internalTypeName = idl_internalTypeNameForBuiltinTopic(scopedMetaTypeName);
keyList = idl_keyResolve(idl_keyDefDefGet(), scope, name);
if ((strlen(internalTypeName) != 0) &&
((keyList == NULL) ||
(strcmp(keyList,"key") == 0))) {
keyList = "key.localId,key.systemId";
}
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scoped-meta-type-name", scopedMetaTypeName));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("internal-type-name", internalTypeName));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scoped-actual-type-name", idl_corbaJavaTypeFromTypeSpec(typeSpec)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("key-list", keyList));
os_free(scopedMetaTypeName);
/* Generate only in standalone mode */
if (idl_getCorbaMode() == IDL_MODE_STANDALONE) {
snprintf(pname, sizeof (pname), "%s%s", javaId, class_base);
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
result = -1;
goto err_exit;
}
/* Prepare Interface class */
if (generateInterfaceClass) {
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ctmpl%s.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
result = -1;
goto err_exit;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
os_free(idlpp_template);
}
idl_closeJavaPackage();
snprintf(pname, sizeof(pname), "%s%sHolder", javaId, class_base);
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
result = -1;
goto err_exit;
}
/* Prepare typeSupportHolder class */
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ctmpl%sHolder.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
result = -1;
goto err_exit;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
os_free(idlpp_template);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
snprintf(pname, sizeof(pname), "%s%sHelper", javaId, class_base);
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
result = -1;
goto err_exit;
}
/* Prepare typeSupportHelper class */
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ctmpl%sHelper.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
result = -1;
goto err_exit;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
os_free(idlpp_template);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
snprintf(pname, sizeof(pname), "%s%sOperations", javaId, class_base);
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
result = idl_abort;
goto err_exit;
}
/* Prepare typeSupportOperations class */
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ctmpl%sOperations.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
result = -1;
goto err_exit;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
os_free(idlpp_template);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
}
if (generateInterfaceClass) {
/* Implementation with Impl extension */
snprintf(pname, sizeof(pname), "%s%sImpl", javaId, class_base);
} else {
/* Implementation without Impl extension */
snprintf(pname, sizeof(pname), "%s%s", javaId, class_base);
}
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
result = -1;
goto err_exit;
}
/* Prepare typeSupportStub class */
snprintf(tmplFileName, sizeof(tmplFileName), "%s%c%s%ctmpl%sImpl.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf("No template found or protection violation (%s)\n", tmplFileName);
result = idl_abort;
goto err_exit;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc(tmplStat.stat_size+1);
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, tmplStat.stat_size+1-nRead);
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
os_free(idlpp_template);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
err_exit:
os_free(javaId);
os_free(scopeStackJavaDot);
os_free(scopeStackJavaSlash);
return result;
}
static int
idl_genInterface(
idl_scope scope,
const char *name,
char *class_base,
idl_typeSpec typeSpec,
c_bool generateInterfaceClass)
{
idl_tmplExp te;
c_char tmplFileName[1024];
c_char pname[1024];
c_char *tmplPath;
c_char *orbPath;
int tmplFile;
struct os_stat tmplStat;
unsigned int nRead;
tmplPath = os_getenv("OSPL_TMPL_PATH");
orbPath = os_getenv("OSPL_ORB_PATH");
if (tmplPath == NULL) {
printf("OSPL_TMPL_PATH not defined\n");
return -1;
}
if (orbPath == NULL) {
printf("OSPL_ORB_PATH not defined\n");
return -1;
}
idlpp_macroSet = idl_macroSetNew();
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("type-name", idl_javaId(name)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("actual-type-name", idl_typeSpecName(typeSpec)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scoped-type-name", idl_scopeStackJava(scope, ".", name)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("java-class-name", idl_scopeStackJava(scope, "/", name)));
if(idl_genJavaHelperGetOrgPName())
{
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("java-org-package-name", idl_genJavaHelperGetOrgPName()));
} else
{
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("java-org-package-name", "null"));
}
if(idl_genJavaHelperGetTgtPName())
{
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("java-tgt-package-name", idl_genJavaHelperGetTgtPName()));
} else
{
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("java-tgt-package-name", "null"));
}
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scoped-meta-type-name", idl_scopeStack(scope, "::", name)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scoped-actual-type-name", idl_corbaJavaTypeFromTypeSpec(typeSpec)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("key-list", idl_keyResolve(idl_keyDefDefGet(), scope, name)));
snprintf(pname, sizeof (pname), "%s%s", idl_javaId(name), class_base);
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
return -1;
}
if (idl_scopeStackSize(scope) > 0) {
idl_fileOutPrintf(idl_fileCur(), "package %s;\n", idl_scopeStackJava (scope, ".", NULL));
idl_fileOutPrintf(idl_fileCur(), "\n");
}
/* Prepare Interface class */
if (generateInterfaceClass) {
snprintf(tmplFileName, (size_t)sizeof(tmplFileName), "%s%c%s%ctmpl%s.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
return -1;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc((size_t)((int)tmplStat.stat_size+1));
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, (size_t)tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, (size_t)((int)tmplStat.stat_size+1-nRead));
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
}
idl_closeJavaPackage();
snprintf(pname, sizeof(pname), "%s%sHolder", idl_javaId(name), class_base);
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
return -1;
}
if (idl_scopeStackSize(scope) > 0) {
idl_fileOutPrintf(idl_fileCur(), "package %s;\n", idl_scopeStackJava(scope, ".", NULL));
idl_fileOutPrintf(idl_fileCur(), "\n");
}
/* Prepare typeSupportHolder class */
snprintf(tmplFileName, (size_t)sizeof(tmplFileName), "%s%c%s%ctmpl%sHolder.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
return -1;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc((size_t)((int)tmplStat.stat_size+1));
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, (size_t)tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, (size_t)((int)tmplStat.stat_size+1-nRead));
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
snprintf(pname, sizeof(pname), "%s%sHelper", idl_javaId(name), class_base);
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
return -1;
}
if (idl_scopeStackSize(scope) > 0) {
idl_fileOutPrintf(idl_fileCur(), "package %s;\n", idl_scopeStackJava(scope, ".", NULL));
idl_fileOutPrintf(idl_fileCur(), "\n");
}
/* Prepare typeSupportHelper class */
snprintf(tmplFileName, (size_t)sizeof(tmplFileName), "%s%c%s%ctmpl%sHelper.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
return -1;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc((size_t)((int)tmplStat.stat_size+1));
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, (size_t)tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, (size_t)((int)tmplStat.stat_size+1-nRead));
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
snprintf(pname, sizeof(pname), "%s%sOperations", idl_javaId(name), class_base);
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
return (idl_abort);
}
if (idl_scopeStackSize(scope) > 0) {
idl_fileOutPrintf(idl_fileCur(), "package %s;\n", idl_scopeStackJava(scope, ".", NULL));
idl_fileOutPrintf(idl_fileCur(), "\n");
}
/* Prepare typeSupportOperations class */
snprintf(tmplFileName, (size_t)sizeof(tmplFileName), "%s%c%s%ctmpl%sOperations.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf ("No template found or protection violation (%s)\n", tmplFileName);
return -1;
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc((size_t)((int)tmplStat.stat_size+1));
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, (size_t)tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, (size_t)((int)tmplStat.stat_size+1-nRead));
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
if (generateInterfaceClass) {
/* Implementation with Impl extension */
snprintf(pname, sizeof(pname), "%s%sImpl", idl_javaId(name), class_base);
} else {
/* Implementation without Impl extension */
snprintf(pname, sizeof(pname), "%s%s", idl_javaId(name), class_base);
}
idl_openJavaPackage(scope, pname);
if (idl_fileCur() == NULL) {
return -1;
}
if (idl_scopeStackSize(scope) > 0) {
idl_fileOutPrintf(idl_fileCur(), "package %s;\n", idl_scopeStackJava(scope, ".", NULL));
idl_fileOutPrintf(idl_fileCur(), "\n");
}
/* Prepare typeSupportStub class */
snprintf(tmplFileName, (size_t)sizeof(tmplFileName), "%s%c%s%ctmpl%sImpl.java", tmplPath, OS_FILESEPCHAR, orbPath, OS_FILESEPCHAR, class_base);
/* QAC EXPECT 3416; No side effects here */
if ((os_stat(tmplFileName, &tmplStat) != os_resultSuccess) ||
(os_access(tmplFileName, OS_ROK) != os_resultSuccess)) {
printf("No template found or protection violation (%s)\n", tmplFileName);
return (idl_abort);
}
/* QAC EXPECT 5007; will not use wrapper */
idlpp_template = os_malloc((size_t)((int)tmplStat.stat_size+1));
tmplFile = open(tmplFileName, O_RDONLY);
nRead = (unsigned int)read(tmplFile, idlpp_template, (size_t)tmplStat.stat_size);
memset(&idlpp_template[nRead], 0, (size_t)((int)tmplStat.stat_size+1-nRead));
close(tmplFile);
idlpp_macroAttrib = idl_macroAttribNew(IDL_TOKEN_START, IDL_TOKEN_OPEN, IDL_TOKEN_CLOSE);
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
te = idl_tmplExpNew(idlpp_macroSet);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
idl_closeJavaPackage();
return 0;
}
