Skip to content
Snippets Groups Projects
Select Git revision
  • pu
  • passt default
  • master
  • todo
  • next
  • maint
  • v2.8.0-rc1
  • v2.8.0-rc0
  • v2.7.2
  • v2.7.1
  • v2.7.0
  • v2.6.5
  • v2.7.0-rc3
  • v2.7.0-rc2
  • v2.7.0-rc1
  • v2.7.0-rc0
  • v2.6.4
  • v2.6.3
  • v2.6.2
  • v2.6.1
  • v2.3.10
  • v2.5.4
  • v2.4.10
  • v2.6.0
  • v2.6.0-rc3
  • v2.5.3
26 results

copy.c

Blame
    • Junio C Hamano's avatar
      00b7cbfc
      copy.c: make copy_fd() report its status silently · 00b7cbfc
      Junio C Hamano authored
      
      When copy_fd() function encounters errors, it emits error messages
      itself, which makes it impossible for callers to take responsibility
      for reporting errors, especially when they want to ignore certain
      errors.
      
      Move the error reporting to its callers in preparation.
      
       - copy_file() and copy_file_with_time() by indirection get their
         own calls to error().
      
       - hold_lock_file_for_append(), when told to die on error, used to
         exit(128) relying on the error message from copy_fd(), but now it
         does its own die() instead.  Note that the callers that do not
         pass LOCK_DIE_ON_ERROR need to be adjusted for this change, but
         fortunately there is none ;-)
      
       - filter_buffer_or_fd() has its own error() already, in addition to
         the message from copy_fd(), so this will change the output but
         arguably in a better way.
      
      Signed-off-by: default avatarJunio C Hamano <gitster@pobox.com>
      00b7cbfc
      History
      copy.c: make copy_fd() report its status silently
      Junio C Hamano authored
      
      When copy_fd() function encounters errors, it emits error messages
      itself, which makes it impossible for callers to take responsibility
      for reporting errors, especially when they want to ignore certain
      errors.
      
      Move the error reporting to its callers in preparation.
      
       - copy_file() and copy_file_with_time() by indirection get their
         own calls to error().
      
       - hold_lock_file_for_append(), when told to die on error, used to
         exit(128) relying on the error message from copy_fd(), but now it
         does its own die() instead.  Note that the callers that do not
         pass LOCK_DIE_ON_ERROR need to be adjusted for this change, but
         fortunately there is none ;-)
      
       - filter_buffer_or_fd() has its own error() already, in addition to
         the message from copy_fd(), so this will change the output but
         arguably in a better way.
      
      Signed-off-by: default avatarJunio C Hamano <gitster@pobox.com>
    abspath.c 4.40 KiB
    #include "cache.h"
    
    /*
     * Do not use this for inspecting *tracked* content.  When path is a
     * symlink to a directory, we do not want to say it is a directory when
     * dealing with tracked content in the working tree.
     */
    int is_directory(const char *path)
    {
    	struct stat st;
    	return (!stat(path, &st) && S_ISDIR(st.st_mode));
    }
    
    /* We allow "recursive" symbolic links. Only within reason, though. */
    #define MAXDEPTH 5
    
    /*
     * Return the real path (i.e., absolute path, with symlinks resolved
     * and extra slashes removed) equivalent to the specified path.  (If
     * you want an absolute path but don't mind links, use
     * absolute_path().)  The return value is a pointer to a static
     * buffer.
     *
     * The input and all intermediate paths must be shorter than MAX_PATH.
     * The directory part of path (i.e., everything up to the last
     * dir_sep) must denote a valid, existing directory, but the last
     * component need not exist.  If die_on_error is set, then die with an
     * informative error message if there is a problem.  Otherwise, return
     * NULL on errors (without generating any output).
     *
     * If path is our buffer, then return path, as it's already what the
     * user wants.
     */
    static const char *real_path_internal(const char *path, int die_on_error)
    {
    	static struct strbuf sb = STRBUF_INIT;
    	char *retval = NULL;
    
    	/*
    	 * If we have to temporarily chdir(), store the original CWD
    	 * here so that we can chdir() back to it at the end of the
    	 * function:
    	 */
    	struct strbuf cwd = STRBUF_INIT;
    
    	int depth = MAXDEPTH;
    	char *last_elem = NULL;
    	struct stat st;
    
    	/* We've already done it */
    	if (path == sb.buf)
    		return path;
    
    	if (!*path) {
    		if (die_on_error)
    			die("The empty string is not a valid path");
    		else
    			goto error_out;
    	}
    
    	strbuf_reset(&sb);
    	strbuf_addstr(&sb, path);
    
    	while (depth--) {
    		if (!is_directory(sb.buf)) {
    			char *last_slash = find_last_dir_sep(sb.buf);
    			if (last_slash) {
    				last_elem = xstrdup(last_slash + 1);
    				strbuf_setlen(&sb, last_slash - sb.buf + 1);
    			} else {
    				last_elem = xmemdupz(sb.buf, sb.len);
    				strbuf_reset(&sb);
    			}
    		}
    
    		if (sb.len) {
    			if (!cwd.len && strbuf_getcwd(&cwd)) {
    				if (die_on_error)
    					die_errno("Could not get current working directory");
    				else
    					goto error_out;
    			}
    
    			if (chdir(sb.buf)) {
    				if (die_on_error)
    					die_errno("Could not switch to '%s'",
    						  sb.buf);
    				else
    					goto error_out;
    			}
    		}
    		if (strbuf_getcwd(&sb)) {
    			if (die_on_error)
    				die_errno("Could not get current working directory");
    			else
    				goto error_out;
    		}
    
    		if (last_elem) {
    			if (sb.len && !is_dir_sep(sb.buf[sb.len - 1]))
    				strbuf_addch(&sb, '/');
    			strbuf_addstr(&sb, last_elem);
    			free(last_elem);
    			last_elem = NULL;
    		}
    
    		if (!lstat(sb.buf, &st) && S_ISLNK(st.st_mode)) {
    			struct strbuf next_sb = STRBUF_INIT;
    			ssize_t len = strbuf_readlink(&next_sb, sb.buf, 0);
    			if (len < 0) {
    				if (die_on_error)
    					die_errno("Invalid symlink '%s'",
    						  sb.buf);
    				else
    					goto error_out;
    			}
    			strbuf_swap(&sb, &next_sb);
    			strbuf_release(&next_sb);
    		} else
    			break;
    	}
    
    	retval = sb.buf;
    error_out:
    	free(last_elem);
    	if (cwd.len && chdir(cwd.buf))
    		die_errno("Could not change back to '%s'", cwd.buf);
    	strbuf_release(&cwd);
    
    	return retval;
    }
    
    const char *real_path(const char *path)
    {
    	return real_path_internal(path, 1);
    }
    
    const char *real_path_if_valid(const char *path)
    {
    	return real_path_internal(path, 0);
    }
    
    /*
     * Use this to get an absolute path from a relative one. If you want
     * to resolve links, you should use real_path.
     */
    const char *absolute_path(const char *path)
    {
    	static struct strbuf sb = STRBUF_INIT;
    	strbuf_reset(&sb);
    	strbuf_add_absolute_path(&sb, path);
    	return sb.buf;
    }
    
    /*
     * Unlike prefix_path, this should be used if the named file does
     * not have to interact with index entry; i.e. name of a random file
     * on the filesystem.
     */
    const char *prefix_filename(const char *pfx, int pfx_len, const char *arg)
    {
    	static struct strbuf path = STRBUF_INIT;
    #ifndef GIT_WINDOWS_NATIVE
    	if (!pfx_len || is_absolute_path(arg))
    		return arg;
    	strbuf_reset(&path);
    	strbuf_add(&path, pfx, pfx_len);
    	strbuf_addstr(&path, arg);
    #else
    	char *p;
    	/* don't add prefix to absolute paths, but still replace '\' by '/' */
    	strbuf_reset(&path);
    	if (is_absolute_path(arg))
    		pfx_len = 0;
    	else if (pfx_len)
    		strbuf_add(&path, pfx, pfx_len);
    	strbuf_addstr(&path, arg);
    	for (p = path.buf + pfx_len; *p; p++)
    		if (*p == '\\')
    			*p = '/';
    #endif
    	return path.buf;
    }