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; }