static void save_folders_r(struct folder *root, char* dst, size_t maxlen)
{
int i = 0;
while (i < root->children_count)
{
struct child *this = &root->children[i];
if (this->state == SELECTED)
{
if (this->folder)
snprintf(buffer_front, buffer_end - buffer_front,
"%s:", get_full_path(this->folder));
else
{
char *p = get_full_path(root);
snprintf(buffer_front, buffer_end - buffer_front,
"%s/%s:", strcmp(p, "/") ? p : "",
strcmp(this->name, "/") ? this->name : "");
}
strlcat(dst, buffer_front, maxlen);
}
else if (this->state == EXPANDED)
save_folders_r(this->folder, dst, maxlen);
i++;
}
}
static int rootfctrl_path_rename(struct path *old_dir, struct dentry *old_dentry,
struct path *new_dir, struct dentry *new_dentry)
{
pid_t pid;
char tcomm[sizeof(current->comm)];
char old_name_buf[MAX_NAME_BUF_LEN], new_name_buf[MAX_NAME_BUF_LEN];
char *old_full_path = get_full_path(old_dir, old_dentry, old_name_buf);
char *new_full_path = get_full_path(new_dir, new_dentry, new_name_buf);
#if (RTFCTL_RUN_MODE == RTFCTL_TEST_MODE)
if (is_felica_file(old_full_path) || is_nfc_file(old_full_path))
#else
if (is_felica_file(old_full_path) || is_felica_file(new_full_path) ||
is_nfc_file(old_full_path) || is_nfc_file(new_full_path))
#endif
{
pid = task_tgid_vnr(current);
get_task_comm(tcomm, current);
RTFCTL_MSG("########## %s ##########\n", __FUNCTION__);
RTFCTL_MSG("pid: %d (%s)\n", pid, tcomm);
#if (RTFCTL_RUN_MODE != RTFCTL_TRACKING_MODE)
printk("[RTFCTL] RType-5 <%s (%d)>\n", tcomm, pid);
if (old_full_path)
printk("[RTFCTL] RType-5 <old %s>\n", old_full_path);
if (new_full_path)
printk("[RTFCTL] RType-5 <new %s>\n", new_full_path);
return -EACCES;
#endif
}
return 0;
}
static int rootfctrl_path_truncate(struct path *path)
{
char name_buf[MAX_NAME_BUF_LEN];
if (is_felica_file(get_full_path(path, NULL, name_buf))) {
RTFCTL_MSG("*****>>>>> %s <<<<<*****\n", __FUNCTION__);
RTFCTL_MSG("path: %s\n", get_full_path(path, NULL, name_buf));
}
return 0;
}
/* Program */
int main(int argc, char **argv) {
int err = 0;
int i;
int len;
/* Set default applications to open bookmarks */
g_cmd_name = argv[0];
g_dir_name = getenv("HOME");
g_browser_name = "firefox";
g_filer_name = "rox";
g_icon_dir = "/usr/share/icons/hicolor/32x32/apps";
/* If applications is specified. */
for (i = 1; i < argc; i++) {
len = strlen(argv[i]);
if (len > 2 && argv[i][0] == '-') {
switch (argv[i][1]) {
case 'd': g_dir_name = get_full_path(argv[i] + 2); break;
case 'b': g_browser_name = argv[i] + 2; break;
case 'f': g_filer_name = argv[i] + 2; break;
case 'i': g_icon_dir = get_full_path(argv[i] + 2); break;
default:
exit(1);
}
}
}
printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
printf("<openbox_pipe_menu>\n");
err = print_dir_entries(g_dir_name);
if (err) {
printf(ERR_MSG_DIR);
}
printf(
"<separator label=\"編集\" />\n"
"<item label=\"Open the location with %s\" icon=\"%s/%s.png\">\n"
" <action name=\"Execute\"><execute>%s "%s"</execute></action>\n"
"</item>\n",
g_filer_name, g_icon_dir, g_filer_name, g_filer_name, g_dir_name
);
printf("</openbox_pipe_menu>\n");
if (g_dir_name != NULL) {
free(g_dir_name);
}
if (g_icon_dir != NULL) {
free(g_icon_dir);
}
return 0;
}
static int rootfctrl_path_rmdir(struct path *dir, struct dentry *dentry)
{
char name_buf[MAX_NAME_BUF_LEN];
if (is_felica_file(get_full_path(dir, dentry, name_buf))) {
RTFCTL_MSG("*****>>>>> %s <<<<<*****\n", __FUNCTION__);
RTFCTL_MSG("parent: %s\n", get_full_path(dir, NULL, name_buf));
RTFCTL_MSG("dentry: %s\n", dentry->d_name.name);
if (current_uid() == 0) {
RTFCTL_MSG("Rejected...\n");
}
}
return 0;
}
/*
* display the file open dialog
*/
void gtkui_load_filter(void)
{
GtkWidget *dialog;
gchar *filename;
int response = 0;
char *path = get_full_path("share", "");
DEBUG_MSG("gtk_load_filter");
dialog = gtk_file_chooser_dialog_new("Select a precompiled filter file...",
GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), path);
SAFE_FREE(path);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
gtk_widget_hide(dialog);
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
/*
* load the filters chain.
* errors are spawned by the function itself
*/
filter_load_file(filename, GBL_FILTERS, 1);
g_free(filename);
}
gtk_widget_destroy (dialog);
}
static int rootfctrl_path_link(struct dentry *old_dentry, struct path *new_dir, struct dentry *new_dentry)
{
pid_t pid;
char tcomm[sizeof(current->comm)], name_buf[MAX_NAME_BUF_LEN];
char *full_path;
struct path path;
path.mnt = new_dir->mnt;
path.dentry = old_dentry;
full_path = get_full_path(&path, NULL, name_buf);
if (is_felica_file(full_path) || is_nfc_file(full_path)) {
pid = task_tgid_vnr(current);
get_task_comm(tcomm, current);
RTFCTL_MSG("########## %s ##########\n", __FUNCTION__);
RTFCTL_MSG("pid: %d (%s)\n", pid, tcomm);
RTFCTL_MSG("new_dentry: %s -> old_dentry: %s\n", new_dentry->d_name.name, old_dentry->d_name.name);
#if (RTFCTL_RUN_MODE != RTFCTL_TRACKING_MODE)
printk("[RTFCTL] RType-4 <%s-%s (%d)>\n", full_path, tcomm, pid);
return -EACCES;
#endif
}
return 0;
}
int run() {
// store cooccurrence in Eigen sparse matrix object
REDSVD::SMatrixXf A;
const int ncontext = read_cooccurrence(c_cooc_file_name, A, verbose);
// read U matrix from file
Eigen::MatrixXf V;
read_eigen_truncated_matrix(c_input_file_V_name, V, dim);
// read S matrix from file
Eigen::VectorXf S;
read_eigen_vector(c_input_file_S_name, S, dim, 1.0-eig);
// checking the dimensions
if (V.rows() != ncontext){
throw std::runtime_error("size mismatch between projection V matrix and the number of context words!!");
}
// starting projection
if (verbose) fprintf(stderr, "Running the projection...");
const double start = REDSVD::Util::getSec();
Eigen::MatrixXf embeddings = A * V * S.asDiagonal().inverse();
if (norm) embeddings.rowwise().normalize();
if (verbose) fprintf(stderr, "done in %.2f.\n",REDSVD::Util::getSec() - start);
// write out embeddings
const char *c_output_name = get_full_path(c_cooc_dir_name, c_output_file_name);
if (verbose) fprintf(stderr, "writing infered word embeddings in %s\n", c_output_name);
write_eigen_matrix(c_output_name, embeddings);
free((char*)c_output_name);
return 0;
}
void delete_cmd(int argc, char **args, int call_type) {
char *path;
switch (call_type) {
case CALL_TYPE_HELP:
puts("DELETE ITEMS\n");
return;
case CALL_TYPE_DESC:
puts("[PATH] [PATH] [PATH] . . .\n");
puts("\tPATH\tTHE PATH OF THE TARGET TO DELETE\n");
return;
}
while (argc--) {
path = get_full_path(*args);
if (is_path(path, strlen(path), TYPE_UNDEFINED, 0)) {
delete(path, strlen(path));
} else {
puts(*args);
puts(" not found!\n");
}
args++;
free(path);
}
}
void ImplNodeEx::update() const
{
auto hndl = CheckHandleErr(::CreateFileW(get_full_path().c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE | FILE_SHARE_READ, nullptr, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
nullptr));
::GetFileInformationByHandle(hndl, &data_);
}
/*
* The BFileFullPathFunc() SQL function returns full path of a BFile
*/
static void BFileFullPathFunc(
sqlite3_context *context,
int argc,
sqlite3_value **argv)
{
int rc;
sqlite3 *db;
int loc_size;
char *pLoc, *full_path;
assert(context != NULL && argc == 1 && argv != NULL);
loc_size = sqlite3_value_bytes(argv[0]);
if (loc_size == 0) {
sqlite3_result_null(context);
return;
}
pLoc = (char *)sqlite3_value_text(argv[0]);
db = (sqlite3 *)sqlite3_user_data(context);
rc = get_full_path(db, pLoc, loc_size, &full_path);
if (rc) {
if (rc == SQLITE_NOMEM)
sqlite3_result_error_nomem(context);
else
sqlite3_result_error(context, "internal error", -1);
return;
}
sqlite3_result_text(context, full_path, strlen(full_path), sqlite3_free);
}
int GIGAreadlink(const char *path, char *link, size_t size)
{
logMessage(LOG_TRACE, __func__,
" ==> readlink(path=[%s],link=[%s],size[%d])", path, link, size);
int ret = 0;
char fpath[MAX_LEN] = {0};
switch (giga_options_t.backend_type) {
case BACKEND_LOCAL_FS:
get_full_path(fpath, path);
ret = local_readlink(fpath, link, size);
ret = FUSE_ERROR(ret);
break;
case BACKEND_RPC_LEVELDB:
break;
default:
break;
}
logMessage(LOG_TRACE, __func__,
"ret_readlink(link=[%s], size[%d])", path, link, strlen(link));
return ret;
}
static WERROR cmd_ck(struct regshell_context *ctx, int argc, char **argv)
{
struct registry_key *nkey = NULL;
char *full_path;
WERROR error;
if(argc == 2) {
if (!W_ERROR_IS_OK(get_full_path(ctx, argv[1], &full_path))) {
fprintf(stderr, "Unable to parse the supplied path\n");
return WERR_INVALID_PARAM;
}
error = reg_open_key(ctx->registry, ctx->root, full_path,
&nkey);
if(!W_ERROR_IS_OK(error)) {
DEBUG(0, ("Error opening specified key: %s\n",
win_errstr(error)));
return error;
}
talloc_free(ctx->path);
ctx->path = full_path;
ctx->current = nkey;
}
printf("New path is: %s\\%s\n", ctx->predef?ctx->predef:"", ctx->path);
return WERR_OK;
}
int GIGAmkdir(const char *path, mode_t mode)
{
logMessage(LOG_TRACE, __func__,
" ==> mkdir(path=[%s], mode=[0%3o])", path, mode);
int ret = 0;
char fpath[MAX_LEN] = {0};
char dir[MAX_LEN] = {0};
char file[MAX_LEN] = {0};
int dir_id = 0;
switch (giga_options_t.backend_type) {
case BACKEND_LOCAL_FS:
get_full_path(fpath, path);
ret = local_mkdir(fpath, mode);
ret = FUSE_ERROR(ret);
break;
case BACKEND_RPC_LEVELDB:
parse_path_components(path, dir, file);
ret = rpc_mkdir(dir_id, path, mode);
ret = FUSE_ERROR(ret);
break;
default:
break;
}
return ret;
}
/*
* display the file open dialog
*/
void gtkui_load_filter(void)
{
GtkWidget *dialog;
char *filename;
int response = 0;
char *path = get_full_path("share", "");
DEBUG_MSG("gtk_load_filter");
dialog = gtk_file_selection_new ("Select a precompiled filter file...");
gtk_file_selection_set_filename(GTK_FILE_SELECTION(dialog), path);
SAFE_FREE(path);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
gtk_widget_hide(dialog);
filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog));
/*
* load the filters chain.
* errors are spawned by the function itself
*/
filter_load_file(filename, GBL_FILTERS);
}
gtk_widget_destroy (dialog);
}
int GIGAgetattr(const char *path, struct stat *statbuf)
{
logMessage(LOG_TRACE, __func__,
" ==> getattr(path=[%s], statbuf=0x%08x) ", path, statbuf);
int ret = 0;
char fpath[MAX_LEN] = {0};
char dir[MAX_LEN] = {0};
char file[MAX_LEN] = {0};
int dir_id = 0;
switch (giga_options_t.backend_type) {
case BACKEND_LOCAL_FS:
get_full_path(fpath, path);
ret = local_getattr(fpath, statbuf);
ret = FUSE_ERROR(ret);
break;
case BACKEND_RPC_LEVELDB:
parse_path_components(path, dir, file);
//TODO: convert "dir" to "dir_id"
ret = rpc_getattr(dir_id, file, statbuf);
ret = FUSE_ERROR(ret);
break;
default:
break;
}
return ret;
}
sodiumpp::locked_string filestorage::load_string_mlocked(t_filestore file_type,
const std::string &filename) {
FILE * f_ptr;
fs::path file_with_path = get_full_path(file_type, filename);
f_ptr = std::fopen(file_with_path.c_str(), "r");
if (f_ptr == NULL){
throw std::invalid_argument("Fail to open mlocked file for read: " + filename);
}
std::fseek(f_ptr, 0L, SEEK_END);
size_t content_size = static_cast<size_t>(ftell(f_ptr));
std::rewind(f_ptr);
sodiumpp::locked_string content(content_size);
size_t byte_read = std::fread(content.buffer_writable(), 1, content_size, f_ptr);
if (byte_read != content_size) {
std::string err_msg = "Fail to read all content of file: " + filename;
err_msg += " read: [" + std::to_string(byte_read);
err_msg += "] bytes of [" + std::to_string(content_size) + "]";
throw std::invalid_argument(err_msg);
}
std::fclose(f_ptr);
_dbg2("Successfully loaded mlocked string from:" << file_with_path.native());
return content;
}
int ConfirmOverwrite(const CTar32CmdInfo &cmdinfo,EXTRACTINGINFOEX64 &ExtractingInfoEx64)
{
extern HINSTANCE dll_instance;
extern HWND g_hwndOwnerWindow;
std::string path=ExtractingInfoEx64.szDestFileName;
convert_slash_to_backslash(path);
//存在確認
if(PathFileExists(path.c_str()) && !PathIsDirectory(path.c_str())){
HWND hWnd=NULL;
if(cmdinfo.hTar32StatusDialog){
hWnd=cmdinfo.hTar32StatusDialog;
}else if(g_hwndOwnerWindow){
hWnd=g_hwndOwnerWindow;
}
get_full_path(path.c_str(),path);
std::stringstream msg;
msg << "File " << path << " already exists.\r\n"
<< "Do you want to overwrite?";
int ret=::DialogBoxParam(dll_instance,MAKEINTRESOURCE(IDD_CONFIRM_OVERWRITE),hWnd,Tar32ConfirmOverwriteDialogProc,(LPARAM)(const char*)(msg.str().c_str()));
switch(ret){
case IDCANCEL:
return -1;
case IDC_BUTTON_OVERWRITE:
return 0;
case IDC_BUTTON_OVERWRITE_ALL:
return 1;
default:
return 0;
}
}
return 0;
}
/*
* display the file open dialog
*/
void gtkui_plugin_load(void)
{
GtkWidget *dialog;
char *filename;
int response = 0;
#ifdef OS_WINDOWS
char *path = get_full_path("/lib/", "");
#else
char *path = INSTALL_LIBDIR "/" EC_PROGRAM "/";
#endif
DEBUG_MSG("gtk_plugin_load");
dialog = gtk_file_selection_new ("Select a plugin...");
gtk_file_selection_set_filename(GTK_FILE_SELECTION(dialog), path);
#ifdef OS_WINDOWS
SAFE_FREE(path);
#endif
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK) {
gtk_widget_hide(dialog);
filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog));
gtkui_load_plugin(filename);
/* update the list */
gtkui_create_plug_array();
}
gtk_widget_destroy (dialog);
}
/*--------------------------------------------------------------------------*/
BOOL IsAlreadyOpenedInScilab(char *filename)
{
if (ScilabFileList)
{
char fullpath[PATH_MAX*4];
int i = 0;
if ((strcmp(filename, "") == 0) || (filename == NULL))
{
return FALSE;
}
if( get_full_path( fullpath, filename, PATH_MAX*4 ) == NULL )
{
/* if we are a problem */
strcpy(fullpath,filename);
}
for (i=0;i<CurrentMaxFiles;i++)
{
if ( (ScilabFileList[i].ftformat) && ScilabFileList[i].ftname)
{
if (strcmp(ScilabFileList[i].ftname,fullpath) == 0) return TRUE;
}
}
}
return FALSE;
}
/* check if (arg) is a valid wordlist file */
void parser_wordlist(char *arg)
{
struct stat wrd_stat;
#ifdef HAVE_LIBMAGIC
const char *target_mime = "text/plain;";
#endif
if(arg == NULL)
fatal("called with NULL argument.");
else if(globals.options.dict == false)
fatal("dictionary features OFF. unable to parse wordlist.");
else if( stat(arg,&wrd_stat) ) // if can't get file stats
pfatal(arg);
else if( S_ISREG(wrd_stat.st_mode) == 0 ) // if isn't a regular file
fatal_long("\"%s\" is not a regular file.",arg);
else if( access(arg,R_OK))
pfatal(arg);
else
{
#ifdef HAVE_LIBMAGIC
if(strncmp(get_mime(arg),target_mime,strlen(target_mime)+1) != 0)
report(warning,"\"%s\" is not a \"%s\" file.",arg,target_mime);
#endif
if((globals.wordlist = (const char *) get_full_path(arg)) == NULL)
fatal("unable to resolve full path for wordlist.");
}
return;
}
Errcode set_flipath(char *fliname, Fli_id *flid, Flipath *fp)
/* note this sets size to sizeof(Flipath) not length of string! it
* returns adjusted size of length for actual path string length if
* successful */
{
Errcode err;
char pbuf[PATH_SIZE];
clear_struct(&fp->fid);
if(fliname && flid)
{
if((err = get_full_path(fliname,pbuf)) < 0)
return(err);
fp->fid = *flid;
}
else
sprintf(pbuf,"%s.flc", unnamed_str );
fp->id.type = FP_FLIPATH;
fp->id.size = sizeof(Flipath);
fp->id.version = FLIPATH_VERSION;
return((OFFSET(Flipath,path)+1) + sprintf(fp->path,"%s", pbuf));
}
/// 这里应该做 错误检查 , 检查相对应模式下的错误情况 比如在copy 文件时 , source 不能是目录 , copy 目录时 , source 不能是文件等 必须做特殊处理
int copy_file (struct mode *oper_mode , int argc , char* argv[]) {
// 保存 argv 中的 dest
char path_buf[PATH_MAX_LEN] ;
char source_path[PATH_MAX_LEN] ;
// 这里 对于递归 ， 接口写好！ ， directory ， directory 参数 ， 这样的话， 就可以调， target的话，
bzero (path_buf , PATH_MAX_LEN) ;
strcpy(source_path , argv[argc-2]) ;
if( 1 == oper_mode->directory ) {
printf ("copy directory!\n ") ; // source是目录
get_full_path (argv[argc-1] , path_buf) ;
// 判断用户输入的是否符合自己规定
if ( '/' != path_buf[strlen(path_buf)-1] ){
strcat (path_buf , "/") ;
}
if ( '/' != source_path[strlen(source_path)-1] ) {
strcat (source_path , "/" ) ;
}
cat_source_to_dest (source_path , path_buf) ;
copy_dir (source_path,path_buf) ;
return TRUE ;
} else {
// 全都处理成绝对路径
get_full_path (argv[argc-1] ,path_buf ) ;
if (ISDIR == is_directory(path_buf )) {
printf ("target is a direcroty !\n") ;
// 首先处理名字
// 我需要st_mode 值 和 st_uid , st_gid值 然后去调函数设置
// 生成最终的文件名
if ( '/' != path_buf[strlen(path_buf)-1] ){
strcat (path_buf , "/") ;
}
cat_source_to_dest (argv[argc-2] , path_buf) ;
path_buf[strlen(path_buf)-1] = 0 ;
copy (argv[argc-2] , path_buf ) ;
}else {
// 判断文件是否存在
if (!access (path_buf , F_OK)) {
// 存在
printf ("file now is exist ! overwrite it now !\n") ;
}
copy (argv[argc-2] , path_buf ) ;
return TRUE ;
}
}
return TRUE ;
}
//---------------------------------------------------------------------------------------
string DocLocator::get_locator_as_string()
{
string loc = get_protocol_string() + get_full_path();
if (m_innerProtocol == k_zip)
return loc + "#zip:" + get_inner_fullpath();
else
return loc;
}
fs::path filestorage::create_path_for(t_filestore file_type,
const std::string &filename) {
// connect parent path with filename
fs::path full_path = get_full_path(file_type, filename);
std::cout << "full_path: " << full_path.native() << std::endl;
create_parent_dir(full_path);
return full_path;
}
/*
* Access BFILE element of the current row in the row set
*/
SQLITE_API int sqlite3_column_bfile(
sqlite3_stmt *pStmt,
int iCol,
sqlite3_bfile **ppBfile
)
{
BfileHdl *pHdl;
char * pLoc;
int loc_size, rc;
sqlite3 *db;
#define IS_ERROR(rc) \
((rc)!= SQLITE_OK && (rc) != SQLITE_ROW && (rc) != SQLITE_DONE)
if (pStmt == NULL || iCol < 0 || iCol >= sqlite3_column_count(pStmt)
|| ppBfile == NULL)
return SQLITE_ERROR;
db = sqlite3_db_handle(pStmt);
/*
* If a memory allocation error occurs during the evaluation of any of
* these routines, a default value is returned. The default value is
* either the integer 0, the floating point number 0.0, or a NULL
* pointer. Subsequent calls to sqlite3_errcode() will return
* SQLITE_NOMEM.
*/
pLoc = (char *)sqlite3_column_blob(pStmt, iCol);
if (pLoc == NULL) {
*ppBfile = NULL;
rc = sqlite3_errcode(db);
return (IS_ERROR(rc) ? SQLITE_ERROR : SQLITE_OK);
}
pHdl = sqlite3_malloc(sizeof(BfileHdl));
if (pHdl == NULL) {
*ppBfile = NULL;
return SQLITE_ERROR;
}
pHdl->fd = -1;
loc_size = sqlite3_column_bytes(pStmt, iCol);
rc = get_full_path(db, pLoc, loc_size,&(pHdl->full_path));
if (rc) {
if (pHdl != NULL)
sqlite3_free(pHdl);
*ppBfile = NULL;
return SQLITE_ERROR;
}
*ppBfile = (sqlite3_bfile *)pHdl;
return SQLITE_OK;
}
/* check if (arg) is a vlid output file */
void parser_outfile(char *arg)
{
struct stat out_stat;
struct statvfs disk_stat;
char *path=NULL;
FILE *fout;
if(arg == NULL)
fatal("called with NULL argument.");
else if(stat(arg,&out_stat) == 0)
{
if(S_ISREG(out_stat.st_mode))
{
if((path = get_full_path(arg)) != NULL)
{
if(access(path,W_OK) == 0)
{
if(statvfs(path,&disk_stat) == 0)
{
if((disk_stat.f_bsize * disk_stat.f_bavail) > MIN_FREE_SPACE )
{
argcpy(&(globals.outfile),path,strlen(path)+1);
}
else
fatal_long("we need at least %lu free bytes for writing some output.",MIN_FREE_SPACE);
}
else
pfatal(path);
}
else
pfatal(path);
}
else
fatal("unable to find full path for outfile.");
}
else
fatal_long("file \"%s\" isn't a regular file.",arg);
}
else if(errno == ENOENT)
{
if((fout = fopen(arg,"w+")) != NULL)
{
fclose(fout);
parser_outfile(arg); // restart
}
else
pfatal(arg);
}
else
pfatal(arg);
if(path!=NULL)
free((void *) path);
return;
}
static void po_chainto(Popot ppath)
/*****************************************************************************
* void PocoChainTo(char *program_path)
****************************************************************************/
{
if (ppath.pt == NULL)
po_chainto_program_path[0] = '\0';
else
get_full_path(ppath.pt, po_chainto_program_path);
}
t_file *get_glob(char *str, t_env *env)
{
t_file *glob;
char *dir;
glob = NULL;
if (!(dir = get_full_path(str, env)))
return (NULL);
return (glob);
}
void
kfs_close(struct file *file)
{
// if this file was allocated with alloc_file it will not have
// an inode
if ( file->inode ) {
char __attribute__((unused)) buff[MAX_PATHLEN];
dbg("name=`%s`\n", get_full_path( file->inode, buff) );
atomic_dec(&file->inode->i_count);
}
