/*
* rm_local -- (internal) remove single local file
*/
static int
rm_local(const char *path, int flags, int is_part_file)
{
int ret = util_unlink_flock(path);
if (!ret) {
LOG(3, "%s: removed", path);
return 0;
}
int oerrno = errno;
os_stat_t buff;
ret = os_stat(path, &buff);
if (!ret) {
if (S_ISDIR(buff.st_mode)) {
errno = EISDIR;
if (is_part_file)
ERR("%s: removing file failed", path);
else
ERR("removing file failed");
return -1;
}
}
errno = oerrno;
if (is_part_file)
ERR_F(flags, "%s: removing file failed", path);
else
ERR_F(flags, "removing file failed");
if (CHECK_FLAG(flags, FORCE))
return 0;
return -1;
}
/*
* util_file_get_type -- checks whether the path points to a device dax,
* normal file or non-existent file
*/
enum file_type
util_file_get_type(const char *path)
{
LOG(3, "path \"%s\"", path);
if (path == NULL) {
ERR("invalid (NULL) path");
errno = EINVAL;
return OTHER_ERROR;
}
int exists = util_file_exists(path);
if (exists < 0)
return OTHER_ERROR;
if (!exists)
return NOT_EXISTS;
#ifdef _WIN32
return TYPE_NORMAL;
#else
os_stat_t st;
if (os_stat(path, &st) < 0) {
ERR("!stat");
return OTHER_ERROR;
}
return util_stat_get_type(&st);
#endif
}
/// Get the file information for a given path
///
/// @param file_descriptor File descriptor of the file.
/// @param[out] file_info Pointer to a FileInfo to put the information in.
/// @return `true` on success, `false` for failure.
bool os_get_file_info(const char *path, FileInfo *file_info)
{
if (os_stat((char_u *)path, &(file_info->stat)) == OK) {
return true;
}
return false;
}
/// Check what `name` is:
/// @return NODE_NORMAL: file or directory (or doesn't exist)
/// NODE_WRITABLE: writable device, socket, fifo, etc.
/// NODE_OTHER: non-writable things
int os_nodetype(const char *name)
{
#ifdef WIN32
// Edge case from Vim os_win32.c:
// We can't open a file with a name "\\.\con" or "\\.\prn", trying to read
// from it later will cause Vim to hang. Thus return NODE_WRITABLE here.
if (STRNCMP(name, "\\\\.\\", 4) == 0) {
return NODE_WRITABLE;
}
#endif
uv_stat_t statbuf;
if (0 != os_stat(name, &statbuf)) {
return NODE_NORMAL; // File doesn't exist.
}
#ifndef WIN32
// libuv does not handle BLK and DIR in uv_handle_type.
// Related: https://github.com/joyent/libuv/pull/1421
if (S_ISREG(statbuf.st_mode) || S_ISDIR(statbuf.st_mode)) {
return NODE_NORMAL;
}
if (S_ISBLK(statbuf.st_mode)) { // block device isn't writable
return NODE_OTHER;
}
#endif
// Vim os_win32.c:mch_nodetype does this (since patch 7.4.015):
// if (enc_codepage >= 0 && (int)GetACP() != enc_codepage) {
// wn = enc_to_utf16(name, NULL);
// hFile = CreatFile(wn, ...)
// to get a HANDLE. But libuv just calls win32's _get_osfhandle() on the fd we
// give it. uv_fs_open calls fs__capture_path which does a similar dance and
// saves us the hassle.
int nodetype = NODE_WRITABLE;
int fd = os_open(name, O_RDONLY, 0);
switch(uv_guess_handle(fd)) {
case UV_TTY: // FILE_TYPE_CHAR
nodetype = NODE_WRITABLE;
break;
case UV_FILE: // FILE_TYPE_DISK
nodetype = NODE_NORMAL;
break;
case UV_NAMED_PIPE: // not handled explicitly in Vim os_win32.c
case UV_UDP: // unix only
case UV_TCP: // unix only
case UV_UNKNOWN_HANDLE:
default:
#ifdef WIN32
nodetype = NODE_NORMAL;
#else
nodetype = NODE_WRITABLE; // Everything else is writable?
#endif
break;
}
close(fd);
return nodetype;
}
static time_t get_modified_timestamp(const char *filename)
{
struct stat stats;
if (os_stat(filename, &stats) != 0)
return -1;
return stats.st_mtime;
}
/*
* device_dax_size -- (internal) checks the size of a given dax device
*/
static ssize_t
device_dax_size(const char *path)
{
LOG(3, "path \"%s\"", path);
os_stat_t st;
int olderrno;
if (os_stat(path, &st) < 0) {
ERR("!stat \"%s\"", path);
return -1;
}
char spath[PATH_MAX];
snprintf(spath, PATH_MAX, "/sys/dev/char/%u:%u/size",
os_major(st.st_rdev), os_minor(st.st_rdev));
LOG(4, "device size path \"%s\"", spath);
int fd = os_open(spath, O_RDONLY);
if (fd < 0) {
ERR("!open \"%s\"", spath);
return -1;
}
ssize_t size = -1;
char sizebuf[MAX_SIZE_LENGTH + 1];
ssize_t nread;
if ((nread = read(fd, sizebuf, MAX_SIZE_LENGTH)) < 0) {
ERR("!read");
goto out;
}
sizebuf[nread] = 0; /* null termination */
char *endptr;
olderrno = errno;
errno = 0;
size = strtoll(sizebuf, &endptr, 0);
if (endptr == sizebuf || *endptr != '\n' ||
((size == LLONG_MAX || size == LLONG_MIN) && errno == ERANGE)) {
ERR("invalid device size %s", sizebuf);
size = -1;
goto out;
}
errno = olderrno;
out:
olderrno = errno;
(void) os_close(fd);
errno = olderrno;
LOG(4, "device size %zu", size);
return size;
}
/*
* pool_set_file_open -- (internal) opens pool set file or regular file
*/
static struct pool_set_file *
pool_set_file_open(const char *fname, struct pool_params *params, int rdonly)
{
LOG(3, NULL);
struct pool_set_file *file = calloc(1, sizeof(*file));
if (!file)
return NULL;
file->fname = strdup(fname);
if (!file->fname)
goto err;
const char *path = file->fname;
if (params->type != POOL_TYPE_BTT) {
int ret = util_poolset_create_set(&file->poolset, path,
0, 0, true);
if (ret < 0) {
LOG(2, "cannot open pool set -- '%s'", path);
goto err_free_fname;
}
unsigned flags = (rdonly ? POOL_OPEN_COW : 0) |
POOL_OPEN_IGNORE_BAD_BLOCKS;
if (util_pool_open_nocheck(file->poolset, flags))
goto err_free_fname;
file->size = file->poolset->poolsize;
/* get modification time from the first part of first replica */
path = file->poolset->replica[0]->part[0].path;
file->addr = file->poolset->replica[0]->part[0].addr;
} else {
int oflag = rdonly ? O_RDONLY : O_RDWR;
file->fd = util_file_open(fname, NULL, 0, oflag);
file->size = params->size;
}
os_stat_t buf;
if (os_stat(path, &buf)) {
ERR("%s", path);
goto err_close_poolset;
}
file->mtime = buf.st_mtime;
file->mode = buf.st_mode;
return file;
err_close_poolset:
if (params->type != POOL_TYPE_BTT)
util_poolset_close(file->poolset, DO_NOT_DELETE_PARTS);
else if (file->fd != -1)
os_close(file->fd);
err_free_fname:
free(file->fname);
err:
free(file);
return NULL;
}
bool os_file_exists(const char_u *name)
{
uv_stat_t statbuf;
if (os_stat(name, &statbuf) == OK) {
return true;
}
return false;
}
int32_t os_getperm(const char_u *name)
{
uv_stat_t statbuf;
if (os_stat(name, &statbuf) == FAIL) {
return -1;
} else {
return (int32_t)statbuf.st_mode;
}
}
/// Get the size of a file in bytes.
///
/// @param[out] size pointer to an off_t to put the size into.
/// @return `true` for success, `false` for failure.
bool os_get_file_size(const char *name, off_t *size)
{
uv_stat_t statbuf;
if (os_stat(name, &statbuf)) {
*size = statbuf.st_size;
return true;
}
return false;
}
int fstat(int fd, struct stat *st)
{
int rc;
FILE* file = support_retrieve_file( fd );
if ( file == NULL ) return -1;
if ( os_stat( file->data, st, &rc ) == NOTIMPLEMENTED )
os_freakout();
return rc;
}
/**
* check to see if a file exists
*
* @param path path of file to test
* @returns 1 if file exists, 0 otherwise
*/
int scan_xml_is_file(char *path) {
struct stat sb;
if(os_stat(path,&sb))
return 0;
if(sb.st_mode & S_IFREG)
return 1;
return 0;
}
time_t get_modified_timestamp(char *filename)
{
struct stat stats;
// stat is apparently terrifying and horrible, but we only call it once
// every second at most.
if (os_stat(filename, &stats) != 0)
return -1;
return stats.st_mtime;
}
/** \brief Return true if memory mapped file related
* to the handle exists
*/
os_boolean
os_mmfFileExist (
os_mmfHandle mmfHandle)
{
struct os_stat stat;
assert (mmfHandle != NULL);
assert (mmfHandle->filename != NULL);
if (os_stat(mmfHandle->filename, &stat) == os_resultSuccess) {
return OS_ISREG(stat.stat_mode);
}
return OS_FALSE;
}
/*
* os_dimm_files_namespace_badblocks -- fake os_dimm_files_namespace_badblocks()
*/
int
os_dimm_files_namespace_badblocks(const char *path, struct badblocks *bbs)
{
LOG(3, "path %s", path);
os_stat_t st;
if (os_stat(path, &st)) {
ERR("!stat %s", path);
return -1;
}
return 0;
}
/*
* os_auto_flush -- check if platform supports auto flush for all regions
*
* Traverse "/sys/bus/nd/devices" path to find all the nvdimm regions,
* then for each region checks if "persistence_domain" file exists and
* contains "cpu_cache" string.
* If for any region "persistence_domain" entry does not exists, or its
* context is not as expected, assume eADR is not available on this platform.
*/
int
os_auto_flush(void)
{
LOG(15, NULL);
char *device_path;
int cpu_cache = 0;
device_path = BUS_DEVICE_PATH;
os_stat_t sdev;
if (os_stat(device_path, &sdev) != 0 ||
S_ISDIR(sdev.st_mode) == 0) {
LOG(3, "eADR not supported");
return cpu_cache;
}
struct fs *dev = fs_new(device_path);
if (dev == NULL) {
ERR("!fs_new: \"%s\"", device_path);
return -1;
}
struct fs_entry *dev_entry;
while ((dev_entry = fs_read(dev)) != NULL) {
/*
* Skip if not a symlink, because we expect that
* region on sysfs path is a symlink.
* Skip if depth is different than 1, bacause region
* we are interested in should be the first level
* child for device.
*/
if ((dev_entry->type != FS_ENTRY_SYMLINK) ||
!strstr(dev_entry->name, "region") ||
dev_entry->level != 1)
continue;
LOG(15, "Start traversing region: %s", dev_entry->path);
cpu_cache = check_domain_in_region(dev_entry->path);
if (cpu_cache != 1)
goto end;
}
end:
fs_delete(dev);
return cpu_cache;
}
/*
* grant_created_parts_perm -- (internal) set RW permission rights to all
* the parts created in place of the broken ones
*/
static int
grant_created_parts_perm(struct pool_set *set, unsigned src_repn,
struct poolset_health_status *set_hs)
{
LOG(3, "set %p, src_repn %u, set_hs %p", set, src_repn, set_hs);
/* choose the default permissions */
mode_t def_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
/* get permissions of the first part of the source replica */
mode_t src_mode;
os_stat_t sb;
if (os_stat(PART(REP(set, src_repn), 0).path, &sb) != 0) {
ERR("cannot check file permissions of %s (replica %u, part %u)",
PART(REP(set, src_repn), 0).path, src_repn, 0);
src_mode = def_mode;
} else {
src_mode = sb.st_mode;
}
/* set permissions to all recreated parts */
for (unsigned r = 0; r < set_hs->nreplicas; ++r) {
/* skip unbroken replicas */
if (!replica_is_replica_broken(r, set_hs))
continue;
if (set->replica[r]->remote)
continue;
for (unsigned p = 0; p < set_hs->replica[r]->nparts; p++) {
/* skip parts which were not created */
if (!PART(REP(set, r), p).created)
continue;
LOG(4, "setting permissions for part %u, replica %u",
p, r);
/* set rights to those of existing part files */
if (os_chmod(PART(REP(set, r), p).path, src_mode)) {
ERR("cannot set permission rights for created"
" parts: replica %u, part %u", r, p);
errno = EPERM;
return -1;
}
}
}
return 0;
}
/*
* ut_stat -- a stat that cannot return -1
*/
int
ut_stat(const char *file, int line, const char *func, const char *path,
os_stat_t *st_bufp)
{
int retval = os_stat(path, st_bufp);
if (retval < 0)
ut_fatal(file, line, func, "!stat: %s", path);
#ifdef _WIN32
/* clear unused bits to avoid confusion */
st_bufp->st_mode &= 0600;
#endif
return retval;
}
/*
* replica_check_local_part_dir -- check if directory for the part file
* exists
*/
int
replica_check_local_part_dir(struct pool_set *set, unsigned repn,
unsigned partn)
{
LOG(3, "set %p, repn %u, partn %u", set, repn, partn);
char *path = Strdup(PART(REP(set, repn), partn).path);
const char *dir = dirname(path);
os_stat_t sb;
if (os_stat(dir, &sb) != 0 || !(sb.st_mode & S_IFDIR)) {
ERR("directory %s for part %u in replica %u"
" does not exist or is not accessible",
path, partn, repn);
Free(path);
return -1;
}
Free(path);
return 0;
}
/*
* util_file_get_size -- returns size of a file
*/
ssize_t
util_file_get_size(const char *path)
{
LOG(3, "path \"%s\"", path);
int file_type = util_file_get_type(path);
if (file_type < 0)
return -1;
#ifndef _WIN32
if (file_type == TYPE_DEVDAX) {
return device_dax_size(path);
}
#endif
os_stat_t stbuf;
if (os_stat(path, &stbuf) < 0) {
ERR("!stat \"%s\"", path);
return -1;
}
LOG(4, "file length %zu", stbuf.st_size);
return stbuf.st_size;
}
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_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;
}
/* Returns increment for curr_y. */
static int
show_file_type(FileView *view, int curr_y)
{
const dir_entry_t *entry;
int x;
int old_curr_y = curr_y;
x = getmaxx(menu_win);
entry = &view->dir_entry[view->list_pos];
mvwaddstr(menu_win, curr_y, 2, "Type: ");
if(entry->type == FT_LINK)
{
char full_path[PATH_MAX];
char linkto[PATH_MAX + NAME_MAX];
get_current_full_path(view, sizeof(full_path), full_path);
mvwaddstr(menu_win, curr_y, 8, "Link");
curr_y += 2;
mvwaddstr(menu_win, curr_y, 2, "Link To: ");
if(get_link_target(full_path, linkto, sizeof(linkto)) == 0)
{
mvwaddnstr(menu_win, curr_y, 11, linkto, x - 11);
if(!path_exists(linkto, DEREF))
{
mvwaddstr(menu_win, curr_y - 2, 12, " (BROKEN)");
}
}
else
{
mvwaddstr(menu_win, curr_y, 11, "Couldn't Resolve Link");
}
}
else if(entry->type == FT_EXEC || entry->type == FT_REG)
{
#ifdef HAVE_FILE_PROG
char full_path[PATH_MAX];
FILE *pipe;
char command[1024];
char buf[NAME_MAX];
get_current_full_path(view, sizeof(full_path), full_path);
/* Use the file command to get file information. */
snprintf(command, sizeof(command), "file \"%s\" -b", full_path);
if((pipe = popen(command, "r")) == NULL)
{
mvwaddstr(menu_win, curr_y, 8, "Unable to open pipe to read file");
return 2;
}
if(fgets(buf, sizeof(buf), pipe) != buf)
strcpy(buf, "Pipe read error");
pclose(pipe);
mvwaddnstr(menu_win, curr_y, 8, buf, x - 9);
if(x > 9 && strlen(buf) > (size_t)(x - 9))
{
mvwaddnstr(menu_win, curr_y + 1, 8, buf + x - 9, x - 9);
}
#else /* #ifdef HAVE_FILE_PROG */
if(entry->type == FT_EXEC)
mvwaddstr(menu_win, curr_y, 8, "Executable");
else
mvwaddstr(menu_win, curr_y, 8, "Regular File");
#endif /* #ifdef HAVE_FILE_PROG */
}
else if(entry->type == FT_DIR)
{
mvwaddstr(menu_win, curr_y, 8, "Directory");
}
#ifndef _WIN32
else if(entry->type == FT_CHAR_DEV || entry->type == FT_BLOCK_DEV)
{
const char *const type = (entry->type == FT_CHAR_DEV)
? "Character Device"
: "Block Device";
char full_path[PATH_MAX];
struct stat st;
mvwaddstr(menu_win, curr_y, 8, type);
get_current_full_path(view, sizeof(full_path), full_path);
if(os_stat(full_path, &st) == 0)
{
char info[64];
snprintf(info, sizeof(info), "Device Id: 0x%x:0x%x", major(st.st_rdev),
minor(st.st_rdev));
curr_y += 2;
mvwaddstr(menu_win, curr_y, 2, info);
}
}
else if(entry->type == FT_SOCK)
{
mvwaddstr(menu_win, curr_y, 8, "Socket");
}
#endif
else if(entry->type == FT_FIFO)
{
mvwaddstr(menu_win, curr_y, 8, "Fifo Pipe");
}
else
{
mvwaddstr(menu_win, curr_y, 8, "Unknown");
}
curr_y += 2;
return curr_y - old_curr_y;
}
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 */
}
/* Implementation of traverse() visitor for subtree removal. Returns 0 on
* success, otherwise non-zero is returned. */
static VisitResult
rm_visitor(const char full_path[], VisitAction action, void *param)
{
io_args_t *const rm_args = param;
VisitResult result = VR_OK;
if(rm_args->cancellable && ui_cancellation_requested())
{
return VR_CANCELLED;
}
switch(action)
{
case VA_DIR_ENTER:
/* Do nothing, directories are removed on leaving them. */
result = VR_OK;
break;
case VA_FILE:
{
io_args_t args = {
.arg1.path = full_path,
.cancellable = rm_args->cancellable,
.estim = rm_args->estim,
.result = rm_args->result,
};
result = (iop_rmfile(&args) == 0) ? VR_OK : VR_ERROR;
rm_args->result = args.result;
break;
}
case VA_DIR_LEAVE:
{
io_args_t args = {
.arg1.path = full_path,
.cancellable = rm_args->cancellable,
.estim = rm_args->estim,
.result = rm_args->result,
};
result = (iop_rmdir(&args) == 0) ? VR_OK : VR_ERROR;
rm_args->result = args.result;
break;
}
}
return result;
}
int
ior_cp(io_args_t *const args)
{
const char *const src = args->arg1.src;
const char *const dst = args->arg2.dst;
if(is_in_subtree(dst, src))
{
(void)ioe_errlst_append(&args->result.errors, src, IO_ERR_UNKNOWN,
"Can't copy parent path into subpath");
return 1;
}
if(args->arg3.crs == IO_CRS_REPLACE_ALL)
{
io_args_t rm_args = {
.arg1.path = dst,
.cancellable = args->cancellable,
.estim = args->estim,
.result = args->result,
};
const int result = ior_rm(&rm_args);
args->result = rm_args.result;
if(result != 0)
{
if(!args->cancellable || !ui_cancellation_requested())
{
(void)ioe_errlst_append(&args->result.errors, dst, IO_ERR_UNKNOWN,
"Failed to remove");
}
return result;
}
}
return traverse(src, &cp_visitor, args);
}
/* Implementation of traverse() visitor for subtree copying. Returns 0 on
* success, otherwise non-zero is returned. */
static VisitResult
cp_visitor(const char full_path[], VisitAction action, void *param)
{
return cp_mv_visitor(full_path, action, param, 1);
}
int
ior_mv(io_args_t *const args)
{
const char *const src = args->arg1.src;
const char *const dst = args->arg2.dst;
const IoCrs crs = args->arg3.crs;
const io_confirm confirm = args->confirm;
if(crs == IO_CRS_FAIL && path_exists(dst, DEREF) && !is_case_change(src, dst))
{
(void)ioe_errlst_append(&args->result.errors, dst, EEXIST,
strerror(EEXIST));
return 1;
}
if(crs == IO_CRS_APPEND_TO_FILES)
{
if(!is_file(src))
{
(void)ioe_errlst_append(&args->result.errors, src, EISDIR,
strerror(EISDIR));
return 1;
}
if(!is_file(dst))
{
(void)ioe_errlst_append(&args->result.errors, dst, EISDIR,
strerror(EISDIR));
return 1;
}
}
else if(crs == IO_CRS_REPLACE_FILES && path_exists(dst, DEREF))
{
/* Ask user whether to overwrite destination file. */
if(confirm != NULL && !confirm(args, src, dst))
{
return 0;
}
}
if(os_rename(src, dst) == 0)
{
ioeta_update(args->estim, src, dst, 1, 0);
return 0;
}
switch(errno)
{
case EXDEV:
{
int result = ior_cp(args);
if(result == 0)
{
io_args_t rm_args = {
.arg1.path = src,
.cancellable = args->cancellable,
.estim = args->estim,
.result = args->result,
};
/* Disable progress reporting for this "secondary" operation. */
const int silent = ioeta_silent_on(rm_args.estim);
result = ior_rm(&rm_args);
args->result = rm_args.result;
ioeta_silent_set(rm_args.estim, silent);
}
return result;
}
case EISDIR:
case ENOTEMPTY:
case EEXIST:
#ifdef _WIN32
/* For MXE builds running in Wine. */
case EPERM:
case EACCES:
#endif
if(crs == IO_CRS_REPLACE_ALL)
{
int error;
io_args_t rm_args = {
.arg1.path = dst,
.cancellable = args->cancellable,
.estim = args->estim,
.result = args->result,
};
/* Ask user whether to overwrite destination file. */
if(confirm != NULL && !confirm(args, src, dst))
{
return 0;
}
error = ior_rm(&rm_args);
args->result = rm_args.result;
if(error != 0)
{
if(!args->cancellable || !ui_cancellation_requested())
{
(void)ioe_errlst_append(&args->result.errors, dst, IO_ERR_UNKNOWN,
"Failed to remove");
}
return error;
}
if(os_rename(src, dst) != 0)
{
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
return 1;
}
return 0;
}
else if(crs == IO_CRS_REPLACE_FILES ||
(!has_atomic_file_replace() && crs == IO_CRS_APPEND_TO_FILES))
{
if(!has_atomic_file_replace() && is_file(dst))
{
io_args_t rm_args = {
.arg1.path = dst,
.cancellable = args->cancellable,
.estim = args->estim,
.result = args->result,
};
const int error = iop_rmfile(&rm_args);
args->result = rm_args.result;
if(error != 0)
{
if(!args->cancellable || !ui_cancellation_requested())
{
(void)ioe_errlst_append(&args->result.errors, dst, IO_ERR_UNKNOWN,
"Failed to remove");
}
return error;
}
}
return traverse(src, &mv_visitor, args);
}
/* Break is intentionally omitted. */
default:
(void)ioe_errlst_append(&args->result.errors, src, errno,
strerror(errno));
return errno;
}
}
/* Checks that path points to a file or symbolic link. Returns non-zero if so,
* otherwise zero is returned. */
static int
is_file(const char path[])
{
return !is_dir(path)
|| (is_symlink(path) && get_symlink_type(path) != SLT_UNKNOWN);
}
/* Implementation of traverse() visitor for subtree moving. Returns 0 on
* success, otherwise non-zero is returned. */
static VisitResult
mv_visitor(const char full_path[], VisitAction action, void *param)
{
return cp_mv_visitor(full_path, action, param, 0);
}
/* Generic implementation of traverse() visitor for subtree copying/moving.
* Returns 0 on success, otherwise non-zero is returned. */
static VisitResult
cp_mv_visitor(const char full_path[], VisitAction action, void *param, int cp)
{
io_args_t *const cp_args = param;
const char *dst_full_path;
char *free_me = NULL;
VisitResult result = VR_OK;
const char *rel_part;
if(cp_args->cancellable && ui_cancellation_requested())
{
return VR_CANCELLED;
}
/* TODO: come up with something better than this. */
rel_part = full_path + strlen(cp_args->arg1.src);
dst_full_path = (rel_part[0] == '\0')
? cp_args->arg2.dst
: (free_me = format_str("%s/%s", cp_args->arg2.dst, rel_part));
switch(action)
{
case VA_DIR_ENTER:
if(cp_args->arg3.crs != IO_CRS_REPLACE_FILES || !is_dir(dst_full_path))
{
io_args_t args = {
.arg1.path = dst_full_path,
/* Temporary fake rights so we can add files to the directory. */
.arg3.mode = 0700,
.cancellable = cp_args->cancellable,
.estim = cp_args->estim,
.result = cp_args->result,
};
result = (iop_mkdir(&args) == 0) ? VR_OK : VR_ERROR;
cp_args->result = args.result;
}
break;
case VA_FILE:
{
io_args_t args = {
.arg1.src = full_path,
.arg2.dst = dst_full_path,
.arg3.crs = cp_args->arg3.crs,
/* It's safe to always use fast file cloning on moving files. */
.arg4.fast_file_cloning = cp ? cp_args->arg4.fast_file_cloning : 1,
.cancellable = cp_args->cancellable,
.confirm = cp_args->confirm,
.estim = cp_args->estim,
.result = cp_args->result,
};
result = ((cp ? iop_cp(&args) : ior_mv(&args)) == 0) ? VR_OK : VR_ERROR;
cp_args->result = args.result;
break;
}
case VA_DIR_LEAVE:
{
struct stat st;
if(cp_args->arg3.crs == IO_CRS_REPLACE_FILES && !cp)
{
io_args_t rm_args = {
.arg1.path = full_path,
.cancellable = cp_args->cancellable,
.estim = cp_args->estim,
.result = cp_args->result,
};
result = (iop_rmdir(&rm_args) == 0) ? VR_OK : VR_ERROR;
}
else if(os_stat(full_path, &st) == 0)
{
result = (os_chmod(dst_full_path, st.st_mode & 07777) == 0)
? VR_OK
: VR_ERROR;
if(result == VR_ERROR)
{
(void)ioe_errlst_append(&cp_args->result.errors, dst_full_path,
errno, strerror(errno));
}
clone_timestamps(dst_full_path, full_path, &st);
}
else
{
(void)ioe_errlst_append(&cp_args->result.errors, full_path, errno,
strerror(errno));
result = VR_ERROR;
}
break;
}
}
free(free_me);
return result;
}
/*
* Add a module to the Data base
*/
static SECStatus
nssutil_AddSecmodDBEntry(const char *appName,
const char *filename, const char *dbname,
char *module, PRBool rw)
{
os_stat_type stat_existing;
os_open_permissions_type file_mode;
FILE *fd = NULL;
char *block = NULL;
PRBool libFound = PR_FALSE;
if (dbname == NULL) {
PORT_SetError(SEC_ERROR_INVALID_ARGS);
return SECFailure;
}
/* can't write to a read only module */
if (!rw) {
PORT_SetError(SEC_ERROR_READ_ONLY);
return SECFailure;
}
/* remove the previous version if it exists */
(void) nssutil_DeleteSecmodDBEntry(appName, filename, dbname, module, rw);
/* get the permissions of the existing file, or use the default */
if (!os_stat(dbname, &stat_existing)) {
file_mode = stat_existing.st_mode;
} else {
file_mode = os_open_permissions_default;
}
fd = lfopen(dbname, lfopen_append, file_mode);
if (fd == NULL) {
return SECFailure;
}
module = NSSUTIL_ArgStrip(module);
while (*module) {
int count;
char *keyEnd = PORT_Strchr(module,'=');
char *value;
if (PORT_Strncmp(module, "library=", 8) == 0) {
libFound=PR_TRUE;
}
if (keyEnd == NULL) {
block = nssutil_DupCat(block, module);
break;
}
block = nssutil_DupnCat(block, module, keyEnd-module+1);
if (block == NULL) { goto loser; }
value = NSSUTIL_ArgFetchValue(&keyEnd[1], &count);
if (value) {
block = nssutil_DupCat(block, NSSUTIL_ArgStrip(value));
PORT_Free(value);
}
if (block == NULL) { goto loser; }
block = nssutil_DupnCat(block, "\n", 1);
module = keyEnd + 1 + count;
module = NSSUTIL_ArgStrip(module);
}
if (block) {
if (!libFound) {
fprintf(fd,"library=\n");
}
fwrite(block, PORT_Strlen(block), 1, fd);
fprintf(fd,"\n");
PORT_Free(block);
block = NULL;
}
fclose(fd);
return SECSuccess;
loser:
PORT_Free(block);
fclose(fd);
return SECFailure;
}
/*
* Delete a module from the Data Base
*/
static SECStatus
nssutil_DeleteSecmodDBEntry(const char *appName,
const char *filename,
const char *dbname,
char *args,
PRBool rw)
{
/* SHDB_FIXME implement */
os_stat_type stat_existing;
os_open_permissions_type file_mode;
FILE *fd = NULL;
FILE *fd2 = NULL;
char line[MAX_LINE_LENGTH];
char *dbname2 = NULL;
char *block = NULL;
char *name = NULL;
char *lib = NULL;
int name_len = 0, lib_len = 0;
PRBool skip = PR_FALSE;
PRBool found = PR_FALSE;
if (dbname == NULL) {
PORT_SetError(SEC_ERROR_INVALID_ARGS);
return SECFailure;
}
if (!rw) {
PORT_SetError(SEC_ERROR_READ_ONLY);
return SECFailure;
}
dbname2 = PORT_Strdup(dbname);
if (dbname2 == NULL) goto loser;
dbname2[strlen(dbname)-1]++;
/* get the permissions of the existing file, or use the default */
if (!os_stat(dbname, &stat_existing)) {
file_mode = stat_existing.st_mode;
} else {
file_mode = os_open_permissions_default;
}
/* do we really want to use streams here */
fd = fopen(dbname, "r");
if (fd == NULL) goto loser;
fd2 = lfopen(dbname2, lfopen_truncate, file_mode);
if (fd2 == NULL) goto loser;
name = NSSUTIL_ArgGetParamValue("name",args);
if (name) {
name_len = PORT_Strlen(name);
}
lib = NSSUTIL_ArgGetParamValue("library",args);
if (lib) {
lib_len = PORT_Strlen(lib);
}
/*
* the following loop takes line separated config files and collapses
* the lines to a single string, escaping and quoting as necessary.
*/
/* loop state variables */
block = NULL;
skip = PR_FALSE;
while (fgets(line, sizeof(line), fd) != NULL) {
/* If we are processing a block (we haven't hit a blank line yet */
if (*line != '\n') {
/* skip means we are in the middle of a block we are deleting */
if (skip) {
continue;
}
/* if we haven't found the block yet, check to see if this block
* matches our requirements */
if (!found && ((name && (PORT_Strncasecmp(line,"name=",5) == 0) &&
(PORT_Strncmp(line+5,name,name_len) == 0)) ||
(lib && (PORT_Strncasecmp(line,"library=",8) == 0) &&
(PORT_Strncmp(line+8,lib,lib_len) == 0)))) {
/* yup, we don't need to save any more data, */
PORT_Free(block);
block=NULL;
/* we don't need to collect more of this block */
skip = PR_TRUE;
/* we don't need to continue searching for the block */
found =PR_TRUE;
continue;
}
/* not our match, continue to collect data in this block */
block = nssutil_DupCat(block,line);
continue;
}
/* we've collected a block of data that wasn't the module we were
* looking for, write it out */
if (block) {
fwrite(block, PORT_Strlen(block), 1, fd2);
PORT_Free(block);
block = NULL;
}
/* If we didn't just delete the this block, keep the blank line */
if (!skip) {
fputs(line,fd2);
}
/* we are definately not in a deleted block anymore */
skip = PR_FALSE;
}
fclose(fd);
fclose(fd2);
if (found) {
/* rename dbname2 to dbname */
PR_Delete(dbname);
PR_Rename(dbname2,dbname);
} else {
PR_Delete(dbname2);
}
PORT_Free(dbname2);
PORT_Free(lib);
PORT_Free(name);
PORT_Free(block);
return SECSuccess;
loser:
if (fd != NULL) {
fclose(fd);
}
if (fd2 != NULL) {
fclose(fd2);
}
if (dbname2) {
PR_Delete(dbname2);
PORT_Free(dbname2);
}
PORT_Free(lib);
PORT_Free(name);
return SECFailure;
}
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;
}
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;
}
/*
* 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;
}
