/*
* There is an error in a specific file. Ask the MudOS driver to log the
* message somewhere.
*/
void smart_log (const char * error_file, int line, const char * what, int flag)
{
char *buff;
svalue_t *mret;
extern int pragmas;
buff = (char *)
DMALLOC(strlen(error_file) + strlen(what) +
((pragmas & PRAGMA_ERROR_CONTEXT) ? 100 : 40), TAG_TEMPORARY, "smart_log: 1");
if (flag)
sprintf(buff, "/%s line %d: Warning: %s", error_file, line, what);
else
sprintf(buff, "/%s line %d: %s", error_file, line, what);
if (pragmas & PRAGMA_ERROR_CONTEXT) {
char *ls = strrchr(buff, '\n');
unsigned char *tmp;
if (ls) {
tmp = (unsigned char *)ls + 1;
while (*tmp && isspace(*tmp)) tmp++;
if (!*tmp) *ls = 0;
}
strcat(buff, show_error_context());
} else strcat(buff, "\n");
push_malloced_string(add_slash(error_file));
copy_and_push_string(buff);
mret = safe_apply_master_ob(APPLY_LOG_ERROR, 2);
if (!mret || mret == (svalue_t *)-1) {
debug_message("%s", buff);
}
FREE(buff);
} /* smart_log() */
static void set_escape(uint8_t format, char *dest, const char *src,
int len_max, int len)
{
if (format == FORMAT_VCARD30)
add_slash(dest, src, len_max, len);
else if (format == FORMAT_VCARD21)
escape_semicolon(dest, src, len_max, len);
}
void initialize_directory_globals() {
// Set the working_directory
WCHAR buffer[MAX_PATH + 1];
GetCurrentDirectoryW(MAX_PATH + 1, buffer);
enigma_user::working_directory = add_slash(shorten(buffer));
// Set the program_directory
buffer[0] = 0;
GetModuleFileNameW(NULL, buffer, MAX_PATH + 1);
enigma_user::program_directory = shorten(buffer);
enigma_user::program_directory =
enigma_user::program_directory.substr(0, enigma_user::program_directory.find_last_of("\\/"));
// Set the temp_directory
buffer[0] = 0;
GetTempPathW(MAX_PATH + 1, buffer);
enigma_user::temp_directory = add_slash(shorten(buffer));
}
static void init_domain_for_ob (object_t * ob)
{
svalue_t *ret;
const char *domain_name;
if (!current_object
#ifdef PACKAGE_UIDS
|| !current_object->uid
#endif
) {
/*
* Only for the master and void object. Note that you can't ask for
* the backbone or root domain here since we're in the process of
* loading the master object.
*/
ob->stats.domain = add_stat_entry("NONAME", &domains);
return;
}
/*
* Ask master object who the creator of this object is.
*/
push_malloced_string(add_slash(ob->obname));
if (master_ob)
ret = apply_master_ob(APPLY_DOMAIN_FILE, 1);
else
ret = apply(applies_table[APPLY_DOMAIN_FILE], ob, 1, ORIGIN_DRIVER);
if (IS_ZERO(ret)) {
ob->stats.domain = current_object->stats.domain;
return;
}
if (ret->type != T_STRING)
error("'domain_file' in the master object must return a string!\n");
domain_name = ret->u.string;
if (strcmp(current_object->stats.domain->name, domain_name) == 0) {
ob->stats.domain = current_object->stats.domain;
return;
}
if (strcmp(backbone_domain->name, domain_name) == 0) {
/*
* The object is loaded from backbone. We give domain ownership to
* the creator rather than backbone.
*/
ob->stats.domain = current_object->stats.domain;
return;
}
/*
* The object isn't loaded from backbone or from the same domain as the
* creator, so we need to lookup the domain, and add it if it isnt
* present.
*/
ob->stats.domain = add_stat_entry(domain_name, &domains);
return;
}
static void vcard_printf_sip_uri(GString *vcards, const char *sip_uri)
{
int len = 0;
if (sip_uri)
len = strlen(sip_uri);
if (len) {
char field[LEN_MAX];
add_slash(field, sip_uri, LEN_MAX, len);
vcard_printf(vcards, "IMPP;TYPE=SIP:%s", field);
}
}
bool set_working_directory(string dname) {
tstring tstr_dname = widen(dname);
replace(tstr_dname.begin(), tstr_dname.end(), '/', '\\');
if (SetCurrentDirectoryW(tstr_dname.c_str()) != 0) {
WCHAR wstr_buffer[MAX_PATH + 1];
if (GetCurrentDirectoryW(MAX_PATH + 1, wstr_buffer) != 0) {
working_directory = add_slash(shorten(wstr_buffer));
return true;
}
}
return false;
}
static void vcard_printf_group(GString *vcards, const char *group)
{
int len = 0;
if (group)
len = strlen(group);
if (len) {
char field[LEN_MAX];
add_slash(field, group, LEN_MAX, len);
vcard_printf(vcards, "CATEGORIES:%s", field);
}
}
void initialize_directory_globals() {
// Set the working_directory
char buffer[PATH_MAX + 1];
if (getcwd(buffer, PATH_MAX + 1) != NULL)
enigma_user::working_directory = add_slash(buffer);
// Set the program_directory
buffer[0] = 0;
uint32_t bufsize = sizeof(buffer);
if (_NSGetExecutablePath(buffer, &bufsize) == 0) {
enigma_user::program_directory = add_slash(dirname(buffer));
}
// Set the temp_directory
char *env = getenv("TMPDIR");
if (env != NULL)
enigma_user::temp_directory = add_slash(env);
else
enigma_user::temp_directory = "/tmp/";
}
static void init_author_for_ob (object_t * ob)
{
svalue_t *ret;
push_malloced_string(add_slash(ob->obname));
ret = apply_master_ob(APPLY_AUTHOR_FILE, 1);
if (ret == (svalue_t *)-1) {
ob->stats.author = master_author;
} else if (!ret || ret->type != T_STRING) {
ob->stats.author = NULL;
} else {
ob->stats.author = add_stat_entry(ret->u.string, &authors);
}
}
static void vcard_printf_email(GString *vcards, const char *email)
{
int len = 0;
if (email)
len = strlen(email);
if (len) {
char field[LEN_MAX];
add_slash(field, email, LEN_MAX, len);
vcard_printf(vcards,
"EMAIL;TYPE=INTERNET:%s", field);
}
}
/*
* Returns a list of all inherited files.
*
*/
struct vector *
inherit_list(struct object *ob)
{
struct vector *ret;
int inh;
ret = allocate_array(ob->prog->num_inherited);
for (inh = 0; inh < (int)ob->prog->num_inherited; inh++ )
{
ret->item[inh].type = T_STRING;
ret->item[inh].string_type = STRING_MSTRING;
ret->item[inh].u.string = add_slash(ob->prog->inherit[inh].prog->name);
}
return ret;
}
static int index_range_of_same_dir(const char *src, int length,
int *first_p, int *last_p)
{
const char *src_w_slash = add_slash(src);
int first, last, len_w_slash = length + 1;
first = cache_name_pos(src_w_slash, len_w_slash);
if (first >= 0)
die(_("%.*s is in index"), len_w_slash, src_w_slash);
first = -1 - first;
for (last = first; last < active_nr; last++) {
const char *path = active_cache[last]->name;
if (strncmp(path, src_w_slash, len_w_slash))
break;
}
if (src_w_slash != src)
free((char *)src_w_slash);
*first_p = first;
*last_p = last;
return last - first;
}
void
f_traceprefix (void)
{
char *old = 0;
if (command_giver && command_giver->interactive) {
old = command_giver->interactive->trace_prefix;
if (sp->type & T_STRING) {
const char *p = sp->u.string;
if (*p == '/') p++;
command_giver->interactive->trace_prefix = make_shared_string(p);
free_string_svalue(sp);
} else
command_giver->interactive->trace_prefix = 0;
}
if (old) {
put_malloced_string(add_slash(old));
free_string(old);
} else
*sp = const0;
}
Directory::Directory(const ACE_TString& dirname, const ACE_TString& logical,
Directory* parent)
: parent_(parent, false)
, physical_dirname_(dirname)
, logical_dirname_(logical)
{
add_slash(physical_dirname_);
bool ok(true);
DDS_Dirent dir;
if (dir.open(physical_dirname_.c_str()) == -1) {
ok = false;
if (errno == ENOENT && dds_mkdir(physical_dirname_.c_str()) != -1
&& dir.open(physical_dirname_.c_str()) != -1) {
ok = true;
}
}
if (!ok) throw std::runtime_error("Can't open or create directory");
scan_dir(ACE_TEXT(""), dir, 0);
}
int cmd_mv(int argc, const char **argv, const char *prefix)
{
int i, newfd, gitmodules_modified = 0;
int verbose = 0, show_only = 0, force = 0, ignore_errors = 0;
struct option builtin_mv_options[] = {
OPT__VERBOSE(&verbose, N_("be verbose")),
OPT__DRY_RUN(&show_only, N_("dry run")),
OPT__FORCE(&force, N_("force move/rename even if target exists")),
OPT_BOOL('k', NULL, &ignore_errors, N_("skip move/rename errors")),
OPT_END(),
};
const char **source, **destination, **dest_path, **submodule_gitfile;
enum update_mode { BOTH = 0, WORKING_DIRECTORY, INDEX } *modes;
struct stat st;
struct string_list src_for_dst = STRING_LIST_INIT_NODUP;
gitmodules_config();
git_config(git_default_config, NULL);
argc = parse_options(argc, argv, prefix, builtin_mv_options,
builtin_mv_usage, 0);
if (--argc < 1)
usage_with_options(builtin_mv_usage, builtin_mv_options);
newfd = hold_locked_index(&lock_file, 1);
if (read_cache() < 0)
die(_("index file corrupt"));
source = internal_copy_pathspec(prefix, argv, argc, 0);
modes = xcalloc(argc, sizeof(enum update_mode));
/*
* Keep trailing slash, needed to let
* "git mv file no-such-dir/" error out.
*/
dest_path = internal_copy_pathspec(prefix, argv + argc, 1,
KEEP_TRAILING_SLASH);
submodule_gitfile = xcalloc(argc, sizeof(char *));
if (dest_path[0][0] == '\0')
/* special case: "." was normalized to "" */
destination = internal_copy_pathspec(dest_path[0], argv, argc, DUP_BASENAME);
else if (!lstat(dest_path[0], &st) &&
S_ISDIR(st.st_mode)) {
dest_path[0] = add_slash(dest_path[0]);
destination = internal_copy_pathspec(dest_path[0], argv, argc, DUP_BASENAME);
} else {
if (argc != 1)
die("destination '%s' is not a directory", dest_path[0]);
destination = dest_path;
}
/* Checking */
for (i = 0; i < argc; i++) {
const char *src = source[i], *dst = destination[i];
int length, src_is_dir;
const char *bad = NULL;
if (show_only)
printf(_("Checking rename of '%s' to '%s'\n"), src, dst);
length = strlen(src);
if (lstat(src, &st) < 0)
bad = _("bad source");
else if (!strncmp(src, dst, length) &&
(dst[length] == 0 || dst[length] == '/')) {
bad = _("can not move directory into itself");
} else if ((src_is_dir = S_ISDIR(st.st_mode))
&& lstat(dst, &st) == 0)
bad = _("cannot move directory over file");
else if (src_is_dir) {
int first = cache_name_pos(src, length);
if (first >= 0) {
struct strbuf submodule_dotgit = STRBUF_INIT;
if (!S_ISGITLINK(active_cache[first]->ce_mode))
die (_("Huh? Directory %s is in index and no submodule?"), src);
if (!is_staging_gitmodules_ok())
die (_("Please, stage your changes to .gitmodules or stash them to proceed"));
strbuf_addf(&submodule_dotgit, "%s/.git", src);
submodule_gitfile[i] = read_gitfile(submodule_dotgit.buf);
if (submodule_gitfile[i])
submodule_gitfile[i] = xstrdup(submodule_gitfile[i]);
else
submodule_gitfile[i] = SUBMODULE_WITH_GITDIR;
strbuf_release(&submodule_dotgit);
} else {
const char *src_w_slash = add_slash(src);
int last, len_w_slash = length + 1;
modes[i] = WORKING_DIRECTORY;
first = cache_name_pos(src_w_slash, len_w_slash);
if (first >= 0)
die (_("Huh? %.*s is in index?"),
len_w_slash, src_w_slash);
first = -1 - first;
for (last = first; last < active_nr; last++) {
const char *path = active_cache[last]->name;
if (strncmp(path, src_w_slash, len_w_slash))
break;
}
free((char *)src_w_slash);
if (last - first < 1)
bad = _("source directory is empty");
else {
int j, dst_len;
if (last - first > 0) {
source = xrealloc(source,
(argc + last - first)
* sizeof(char *));
destination = xrealloc(destination,
(argc + last - first)
* sizeof(char *));
modes = xrealloc(modes,
(argc + last - first)
* sizeof(enum update_mode));
submodule_gitfile = xrealloc(submodule_gitfile,
(argc + last - first)
* sizeof(char *));
}
dst = add_slash(dst);
dst_len = strlen(dst);
for (j = 0; j < last - first; j++) {
const char *path =
active_cache[first + j]->name;
source[argc + j] = path;
destination[argc + j] =
prefix_path(dst, dst_len,
path + length + 1);
modes[argc + j] = INDEX;
submodule_gitfile[argc + j] = NULL;
}
argc += last - first;
}
}
} else if (cache_name_pos(src, length) < 0)
bad = _("not under version control");
else if (lstat(dst, &st) == 0) {
bad = _("destination exists");
if (force) {
/*
* only files can overwrite each other:
* check both source and destination
*/
if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
if (verbose)
warning(_("overwriting '%s'"), dst);
bad = NULL;
} else
bad = _("Cannot overwrite");
}
} else if (string_list_has_string(&src_for_dst, dst))
bad = _("multiple sources for the same target");
else if (is_dir_sep(dst[strlen(dst) - 1]))
bad = _("destination directory does not exist");
else
string_list_insert(&src_for_dst, dst);
if (bad) {
if (ignore_errors) {
if (--argc > 0) {
memmove(source + i, source + i + 1,
(argc - i) * sizeof(char *));
memmove(destination + i,
destination + i + 1,
(argc - i) * sizeof(char *));
memmove(modes + i, modes + i + 1,
(argc - i) * sizeof(enum update_mode));
memmove(submodule_gitfile + i,
submodule_gitfile + i + 1,
(argc - i) * sizeof(char *));
i--;
}
} else
die (_("%s, source=%s, destination=%s"),
bad, src, dst);
}
}
for (i = 0; i < argc; i++) {
const char *src = source[i], *dst = destination[i];
enum update_mode mode = modes[i];
int pos;
if (show_only || verbose)
printf(_("Renaming %s to %s\n"), src, dst);
if (!show_only && mode != INDEX) {
if (rename(src, dst) < 0 && !ignore_errors)
die_errno (_("renaming '%s' failed"), src);
if (submodule_gitfile[i]) {
if (submodule_gitfile[i] != SUBMODULE_WITH_GITDIR)
connect_work_tree_and_git_dir(dst, submodule_gitfile[i]);
if (!update_path_in_gitmodules(src, dst))
gitmodules_modified = 1;
}
}
if (mode == WORKING_DIRECTORY)
continue;
pos = cache_name_pos(src, strlen(src));
assert(pos >= 0);
if (!show_only)
rename_cache_entry_at(pos, dst);
}
if (gitmodules_modified)
stage_updated_gitmodules();
if (active_cache_changed) {
if (write_cache(newfd, active_cache, active_nr) ||
commit_locked_index(&lock_file))
die(_("Unable to write new index file"));
}
return 0;
}
void Directory::scan_dir(const ACE_TString& relative, DDS_Dirent& dir,
unsigned int overflow_index)
{
ACE_TString path = physical_dirname_ + relative;
add_slash(path);
while (DDS_DIRENT* ent = dir.read()) {
if (ent->d_name[0] == ACE_TEXT('.') && (!ent->d_name[1] ||
(ent->d_name[1] == ACE_TEXT('.') && !ent->d_name[2]))) {
continue; // skip '.' and '..'
}
ACE_TString file = path + ent->d_name;
if (is_dir(file.c_str())) {
ACE_TString phys(relative);
add_slash(phys);
phys += ent->d_name;
if (ACE_OS::strncmp(ent->d_name, ACE_TEXT("_overflow."), 10) == 0) {
unsigned int n = ACE_OS::atoi(ent->d_name + 10);
DDS_Dirent overflow(file.c_str());
scan_dir(ent->d_name, overflow, n);
} else if (ACE_OS::strlen(ent->d_name) <= FSS_MAX_FILE_NAME_ENCODED) {
dirs_[b32h_decode(ent->d_name)] = phys;
++overflow_[overflow_index];
} else {
CwdGuard cg(file);
std::ifstream fn("_fullname");
std::string fullname;
if (!std::getline(fn, fullname)) {
throw std::runtime_error("Can't read .../_fullname");
}
ACE_TString full_t(ACE_TEXT_CHAR_TO_TCHAR(fullname.c_str()));
dirs_[full_t] = phys;
++overflow_[overflow_index];
String_Index_t idx = phys.rfind(ACE_TEXT('.'));
if (idx == ACE_TString::npos) {
throw std::runtime_error("Badly formatted long dir name");
}
ACE_TString prefix(phys.c_str(), idx);
unsigned int serial = ACE_OS::atoi(&phys[idx + 1]);
unsigned int& counter = long_names_[prefix];
if (serial >= counter) counter = serial + 1;
}
} else { // regular file
if (ent->d_name[0] != ACE_TEXT('_')) {
files_[b32h_decode(ent->d_name)] = ent->d_name;
++overflow_[overflow_index];
}
}
}
}
int cmd_mv(int argc, const char **argv, const char *prefix)
{
int i, flags, gitmodules_modified = 0;
int verbose = 0, show_only = 0, force = 0, ignore_errors = 0;
struct option builtin_mv_options[] = {
OPT__VERBOSE(&verbose, N_("be verbose")),
OPT__DRY_RUN(&show_only, N_("dry run")),
OPT__FORCE(&force, N_("force move/rename even if target exists")),
OPT_BOOL('k', NULL, &ignore_errors, N_("skip move/rename errors")),
OPT_END(),
};
const char **source, **destination, **dest_path, **submodule_gitfile;
enum update_mode { BOTH = 0, WORKING_DIRECTORY, INDEX } *modes;
struct stat st;
struct string_list src_for_dst = STRING_LIST_INIT_NODUP;
gitmodules_config();
git_config(git_default_config, NULL);
argc = parse_options(argc, argv, prefix, builtin_mv_options,
builtin_mv_usage, 0);
if (--argc < 1)
usage_with_options(builtin_mv_usage, builtin_mv_options);
hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
if (read_cache() < 0)
die(_("index file corrupt"));
source = internal_prefix_pathspec(prefix, argv, argc, 0);
modes = xcalloc(argc, sizeof(enum update_mode));
/*
* Keep trailing slash, needed to let
* "git mv file no-such-dir/" error out, except in the case
* "git mv directory no-such-dir/".
*/
flags = KEEP_TRAILING_SLASH;
if (argc == 1 && is_directory(argv[0]) && !is_directory(argv[1]))
flags = 0;
dest_path = internal_prefix_pathspec(prefix, argv + argc, 1, flags);
submodule_gitfile = xcalloc(argc, sizeof(char *));
if (dest_path[0][0] == '\0')
/* special case: "." was normalized to "" */
destination = internal_prefix_pathspec(dest_path[0], argv, argc, DUP_BASENAME);
else if (!lstat(dest_path[0], &st) &&
S_ISDIR(st.st_mode)) {
dest_path[0] = add_slash(dest_path[0]);
destination = internal_prefix_pathspec(dest_path[0], argv, argc, DUP_BASENAME);
} else {
if (argc != 1)
die(_("destination '%s' is not a directory"), dest_path[0]);
destination = dest_path;
}
/* Checking */
for (i = 0; i < argc; i++) {
const char *src = source[i], *dst = destination[i];
int length, src_is_dir;
const char *bad = NULL;
if (show_only)
printf(_("Checking rename of '%s' to '%s'\n"), src, dst);
length = strlen(src);
if (lstat(src, &st) < 0)
bad = _("bad source");
else if (!strncmp(src, dst, length) &&
(dst[length] == 0 || dst[length] == '/')) {
bad = _("can not move directory into itself");
} else if ((src_is_dir = S_ISDIR(st.st_mode))
&& lstat(dst, &st) == 0)
bad = _("cannot move directory over file");
else if (src_is_dir) {
int first = cache_name_pos(src, length), last;
if (first >= 0)
prepare_move_submodule(src, first,
submodule_gitfile + i);
else if (index_range_of_same_dir(src, length,
&first, &last) < 1)
bad = _("source directory is empty");
else { /* last - first >= 1 */
int j, dst_len, n;
modes[i] = WORKING_DIRECTORY;
n = argc + last - first;
REALLOC_ARRAY(source, n);
REALLOC_ARRAY(destination, n);
REALLOC_ARRAY(modes, n);
REALLOC_ARRAY(submodule_gitfile, n);
dst = add_slash(dst);
dst_len = strlen(dst);
for (j = 0; j < last - first; j++) {
const char *path = active_cache[first + j]->name;
source[argc + j] = path;
destination[argc + j] =
prefix_path(dst, dst_len, path + length + 1);
modes[argc + j] = INDEX;
submodule_gitfile[argc + j] = NULL;
}
argc += last - first;
}
} else if (cache_name_pos(src, length) < 0)
bad = _("not under version control");
else if (lstat(dst, &st) == 0 &&
(!ignore_case || strcasecmp(src, dst))) {
bad = _("destination exists");
if (force) {
/*
* only files can overwrite each other:
* check both source and destination
*/
if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
if (verbose)
warning(_("overwriting '%s'"), dst);
bad = NULL;
} else
bad = _("Cannot overwrite");
}
} else if (string_list_has_string(&src_for_dst, dst))
bad = _("multiple sources for the same target");
else if (is_dir_sep(dst[strlen(dst) - 1]))
bad = _("destination directory does not exist");
else
string_list_insert(&src_for_dst, dst);
if (!bad)
continue;
if (!ignore_errors)
die(_("%s, source=%s, destination=%s"),
bad, src, dst);
if (--argc > 0) {
int n = argc - i;
memmove(source + i, source + i + 1,
n * sizeof(char *));
memmove(destination + i, destination + i + 1,
n * sizeof(char *));
memmove(modes + i, modes + i + 1,
n * sizeof(enum update_mode));
memmove(submodule_gitfile + i, submodule_gitfile + i + 1,
n * sizeof(char *));
i--;
}
}
for (i = 0; i < argc; i++) {
const char *src = source[i], *dst = destination[i];
enum update_mode mode = modes[i];
int pos;
if (show_only || verbose)
printf(_("Renaming %s to %s\n"), src, dst);
if (show_only)
continue;
if (mode != INDEX && rename(src, dst) < 0) {
if (ignore_errors)
continue;
die_errno(_("renaming '%s' failed"), src);
}
if (submodule_gitfile[i]) {
if (submodule_gitfile[i] != SUBMODULE_WITH_GITDIR)
connect_work_tree_and_git_dir(dst, submodule_gitfile[i]);
if (!update_path_in_gitmodules(src, dst))
gitmodules_modified = 1;
}
if (mode == WORKING_DIRECTORY)
continue;
pos = cache_name_pos(src, strlen(src));
assert(pos >= 0);
if (!show_only)
rename_cache_entry_at(pos, dst);
}
if (gitmodules_modified)
stage_updated_gitmodules();
if (active_cache_changed &&
write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
die(_("Unable to write new index file"));
return 0;
}
int cmd_mv(int argc, const char **argv, const char *prefix)
{
int i, newfd;
int verbose = 0, show_only = 0, force = 0, ignore_errors = 0;
struct option builtin_mv_options[] = {
OPT__DRY_RUN(&show_only),
OPT_BOOLEAN('f', "force", &force, "force move/rename even if target exists"),
OPT_BOOLEAN('k', NULL, &ignore_errors, "skip move/rename errors"),
OPT_END(),
};
const char **source, **destination, **dest_path;
enum update_mode { BOTH = 0, WORKING_DIRECTORY, INDEX } *modes;
struct stat st;
struct string_list src_for_dst = STRING_LIST_INIT_NODUP;
git_config(git_default_config, NULL);
argc = parse_options(argc, argv, prefix, builtin_mv_options,
builtin_mv_usage, 0);
if (--argc < 1)
usage_with_options(builtin_mv_usage, builtin_mv_options);
newfd = hold_locked_index(&lock_file, 1);
if (read_cache() < 0)
die("index file corrupt");
source = copy_pathspec(prefix, argv, argc, 0);
modes = xcalloc(argc, sizeof(enum update_mode));
dest_path = copy_pathspec(prefix, argv + argc, 1, 0);
if (dest_path[0][0] == '\0')
/* special case: "." was normalized to "" */
destination = copy_pathspec(dest_path[0], argv, argc, 1);
else if (!lstat(dest_path[0], &st) &&
S_ISDIR(st.st_mode)) {
dest_path[0] = add_slash(dest_path[0]);
destination = copy_pathspec(dest_path[0], argv, argc, 1);
} else {
if (argc != 1)
usage_with_options(builtin_mv_usage, builtin_mv_options);
destination = dest_path;
}
/* Checking */
for (i = 0; i < argc; i++) {
const char *src = source[i], *dst = destination[i];
int length, src_is_dir;
const char *bad = NULL;
if (show_only)
printf("Checking rename of '%s' to '%s'\n", src, dst);
length = strlen(src);
if (lstat(src, &st) < 0)
bad = "bad source";
else if (!strncmp(src, dst, length) &&
(dst[length] == 0 || dst[length] == '/')) {
bad = "can not move directory into itself";
} else if ((src_is_dir = S_ISDIR(st.st_mode))
&& lstat(dst, &st) == 0)
bad = "cannot move directory over file";
else if (src_is_dir) {
const char *src_w_slash = add_slash(src);
int len_w_slash = length + 1;
int first, last;
modes[i] = WORKING_DIRECTORY;
first = cache_name_pos(src_w_slash, len_w_slash);
if (first >= 0)
die ("Huh? %.*s is in index?",
len_w_slash, src_w_slash);
first = -1 - first;
for (last = first; last < active_nr; last++) {
const char *path = active_cache[last]->name;
if (strncmp(path, src_w_slash, len_w_slash))
break;
}
free((char *)src_w_slash);
if (last - first < 1)
bad = "source directory is empty";
else {
int j, dst_len;
if (last - first > 0) {
source = xrealloc(source,
(argc + last - first)
* sizeof(char *));
destination = xrealloc(destination,
(argc + last - first)
* sizeof(char *));
modes = xrealloc(modes,
(argc + last - first)
* sizeof(enum update_mode));
}
dst = add_slash(dst);
dst_len = strlen(dst);
for (j = 0; j < last - first; j++) {
const char *path =
active_cache[first + j]->name;
source[argc + j] = path;
destination[argc + j] =
prefix_path(dst, dst_len,
path + length + 1);
modes[argc + j] = INDEX;
}
argc += last - first;
}
} else if (cache_name_pos(src, length) < 0)
bad = "not under version control";
else if (lstat(dst, &st) == 0) {
bad = "destination exists";
if (force) {
/*
* only files can overwrite each other:
* check both source and destination
*/
if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
warning("%s; will overwrite!", bad);
bad = NULL;
} else
bad = "Cannot overwrite";
}
} else if (string_list_has_string(&src_for_dst, dst))
bad = "multiple sources for the same target";
else
string_list_insert(&src_for_dst, dst);
if (bad) {
if (ignore_errors) {
if (--argc > 0) {
memmove(source + i, source + i + 1,
(argc - i) * sizeof(char *));
memmove(destination + i,
destination + i + 1,
(argc - i) * sizeof(char *));
i--;
}
} else
die ("%s, source=%s, destination=%s",
bad, src, dst);
}
}
for (i = 0; i < argc; i++) {
const char *src = source[i], *dst = destination[i];
enum update_mode mode = modes[i];
int pos;
if (show_only || verbose)
printf("Renaming %s to %s\n", src, dst);
if (!show_only && mode != INDEX &&
rename(src, dst) < 0 && !ignore_errors)
die_errno ("renaming '%s' failed", src);
if (mode == WORKING_DIRECTORY)
continue;
pos = cache_name_pos(src, strlen(src));
assert(pos >= 0);
if (!show_only)
rename_cache_entry_at(pos, dst);
}
if (active_cache_changed) {
if (write_cache(newfd, active_cache, active_nr) ||
commit_locked_index(&lock_file))
die("Unable to write new index file");
}
return 0;
}
static void vcard_printf_text(GString *vcards, const char *text)
{
char field[LEN_MAX];
add_slash(field, text, LEN_MAX, strlen(text));
vcard_printf(vcards, "FN:%s", field);
}