static int inflate_or_link_oldfile(const char *oldpath, const char *infpath,
int compression, struct conf **cconfs)
{
struct stat statp;
if(lstat(oldpath, &statp))
{
logp("could not lstat %s\n", oldpath);
return -1;
}
if(dpth_protocol1_is_compressed(compression, oldpath))
return inflate_oldfile(oldpath, infpath, &statp, cconfs);
// If it was not a compressed file, just hard link it.
// It is possible that infpath already exists, if the server
// was interrupted on a previous run just after this point.
return do_link(oldpath, infpath, &statp, cconfs,
1 /* allow overwrite of infpath */);
}
Link*
Link::
is_unique(InputTree* tree, bool& ans, int& cnt)
{
//cerr << "IU " << *tree << endl;
Link* nlink;
const Term* trm = Term::get(tree->term());
nlink = do_link(trm->toInt(), ans);
if(trm->terminal_p())
{
cnt++;
return nlink;
}
InputTreesIter iti = tree->subTrees().begin();
for( ; iti != tree->subTrees().end() ; iti++)
{
nlink = nlink->is_unique((*iti), ans,cnt);
}
nlink = nlink->do_link(DUMMYVAL, ans);
return nlink;
}
/* o link newname to oldname
* o unlink oldname
* o return the value of unlink, or an error
*
* Note that this does not provide the same behavior as the
* Linux system call (if unlink fails then two links to the
* file could exist).
*/
int
do_rename(const char *oldname, const char *newname)
{
if(strlen(oldname) <=0)
{
dbg(DBG_PRINT,"(GRADING2D) String length of oldname not valid\n");
dbg(DBG_ERROR,"String length of oldname not valid\n");
return -EINVAL;
}
if(strlen(newname) <=0)
{
dbg(DBG_PRINT,"(GRADING2D) String length of newname not valid\n");
dbg(DBG_ERROR,"String length of newname not valid\n");
return -EINVAL;
}
dbg(DBG_PRINT,"(GRADING2D) the name was changed \n");
do_link(oldname,newname);
return do_unlink(oldname);
/*NOT_YET_IMPLEMENTED("VFS: do_rename");
return -1;*/
}
/* Link @subject into the directory @parent; or, if @parent is NULL, set
* @subject as the root of the WIM image.
*
* This is the journaled version, so it can be rolled back. */
static int
journaled_link(struct update_command_journal *j,
struct wim_dentry *subject, struct wim_dentry *parent)
{
struct update_primitive prim;
int ret;
prim.type = LINK_DENTRY;
prim.link.subject = subject;
prim.link.parent = parent;
ret = record_update_primitive(j, prim);
if (ret)
return ret;
do_link(subject, parent, j->root_p);
if (subject->is_orphan) {
list_del(&subject->tmp_list);
subject->is_orphan = 0;
}
return 0;
}
/* o link newname to oldname
* o unlink oldname
* o return the value of unlink, or an error
*
* Note that this does not provide the same behavior as the
* Linux system call (if unlink fails then two links to the
* file could exist).
*/
int
do_rename(const char *oldname, const char *newname)
{
/* NOT_YET_IMPLEMENTED("VFS: do_rename"); */
/*GS: oldname and newname should point to something */
KASSERT(oldname);
KASSERT(newname);
dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_rename) Both are valid names \n");
/*GS: link newname to oldname*/
int retVal = do_link(oldname,newname);
/* GS: NOTE! - need to confirm do_link error values after implemented */
if( retVal < 0)
{
dbg(DBG_PRINT, "(GRADING2C 1.m) (vfs_syscall.c) (do_rename) error do_link, return error\n");
return retVal;
}
/*GS: unlink oldname and return the value of unlink */
return do_unlink(oldname);
}
static int sys_link(link_args_t *arg)
{
link_args_t kern_args;
char *to;
char *from;
int err;
if ((err = copy_from_user(&kern_args, arg, sizeof(link_args_t))) < 0) {
curthr->kt_errno = -err;
return -1;
}
to = user_strdup(&kern_args.to);
if (!to) {
curthr->kt_errno = EINVAL;
return -1;
}
from = user_strdup(&kern_args.from);
if (!from) {
curthr->kt_errno = EINVAL;
kfree(to);
return -1;
}
err = do_link(from, to);
kfree(to);
kfree(from);
if (err < 0) {
curthr->kt_errno = -err;
return -1;
} else {
return err;
}
}
static int inflate_or_link_oldfile(struct asfd *asfd, const char *oldpath,
const char *infpath, struct conf **cconfs, int compression)
{
int ret=0;
struct stat statp;
if(lstat(oldpath, &statp))
{
logp("could not lstat %s\n", oldpath);
return -1;
}
if(dpth_protocol1_is_compressed(compression, oldpath))
{
//logp("inflating...\n");
if(!statp.st_size)
{
// Empty file - cannot inflate.
logp("asked to inflate zero length file: %s\n",
oldpath);
return create_zero_length_file(infpath);
}
if((ret=zlib_inflate(asfd, oldpath, infpath, get_cntr(cconfs))))
logp("zlib_inflate returned: %d\n", ret);
}
else
{
// Not compressed - just hard link it.
if(do_link(oldpath, infpath, &statp, cconfs,
1 /* allow overwrite of infpath */))
return -1;
}
return ret;
}
static int jiggle(struct sdirs *sdirs, struct fdirs *fdirs, struct sbuf *sb,
int hardlinked_current, const char *deltabdir, const char *deltafdir,
const char *sigpath, FILE **delfp, struct conf *cconf)
{
int ret=-1;
struct stat statp;
char *oldpath=NULL;
char *newpath=NULL;
char *finpath=NULL;
char *deltafpath=NULL;
const char *datapth=sb->burp1->datapth.buf;
// If the previous backup was a hardlinked_archive, there will not be
// a currentdup directory - just directly use the file in the previous
// backup.
if(!(oldpath=prepend_s(hardlinked_current?
sdirs->currentdata:fdirs->currentdupdata, datapth))
|| !(newpath=prepend_s(fdirs->datadirtmp, datapth))
|| !(finpath=prepend_s(fdirs->datadir, datapth))
|| !(deltafpath=prepend_s(deltafdir, datapth)))
goto end;
if(!lstat(finpath, &statp) && S_ISREG(statp.st_mode))
{
// Looks like an interrupted jiggle
// did this file already.
static int donemsg=0;
if(!lstat(deltafpath, &statp) && S_ISREG(statp.st_mode))
{
logp("deleting unneeded forward delta: %s\n",
deltafpath);
unlink(deltafpath);
}
if(!donemsg)
{
logp("skipping already present file: %s\n", finpath);
logp("to save log space, skips of other already present files will not be logged\n");
donemsg++;
}
}
else if(mkpath(&finpath, fdirs->datadir))
{
logp("could not create path for: %s\n", finpath);
goto end;
}
else if(mkpath(&newpath, fdirs->datadirtmp))
{
logp("could not create path for: %s\n", newpath);
goto end;
}
else if(!lstat(deltafpath, &statp) && S_ISREG(statp.st_mode))
{
int lrs;
char *infpath=NULL;
// Got a forward patch to do.
// First, need to gunzip the old file,
// otherwise the librsync patch will take
// forever, because it will be doing seeks
// all over the place, and gzseeks are slow.
if(!(infpath=prepend_s(deltafdir, "inflate")))
{
log_out_of_memory(__func__);
goto end;
}
//logp("Fixing up: %s\n", datapth);
if(inflate_or_link_oldfile(oldpath, infpath,
sb->compression, cconf))
{
logp("error when inflating old file: %s\n", oldpath);
free(infpath);
goto end;
}
if((lrs=do_patch(NULL, infpath, deltafpath, newpath,
cconf->compression,
sb->compression /* from the manifest */, cconf)))
{
logp("WARNING: librsync error when patching %s: %d\n",
oldpath, lrs);
cntr_add(cconf->cntr, CMD_WARNING, 1);
// Try to carry on with the rest of the backup
// regardless.
//ret=-1;
// Remove anything that got written.
unlink(newpath);
unlink(infpath);
free(infpath);
// First, note that we want to remove this entry from
// the manifest.
if(!*delfp
&& !(*delfp=open_file(fdirs->deletionsfile, "ab")))
{
// Could not mark this file as deleted. Fatal.
goto end;
}
if(sbufl_to_manifest(sb, *delfp, NULL))
goto end;
if(fflush(*delfp))
{
logp("error fflushing deletions file in %s: %s\n", __func__, strerror(errno));
goto end;
}
ret=0;
goto end;
}
// Get rid of the inflated old file.
unlink(infpath);
free(infpath);
// Need to generate a reverse diff, unless we are keeping a
// hardlinked archive.
if(!hardlinked_current)
{
if(gen_rev_delta(sigpath, deltabdir,
oldpath, newpath, datapth, sb, cconf))
goto end;
}
// Power interruptions should be recoverable. If it happens
// before this point, the data jiggle for this file has to be
// done again.
// Once finpath is in place, no more jiggle is required.
// Use the fresh new file.
// Rename race condition is of no consequence, because finpath
// will just get recreated automatically.
if(do_rename(newpath, finpath))
goto end;
// Remove the forward delta, as it is no longer needed. There
// is a reverse diff and the finished finished file is in place.
//logp("Deleting delta.forward...\n");
unlink(deltafpath);
// Remove the old file. If a power cut happens just before
// this, the old file will hang around forever.
// FIX THIS: maybe put in something to detect this.
// ie, both a reverse delta and the old file exist.
if(!hardlinked_current)
{
//logp("Deleting oldpath...\n");
unlink(oldpath);
}
}
else if(!lstat(newpath, &statp) && S_ISREG(statp.st_mode))
{
// Use the fresh new file.
// This needs to happen after checking
// for the forward delta, because the
// patching stuff writes to newpath.
// Rename race condition is of no consequence, because finpath
// will just get recreated automatically.
//logp("Using newly received file\n");
if(do_rename(newpath, finpath))
goto end;
}
else if(!lstat(oldpath, &statp) && S_ISREG(statp.st_mode))
{
// Use the old unchanged file.
// Hard link it first.
//logp("Hard linking to old file: %s\n", datapth);
if(do_link(oldpath, finpath, &statp, cconf,
0 /* do not overwrite finpath (should never need to) */))
goto end;
else
{
// If we are not keeping a hardlinked
// archive, delete the old link.
if(!hardlinked_current)
{
//logp("Unlinking old file: %s\n", oldpath);
unlink(oldpath);
}
}
}
else
{
logp("could not find: %s\n", oldpath);
goto end;
}
ret=0;
end:
free_w(&oldpath);
free_w(&newpath);
free_w(&finpath);
free_w(&deltafpath);
return ret;
}
void
process_command(int descr, dbref player, char *command)
{
char *arg1;
char *arg2;
char *full_command;
char *p; /* utility */
char pbuf[BUFFER_LEN];
char xbuf[BUFFER_LEN];
char ybuf[BUFFER_LEN];
struct timeval starttime;
struct timeval endtime;
double totaltime;
if (command == 0)
abort();
/* robustify player */
if (player < 0 || player >= db_top ||
(Typeof(player) != TYPE_PLAYER && Typeof(player) != TYPE_THING)) {
log_status("process_command: bad player %d", player);
return;
}
if ((tp_log_commands || Wizard(OWNER(player)))) {
if (!(FLAGS(player) & (INTERACTIVE | READMODE))) {
if (!*command) {
return;
}
log_command("%s: %s", whowhere(player), command);
} else {
if (tp_log_interactive) {
log_command("%s: %s%s", whowhere(player),
(FLAGS(player) & (READMODE)) ? "[READ] " : "[INTERP] ", command);
}
}
}
if (FLAGS(player) & INTERACTIVE) {
interactive(descr, player, command);
return;
}
/* eat leading whitespace */
while (*command && isspace(*command))
command++;
/* Disable null command once past READ line */
if (!*command)
return;
/* check for single-character commands */
if (!tp_enable_prefix) {
if (*command == SAY_TOKEN) {
snprintf(pbuf, sizeof(pbuf), "say %s", command + 1);
command = &pbuf[0];
} else if (*command == POSE_TOKEN) {
snprintf(pbuf, sizeof(pbuf), "pose %s", command + 1);
command = &pbuf[0];
} else if (*command == EXIT_DELIMITER) {
snprintf(pbuf, sizeof(pbuf), "delimiter %s", command + 1);
command = &pbuf[0];
}
}
/* profile how long command takes. */
gettimeofday(&starttime, NULL);
/* if player is a wizard, and uses overide token to start line... */
/* ... then do NOT run actions, but run the command they specify. */
if (!(TrueWizard(OWNER(player)) && (*command == OVERIDE_TOKEN))) {
if (can_move(descr, player, command, 0)) {
do_move(descr, player, command, 0); /* command is exact match for exit */
*match_args = 0;
*match_cmdname = 0;
} else {
if (tp_enable_prefix) {
if (*command == SAY_TOKEN) {
snprintf(pbuf, sizeof(pbuf), "say %s", command + 1);
command = &pbuf[0];
} else if (*command == POSE_TOKEN) {
snprintf(pbuf, sizeof(pbuf), "pose %s", command + 1);
command = &pbuf[0];
} else if (*command == EXIT_DELIMITER) {
snprintf(pbuf, sizeof(pbuf), "delimiter %s", command + 1);
command = &pbuf[0];
} else {
goto bad_pre_command;
}
if (can_move(descr, player, command, 0)) {
do_move(descr, player, command, 0); /* command is exact match for exit */
*match_args = 0;
*match_cmdname = 0;
} else {
goto bad_pre_command;
}
} else {
goto bad_pre_command;
}
}
} else {
bad_pre_command:
if (TrueWizard(OWNER(player)) && (*command == OVERIDE_TOKEN))
command++;
full_command = strcpyn(xbuf, sizeof(xbuf), command);
for (; *full_command && !isspace(*full_command); full_command++) ;
if (*full_command)
full_command++;
/* find arg1 -- move over command word */
command = strcpyn(ybuf, sizeof(ybuf), command);
for (arg1 = command; *arg1 && !isspace(*arg1); arg1++) ;
/* truncate command */
if (*arg1)
*arg1++ = '\0';
/* remember command for programs */
strcpyn(match_args, sizeof(match_args), full_command);
strcpyn(match_cmdname, sizeof(match_cmdname), command);
/* move over spaces */
while (*arg1 && isspace(*arg1))
arg1++;
/* find end of arg1, start of arg2 */
for (arg2 = arg1; *arg2 && *arg2 != ARG_DELIMITER; arg2++) ;
/* truncate arg1 */
for (p = arg2 - 1; p >= arg1 && isspace(*p); p--)
*p = '\0';
/* go past delimiter if present */
if (*arg2)
*arg2++ = '\0';
while (*arg2 && isspace(*arg2))
arg2++;
switch (command[0]) {
case '@':
switch (command[1]) {
case 'a':
case 'A':
/* @action, @armageddon, @attach */
switch (command[2]) {
case 'c':
case 'C':
Matched("@action");
NOGUEST("@action", player);
BUILDERONLY("@action", player);
do_action(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
if (strcmp(command, "@armageddon"))
goto bad;
/*
WIZARDONLY("@armageddon", player);
PLAYERONLY("@armageddon", player);
*/
do_armageddon(player, full_command);
break;
case 't':
case 'T':
Matched("@attach");
NOGUEST("@attach", player);
BUILDERONLY("@attach", player);
do_attach(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'b':
case 'B':
/* @bless, @boot */
switch (command[2]) {
case 'l':
case 'L':
Matched("@bless");
WIZARDONLY("@bless", player);
PLAYERONLY("@bless", player);
NOFORCE("@bless", force_level, player);
do_bless(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("@boot");
WIZARDONLY("@boot", player);
PLAYERONLY("@boot", player);
do_boot(player, arg1);
break;
default:
goto bad;
}
break;
case 'c':
case 'C':
/* @chlock, @chown, @chown_lock, @clone,
@conlock, @contents, @create, @credits */
switch (command[2]) {
case 'h':
case 'H':
switch (command[3]) {
case 'l':
case 'L':
Matched("@chlock");
NOGUEST("@chlock", player);
set_standard_lock(descr, player, arg1, MESGPROP_CHLOCK, "Chown Lock", arg2);
break;
case 'o':
case 'O':
if(strlen(command) < 7) {
Matched("@chown");
do_chown(descr, player, arg1, arg2);
} else {
Matched("@chown_lock");
NOGUEST("@chown_lock", player);
set_standard_lock(descr, player, arg1, MESGPROP_CHLOCK, "Chown Lock", arg2);
}
break;
default:
goto bad;
}
break;
case 'l':
case 'L':
Matched("@clone");
NOGUEST("@clone", player);
BUILDERONLY("@clone", player);
do_clone(descr, player, arg1);
break;
case 'o':
case 'O':
switch (command[4]) {
case 'l':
case 'L':
Matched("@conlock");
NOGUEST("@conlock", player);
set_standard_lock(descr, player, arg1, MESGPROP_CONLOCK, "Container Lock", arg2);
break;
case 't':
case 'T':
Matched("@contents");
do_contents(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
if (string_compare(command, "@credits")) {
Matched("@create");
NOGUEST("@create", player);
BUILDERONLY("@create", player);
do_create(player, arg1, arg2);
} else {
do_credits(player);
}
break;
default:
goto bad;
}
break;
case 'd':
case 'D':
/* @dbginfo, @describe, @dig, @doing,
@drop, @dump */
switch (command[2]) {
#ifdef DISKBASE
case 'b':
case 'B':
Matched("@dbginfo");
WIZARDONLY("@dbginfo", player);
diskbase_debug(player);
break;
#endif
case 'e':
case 'E':
Matched("@describe");
NOGUEST("@describe", player);
set_standard_property(descr, player, arg1, MESGPROP_DESC, "Object Description", arg2);
break;
case 'i':
case 'I':
Matched("@dig");
NOGUEST("@dig", player);
BUILDERONLY("@dig", player);
do_dig(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("@doing");
if (!tp_who_doing)
goto bad;
NOGUEST("@doing", player);
set_standard_property(descr, player, arg1, MESGPROP_DOING, "Doing", arg2);
break;
case 'r':
case 'R':
Matched("@drop");
NOGUEST("@drop", player);
set_standard_property(descr, player, arg1, MESGPROP_DROP, "Drop Message", arg2);
break;
case 'u':
case 'U':
Matched("@dump");
WIZARDONLY("@dump", player);
PLAYERONLY("@dump", player);
do_dump(player, full_command);
break;
default:
goto bad;
}
break;
case 'e':
case 'E':
/* @edit, @entrances, @examine */
switch (command[2]) {
case 'd':
case 'D':
Matched("@edit");
NOGUEST("@edit", player);
PLAYERONLY("@edit", player);
MUCKERONLY("@edit", player);
do_edit(descr, player, arg1);
break;
case 'n':
case 'N':
Matched("@entrances");
do_entrances(descr, player, arg1, arg2);
break;
case 'x':
case 'X':
Matched("@examine");
GODONLY("@examine", player);
sane_dump_object(player, arg1);
break;
default:
goto bad;
}
break;
case 'f':
case 'F':
/* @fail, @find, @flock, @force, @force_lock */
switch (command[2]) {
case 'a':
case 'A':
Matched("@fail");
NOGUEST("@fail", player);
set_standard_property(descr, player, arg1, MESGPROP_FAIL, "Fail Message", arg2);
break;
case 'i':
case 'I':
Matched("@find");
do_find(player, arg1, arg2);
break;
case 'l':
case 'L':
Matched("@flock");
NOGUEST("@flock", player);
NOFORCE("@flock", force_level, player);
set_standard_lock(descr, player, arg1, MESGPROP_FLOCK, "Force Lock", arg2);
break;
case 'o':
case 'O':
if(strlen(command) < 7) {
Matched("@force");
do_force(descr, player, arg1, arg2);
} else {
Matched("@force_lock");
NOGUEST("@force_lock", player);
NOFORCE("@force_lock", force_level, player);
set_standard_lock(descr, player, arg1, MESGPROP_FLOCK, "Force Lock", arg2);
}
break;
default:
goto bad;
}
break;
case 'h':
case 'H':
/* @hashes */
Matched("@hashes");
do_hashes(player, arg1);
break;
case 'i':
case 'I':
/* @idescribe */
Matched("@idescribe");
NOGUEST("@idescribe", player);
set_standard_property(descr, player, arg1, MESGPROP_IDESC, "Inside Description", arg2);
break;
case 'k':
case 'K':
/* @kill */
Matched("@kill");
do_dequeue(descr, player, arg1);
break;
case 'l':
case 'L':
/* @link, @list, @lock */
switch (command[2]) {
case 'i':
case 'I':
switch (command[3]) {
case 'n':
case 'N':
Matched("@link");
NOGUEST("@link", player);
do_link(descr, player, arg1, arg2);
break;
case 's':
case 'S':
Matched("@list");
match_and_list(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'o':
case 'O':
Matched("@lock");
NOGUEST("@lock", player);
set_standard_lock(descr, player, arg1, MESGPROP_LOCK, "Lock", arg2);
break;
default:
goto bad;
}
break;
case 'm':
case 'M':
/* @mcpedit, @mcpprogram, @memory, @mpitops,
@muftops */
switch (command[2]) {
#ifdef MCP_SUPPORT
case 'c':
case 'C':
if (string_prefix("@mcpedit", command)) {
Matched("@mcpedit");
NOGUEST("@mcpedit", player);
PLAYERONLY("@mcpedit", player);
MUCKERONLY("@mcpedit", player);
do_mcpedit(descr, player, arg1);
break;
} else {
Matched("@mcpprogram");
NOGUEST("@mcpprogram", player);
PLAYERONLY("@mcpprogram", player);
MUCKERONLY("@mcpprogram", player);
do_mcpprogram(descr, player, arg1);
break;
}
#endif
#ifndef NO_MEMORY_COMMAND
case 'e':
case 'E':
Matched("@memory");
WIZARDONLY("@memory", player);
do_memory(player);
break;
#endif
case 'p':
case 'P':
Matched("@mpitops");
WIZARDONLY("@mpitops", player);
do_mpi_topprofs(player, arg1);
break;
case 'u':
case 'U':
Matched("@muftops");
WIZARDONLY("@muftops", player);
do_muf_topprofs(player, arg1);
break;
default:
goto bad;
}
break;
case 'n':
case 'N':
/* @name, @newpassword */
switch (command[2]) {
case 'a':
case 'A':
Matched("@name");
NOGUEST("@name", player);
do_name(descr, player, arg1, arg2);
break;
case 'e':
case 'E':
if (strcmp(command, "@newpassword"))
goto bad;
WIZARDONLY("@newpassword", player);
PLAYERONLY("@newpassword", player);
do_newpassword(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'o':
case 'O':
/* @odrop, @oecho, @ofail, @open, @osuccess,
@owned */
switch (command[2]) {
case 'd':
case 'D':
Matched("@odrop");
NOGUEST("@odrop", player);
set_standard_property(descr, player, arg1, MESGPROP_ODROP, "ODrop Message", arg2);
break;
case 'e':
case 'E':
Matched("@oecho");
NOGUEST("@oecho", player);
set_standard_property(descr, player, arg1, MESGPROP_OECHO, "Outside-echo Prefix", arg2);
break;
case 'f':
case 'F':
Matched("@ofail");
NOGUEST("@ofail", player);
set_standard_property(descr, player, arg1, MESGPROP_OFAIL, "OFail Message", arg2);
break;
case 'p':
case 'P':
Matched("@open");
NOGUEST("@open", player);
BUILDERONLY("@open", player);
do_open(descr, player, arg1, arg2);
break;
case 's':
case 'S':
Matched("@osuccess");
NOGUEST("@osuccess", player);
set_standard_property(descr, player, arg1, MESGPROP_OSUCC, "OSuccess Message", arg2);
break;
case 'w':
case 'W':
Matched("@owned");
do_owned(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'p':
case 'P':
/* @password, @pcreate, @pecho, @program,
@propset, @ps */
switch (command[2]) {
case 'a':
case 'A':
Matched("@password");
PLAYERONLY("@password", player);
NOGUEST("@password", player);
do_password(player, arg1, arg2);
break;
case 'c':
case 'C':
Matched("@pcreate");
WIZARDONLY("@pcreate", player);
PLAYERONLY("@pcreate", player);
do_pcreate(player, arg1, arg2);
break;
case 'e':
case 'E':
Matched("@pecho");
NOGUEST("@pecho", player);
set_standard_property(descr, player, arg1, MESGPROP_PECHO, "Puppet-echo Prefix", arg2);
break;
case 'r':
case 'R':
if (string_prefix("@program", command)) {
Matched("@program");
NOGUEST("@program", player);
PLAYERONLY("@program", player);
MUCKERONLY("@program", player);
do_prog(descr, player, arg1);
break;
} else {
Matched("@propset");
NOGUEST("@propset", player);
do_propset(descr, player, arg1, arg2);
break;
}
case 's':
case 'S':
Matched("@ps");
list_events(player);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
/* @recycle, @reconfiguressl, @relink, @restart, @restrict */
switch (command[3]) {
case 'c':
case 'C':
#ifdef USE_SSL
if (!strcmp(command, "@reconfiguressl")) {
WIZARDONLY("@reconfiguressl", player);
PLAYERONLY("@reconfiguressl", player);
do_reconfigure_ssl(player);
break;
}
#endif
Matched("@recycle");
NOGUEST("@recycle", player);
do_recycle(descr, player, arg1);
break;
case 'l':
case 'L':
Matched("@relink");
NOGUEST("@relink", player);
do_relink(descr, player, arg1, arg2);
break;
case 's':
case 'S':
if (!strcmp(command, "@restart")) {
/*
WIZARDONLY("@restart", player);
PLAYERONLY("@restart", player);
*/
do_restart(player);
} else if (!strcmp(command, "@restrict")) {
WIZARDONLY("@restrict", player);
PLAYERONLY("@restrict", player);
do_restrict(player, arg1);
} else {
goto bad;
}
break;
default:
goto bad;
}
break;
case 's':
case 'S':
/* @sanity, @sanchange, @sanfix, @set,
@shutdown, @stats, @success, @sweep */
switch (command[2]) {
case 'a':
case 'A':
if (!strcmp(command, "@sanity")) {
GODONLY("@sanity", player);
sanity(player);
} else if (!strcmp(command, "@sanchange")) {
GODONLY("@sanchange", player);
sanechange(player, full_command);
} else if (!strcmp(command, "@sanfix")) {
GODONLY("@sanfix", player);
sanfix(player);
} else {
goto bad;
}
break;
case 'e':
case 'E':
Matched("@set");
NOGUEST("@set", player);
do_set(descr, player, arg1, arg2);
break;
case 'h':
case 'H':
if (strcmp(command, "@shutdown"))
goto bad;
/*
WIZARDONLY("@shutdown", player);
PLAYERONLY("@shutdown", player);
*/
do_shutdown(player);
break;
case 't':
case 'T':
Matched("@stats");
do_stats(player, arg1);
break;
case 'u':
case 'U':
Matched("@success");
NOGUEST("@success", player);
set_standard_property(descr, player, arg1, MESGPROP_SUCC, "Success Message", arg2);
break;
case 'w':
case 'W':
Matched("@sweep");
do_sweep(descr, player, arg1);
break;
default:
goto bad;
}
break;
case 't':
case 'T':
/* @teleport, @toad, @trace, @tune */
switch (command[2]) {
case 'e':
case 'E':
Matched("@teleport");
do_teleport(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
if (!strcmp(command, "@toad")) {
WIZARDONLY("@toad", player);
PLAYERONLY("@toad", player);
do_toad(descr, player, arg1, arg2);
} else if (!strcmp(command, "@tops")) {
WIZARDONLY("@tops", player);
do_all_topprofs(player, arg1);
} else {
goto bad;
}
break;
case 'r':
case 'R':
Matched("@trace");
do_trace(descr, player, arg1, atoi(arg2));
break;
case 'u':
case 'U':
Matched("@tune");
WIZARDONLY("@tune", player);
PLAYERONLY("@tune", player);
do_tune(player, arg1, arg2, !!strchr(full_command, ARG_DELIMITER));
break;
default:
goto bad;
}
break;
case 'u':
case 'U':
/* @unbless, @unlink, @unlock, @uncompile,
@usage */
switch (command[2]) {
case 'N':
case 'n':
if (string_prefix(command, "@unb")) {
Matched("@unbless");
WIZARDONLY("@unbless", player);
PLAYERONLY("@unbless", player);
NOFORCE("@unbless", force_level, player);
do_unbless(descr, player, arg1, arg2);
} else if (string_prefix(command, "@unli")) {
Matched("@unlink");
NOGUEST("@unlink", player);
do_unlink(descr, player, arg1);
} else if (string_prefix(command, "@unlo")) {
Matched("@unlock");
NOGUEST("@unlock", player);
set_standard_lock(descr, player, arg1, MESGPROP_LOCK, "Lock", "");
} else if (string_prefix(command, "@uncom")) {
Matched("@uncompile");
WIZARDONLY("@uncompile", player);
PLAYERONLY("@uncompile", player);
do_uncompile(player);
} else {
goto bad;
}
break;
#ifndef NO_USAGE_COMMAND
case 'S':
case 's':
Matched("@usage");
WIZARDONLY("@usage", player);
do_usage(player);
break;
#endif
default:
goto bad;
break;
}
break;
case 'v':
case 'V':
/* @version */
Matched("@version");
do_version(player);
break;
case 'w':
case 'W':
/* @wall */
if (strcmp(command, "@wall"))
goto bad;
WIZARDONLY("@wall", player);
PLAYERONLY("@wall", player);
do_wall(player, full_command);
break;
default:
goto bad;
}
break;
case 'd':
case 'D':
/* disembark, drop */
switch (command[1]) {
case 'i':
case 'I':
Matched("disembark");
do_leave(descr, player);
break;
case 'r':
case 'R':
Matched("drop");
do_drop(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'e':
case 'E':
/* examine */
Matched("examine");
do_examine(descr, player, arg1, arg2);
break;
case 'g':
case 'G':
/* get, give, goto, gripe */
switch (command[1]) {
case 'e':
case 'E':
Matched("get");
do_get(descr, player, arg1, arg2);
break;
case 'i':
case 'I':
Matched("give");
do_give(descr, player, arg1, atoi(arg2));
break;
case 'o':
case 'O':
Matched("goto");
do_move(descr, player, arg1, 0);
break;
case 'r':
case 'R':
if (string_compare(command, "gripe"))
goto bad;
do_gripe(player, full_command);
break;
default:
goto bad;
}
break;
case 'h':
case 'H':
/* help */
Matched("help");
do_help(player, arg1, arg2);
break;
case 'i':
case 'I':
/* inventory, info */
if (string_compare(command, "info")) {
Matched("inventory");
do_inventory(player);
} else {
Matched("info");
do_info(player, arg1, arg2);
}
break;
case 'k':
case 'K':
/* kill */
Matched("kill");
do_kill(descr, player, arg1, atoi(arg2));
break;
case 'l':
case 'L':
/* leave, look */
if (string_prefix("look", command)) {
Matched("look");
do_look_at(descr, player, arg1, arg2);
break;
} else {
Matched("leave");
do_leave(descr, player);
break;
}
case 'm':
case 'M':
/* man, motd, move, mpi */
if (string_prefix(command, "move")) {
do_move(descr, player, arg1, 0);
break;
} else if (!string_compare(command, "motd")) {
do_motd(player, full_command);
break;
} else if (!string_compare(command, "mpi")) {
do_mpihelp(player, arg1, arg2);
break;
} else {
if (string_compare(command, "man"))
goto bad;
do_man(player, (!*arg1 && !*arg2 && arg1 != arg2) ? "=" : arg1, arg2);
}
break;
case 'n':
case 'N':
/* news */
Matched("news");
do_news(player, arg1, arg2);
break;
case 'p':
case 'P':
/* page, pose, put */
switch (command[1]) {
case 'a':
case 'A':
Matched("page");
do_page(player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("pose");
do_pose(player, full_command);
break;
case 'u':
case 'U':
Matched("put");
do_drop(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
/* read, rob */
switch (command[1]) {
case 'e':
case 'E':
Matched("read"); /* undocumented alias for look */
do_look_at(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("rob");
do_rob(descr, player, arg1);
break;
default:
goto bad;
}
break;
case 's':
case 'S':
/* say, score */
switch (command[1]) {
case 'a':
case 'A':
Matched("say");
do_say(player, full_command);
break;
case 'c':
case 'C':
Matched("score");
do_score(player);
break;
default:
goto bad;
}
break;
case 't':
case 'T':
/* take, throw */
switch (command[1]) {
case 'a':
case 'A':
Matched("take");
do_get(descr, player, arg1, arg2);
break;
case 'h':
case 'H':
Matched("throw");
do_drop(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'w':
case 'W':
/* whisper */
Matched("whisper");
do_whisper(descr, player, arg1, arg2);
break;
default:
bad:
if (tp_m3_huh != 0)
{
char hbuf[BUFFER_LEN];
snprintf(hbuf,BUFFER_LEN,"HUH? %s", command);
if(can_move(descr, player, hbuf, 3)) {
do_move(descr, player, hbuf, 3);
*match_args = 0;
*match_cmdname = 0;
break;
}
}
notify(player, tp_huh_mesg);
if (tp_log_failed_commands && !controls(player, LOCATION(player))) {
log_status("HUH from %s(%d) in %s(%d)[%s]: %s %s",
NAME(player), player, NAME(LOCATION(player)),
LOCATION(player),
NAME(OWNER(LOCATION(player))), command, full_command);
}
break;
}
}
/* calculate time command took. */
gettimeofday(&endtime, NULL);
if (starttime.tv_usec > endtime.tv_usec) {
endtime.tv_usec += 1000000;
endtime.tv_sec -= 1;
}
endtime.tv_usec -= starttime.tv_usec;
endtime.tv_sec -= starttime.tv_sec;
totaltime = endtime.tv_sec + (endtime.tv_usec * 1.0e-6);
if (totaltime > (tp_cmd_log_threshold_msec / 1000.0)) {
log2file(LOG_CMD_TIMES, "%6.3fs, %.16s: %s: %s",
totaltime, ctime((time_t *)&starttime.tv_sec),
whowhere(player), command);
}
}
int replay(const char *log_data) {
uint64_t fv,lv; //fv = filesystem's version lv = log's version
uint32_t ts;
uint8_t status;
char buff[10000];
char *ptr;
char* errormsgs[]={ ERROR_STRINGS };
char *test_ptr;
sprintf(buff,"%s",log_data);
ptr = buff;
//for test
test_ptr = buff;
fv = shadow_fs_getversion();
GETU64(lv,ptr);
if(lv < fv) {
MFSLOG(LOG_ERR,"the changelog's verison %lu is smaller than filesystem's version %lu",lv,fv);
//more complicated method to ensure consistency
} else {
status = ERROR_MISMATCH;
EAT(ptr,lv,':');
EAT(ptr,lv,' ');
GETU32(ts,ptr);
EAT(ptr,lv,'|');
switch (*ptr) {
case 'A':
if (strncmp(ptr,"ACCESS",6)==0) {
status = do_access(lv,ts,ptr+6);
} else if (strncmp(ptr,"ATTR",4)==0) {
status = do_attr(lv,ts,ptr+4);
} else if (strncmp(ptr,"APPEND",6)==0) {
status = do_append(lv,ts,ptr+6);
} else if (strncmp(ptr,"AQUIRE",6)==0) {
status = do_aquire(lv,ts,ptr+6);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'C':
if (strncmp(ptr,"CREATE",6)==0) {
status = do_create(lv,ts,ptr+6);
} else if (strncmp(ptr,"CUSTOMER",8)==0) { // deprecated
status = do_session(lv,ts,ptr+8);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'E':
if (strncmp(ptr,"EMPTYTRASH",10)==0) {
status = do_emptytrash(lv,ts,ptr+10);
} else if (strncmp(ptr,"EMPTYRESERVED",13)==0) {
status = do_emptyreserved(lv,ts,ptr+13);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'F':
if (strncmp(ptr,"FREEINODES",10)==0) {
status = do_freeinodes(lv,ts,ptr+10);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'I':
if (strncmp(ptr,"INCVERSION",10)==0) {
status = do_incversion(lv,ts,ptr+10);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'L':
if (strncmp(ptr,"LENGTH",6)==0) {
status = do_length(lv,ts,ptr+6);
} else if (strncmp(ptr,"LINK",4)==0) {
status = do_link(lv,ts,ptr+4);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'M':
if (strncmp(ptr,"MOVE",4)==0) {
status = do_move(lv,ts,ptr+4);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'P':
if (strncmp(ptr,"PURGE",5)==0) {
status = do_purge(lv,ts,ptr+5);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'R':
if (strncmp(ptr,"RELEASE",7)==0) {
status = do_release(lv,ts,ptr+7);
} else if (strncmp(ptr,"REPAIR",6)==0) {
status = do_repair(lv,ts,ptr+6);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'S':
if (strncmp(ptr,"SETEATTR",8)==0) {
status = do_seteattr(lv,ts,ptr+8);
} else if (strncmp(ptr,"SETGOAL",7)==0) {
status = do_setgoal(lv,ts,ptr+7);
} else if (strncmp(ptr,"SETPATH",7)==0) {
status = do_setpath(lv,ts,ptr+7);
} else if (strncmp(ptr,"SETTRASHTIME",12)==0) {
status = do_settrashtime(lv,ts,ptr+12);
} else if (strncmp(ptr,"SNAPSHOT",8)==0) {
status = do_snapshot(lv,ts,ptr+8);
} else if (strncmp(ptr,"SYMLINK",7)==0) {
status = do_symlink(lv,ts,ptr+7);
} else if (strncmp(ptr,"SESSION",7)==0) {
status = do_session(lv,ts,ptr+7);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'T':
if (strncmp(ptr,"TRUNC",5)==0) {
status = do_trunc(lv,ts,ptr+5);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'U':
if (strncmp(ptr,"UNLINK",6)==0) {
status = do_unlink(lv,ts,ptr+6);
} else if (strncmp(ptr,"UNDEL",5)==0) {
status = do_undel(lv,ts,ptr+5);
} else if (strncmp(ptr,"UNLOCK",6)==0) {
status = do_unlock(lv,ts,ptr+6);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'W':
if (strncmp(ptr,"WRITE",5)==0) {
status = do_write(lv,ts,ptr+5);
} else {
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
default:
MFSLOG(LOG_ERR,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
/**
* if master is down, slave switch, we may missed some metadata
* return 0 to let the process continue, otherwise, we will reply the
* log forever.
*
* Dongyang, Zhang
*/
if (status!=STATUS_OK) {
MFSLOG(LOG_ERR,"%"PRIu64": error: %"PRIu8" (%s),the log is (%s)",lv,status,errormsgs[status],test_ptr);
// syslog(LOG_ERR,"%"PRIu64": error: %"PRIu8" (%s)",lv,status,errormsgs[status]);
return 1;
}
fv = shadow_fs_getversion();
if (lv+1!=fv) {
MFSLOG(LOG_ERR,"%"PRIu64": version mismatch fsversion:%"PRIu64"",lv,fv);
return 1;
}
}
return 0;
}
int restore(void) {
FILE *fd;
char buff[10000];
char *ptr;
uint64_t v,lv;
uint32_t ts;
uint8_t status;
uint32_t dplen;
char *datapath = NULL;
char *logpath = NULL;
char* errormsgs[]={ ERROR_STRINGS };
v = shadow_fs_getversion();
lv = 0;
MFSLOG(LOG_NOTICE,"meta data version: %"PRIu64"",v);
datapath = strdup(DATA_PATH);
dplen = strlen(datapath);
logpath = malloc(dplen+sizeof("/changelog.0.mfs"));
memcpy(logpath,datapath,dplen);
memcpy(logpath+dplen,"/changelog.0.mfs",sizeof("/changelog.0.mfs"));
fd = fopen(logpath,"r");
if (fd==NULL) {
MFSLOG(LOG_NOTICE,"can't open changemeta file: %s",logpath);
return 1;
}
while (fgets(buff,10000,fd)) {
ptr = buff;
GETU64(lv,ptr);
if (lv<v) {
// skip
} else {
status = ERROR_MISMATCH;
EAT(ptr,lv,':');
EAT(ptr,lv,' ');
GETU32(ts,ptr);
EAT(ptr,lv,'|');
switch (*ptr) {
case 'A':
if (strncmp(ptr,"ACCESS",6)==0) {
status = do_access(lv,ts,ptr+6);
} else if (strncmp(ptr,"ATTR",4)==0) {
status = do_attr(lv,ts,ptr+4);
} else if (strncmp(ptr,"APPEND",6)==0) {
status = do_append(lv,ts,ptr+6);
} else if (strncmp(ptr,"AQUIRE",6)==0) {
status = do_aquire(lv,ts,ptr+6);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'C':
if (strncmp(ptr,"CREATE",6)==0) {
status = do_create(lv,ts,ptr+6);
} else if (strncmp(ptr,"CUSTOMER",8)==0) { // deprecated
status = do_session(lv,ts,ptr+8);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'E':
if (strncmp(ptr,"EMPTYTRASH",10)==0) {
status = do_emptytrash(lv,ts,ptr+10);
} else if (strncmp(ptr,"EMPTYRESERVED",13)==0) {
status = do_emptyreserved(lv,ts,ptr+13);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'F':
if (strncmp(ptr,"FREEINODES",10)==0) {
status = do_freeinodes(lv,ts,ptr+10);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'I':
if (strncmp(ptr,"INCVERSION",10)==0) {
status = do_incversion(lv,ts,ptr+10);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'L':
if (strncmp(ptr,"LENGTH",6)==0) {
status = do_length(lv,ts,ptr+6);
} else if (strncmp(ptr,"LINK",4)==0) {
status = do_link(lv,ts,ptr+4);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'M':
if (strncmp(ptr,"MOVE",4)==0) {
status = do_move(lv,ts,ptr+4);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'P':
if (strncmp(ptr,"PURGE",5)==0) {
status = do_purge(lv,ts,ptr+5);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'R':
if (strncmp(ptr,"RELEASE",7)==0) {
status = do_release(lv,ts,ptr+7);
} else if (strncmp(ptr,"REPAIR",6)==0) {
status = do_repair(lv,ts,ptr+6);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'S':
if (strncmp(ptr,"SETEATTR",8)==0) {
status = do_seteattr(lv,ts,ptr+8);
} else if (strncmp(ptr,"SETGOAL",7)==0) {
status = do_setgoal(lv,ts,ptr+7);
} else if (strncmp(ptr,"SETPATH",7)==0) {
status = do_setpath(lv,ts,ptr+7);
} else if (strncmp(ptr,"SETTRASHTIME",12)==0) {
status = do_settrashtime(lv,ts,ptr+12);
} else if (strncmp(ptr,"SNAPSHOT",8)==0) {
status = do_snapshot(lv,ts,ptr+8);
} else if (strncmp(ptr,"SYMLINK",7)==0) {
status = do_symlink(lv,ts,ptr+7);
} else if (strncmp(ptr,"SESSION",7)==0) {
status = do_session(lv,ts,ptr+7);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'T':
if (strncmp(ptr,"TRUNC",5)==0) {
status = do_trunc(lv,ts,ptr+5);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'U':
if (strncmp(ptr,"UNLINK",6)==0) {
status = do_unlink(lv,ts,ptr+6);
} else if (strncmp(ptr,"UNDEL",5)==0) {
status = do_undel(lv,ts,ptr+5);
} else if (strncmp(ptr,"UNLOCK",6)==0) {
status = do_unlock(lv,ts,ptr+6);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
case 'W':
if (strncmp(ptr,"WRITE",5)==0) {
status = do_write(lv,ts,ptr+5);
} else {
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
break;
default:
MFSLOG(LOG_NOTICE,"%"PRIu64": unknown entry '%s'",lv,ptr);
}
/**
* let the restore continue if we missed some meta data, otherwise the
*
* Dongyang Zhang
*/
if (status!=STATUS_OK) {
MFSLOG(LOG_ERR,"%"PRIu64": error: %"PRIu8" (%s)",lv,status,errormsgs[status]);
return 1;
}
v = shadow_fs_getversion();
if (lv+1!=v) {
MFSLOG(LOG_ERR,"%"PRIu64": version mismatch",lv);
return 1;
}
}
}
fclose(fd);
MFSLOG(LOG_NOTICE,"version after applying changelog: %"PRIu64"",v);
return 0;
}
void CommandParser::executeCommand(int cmd){
switch(cmd){
case WRI : toAbsolute(first_arg);
do_wri(first_arg); break;
case LIST : toAbsolute(first_arg);
do_list(first_arg); break;
case SHOW : toAbsolute(first_arg);
do_show(first_arg); break;
case APP : toAbsolute(first_arg);
do_app(first_arg); break;
case CD : do_cd(); break;
case HELP : if (strlen(first_arg) == 0)
do_helpd();
else
do_help(first_arg);
break;
case MKFS : do_mkfs(); break;
case REN : toAbsolute(first_arg);
do_ren(first_arg , second_arg);
break;
case FINFO: toAbsolute(first_arg);
do_info(first_arg);
break;
case LINK : toAbsolute(first_arg);
toAbsolute(second_arg);
do_link(first_arg , second_arg);
break;
case QUIT : do_quit();break;
case CP : toAbsolute(first_arg);
toAbsolute(second_arg);
do_cp(first_arg , second_arg);
break;
case LOAD : do_load();
break;
case ULOAD: do_uload();
break;
case RF : toAbsolute(first_arg);
do_rf(first_arg);
break;
case RMD : toAbsolute(first_arg);
do_rmd(first_arg);
break;
case MKD : toAbsolute(first_arg);
do_mkd(first_arg);
break;
case CHOWN : toAbsolute(first_arg);
do_chown(first_arg,second_arg);
break ;
case CHPERM : toAbsolute(first_arg);
do_chperm(first_arg,second_arg);
break;
case ADDUSER :
do_adduser() ;
break;
case CLS :
clrscr();
break;
case REBOOT :
//
break;
default:
if ( strlen(command) )
vd_puts("Invalid Command\n");
}
}
int restore_line(const char *filename,uint64_t lv,char *line) {
char *ptr;
uint32_t ts;
int status;
char* errormsgs[]={ ERROR_STRINGS };
status = ERROR_MISMATCH;
ptr = line;
EAT(ptr,filename,lv,':');
EAT(ptr,filename,lv,' ');
GETU32(ts,ptr);
EAT(ptr,filename,lv,'|');
switch (*ptr) {
case 'A':
if (strncmp(ptr,"ACCESS",6)==0) {
status = do_access(filename,lv,ts,ptr+6);
} else if (strncmp(ptr,"ATTR",4)==0) {
status = do_attr(filename,lv,ts,ptr+4);
} else if (strncmp(ptr,"APPEND",6)==0) {
status = do_append(filename,lv,ts,ptr+6);
} else if (strncmp(ptr,"ACQUIRE",7)==0) {
status = do_acquire(filename,lv,ts,ptr+7);
} else if (strncmp(ptr,"AQUIRE",6)==0) {
status = do_acquire(filename,lv,ts,ptr+6);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'C':
if (strncmp(ptr,"CREATE",6)==0) {
status = do_create(filename,lv,ts,ptr+6);
} else if (strncmp(ptr,"CUSTOMER",8)==0) { // deprecated
status = do_session(filename,lv,ts,ptr+8);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'E':
if (strncmp(ptr,"EMPTYTRASH",10)==0) {
status = do_emptytrash(filename,lv,ts,ptr+10);
} else if (strncmp(ptr,"EMPTYRESERVED",13)==0) {
status = do_emptyreserved(filename,lv,ts,ptr+13);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'F':
if (strncmp(ptr,"FREEINODES",10)==0) {
status = do_freeinodes(filename,lv,ts,ptr+10);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'I':
if (strncmp(ptr,"INCVERSION",10)==0) {
status = do_incversion(filename,lv,ts,ptr+10);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'L':
if (strncmp(ptr,"LENGTH",6)==0) {
status = do_length(filename,lv,ts,ptr+6);
} else if (strncmp(ptr,"LINK",4)==0) {
status = do_link(filename,lv,ts,ptr+4);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'M':
if (strncmp(ptr,"MOVE",4)==0) {
status = do_move(filename,lv,ts,ptr+4);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'P':
if (strncmp(ptr,"PURGE",5)==0) {
status = do_purge(filename,lv,ts,ptr+5);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'Q':
if (strncmp(ptr,"QUOTA",5)==0) {
status = do_quota(filename,lv,ts,ptr+5);
}
break;
case 'R':
if (strncmp(ptr,"RELEASE",7)==0) {
status = do_release(filename,lv,ts,ptr+7);
} else if (strncmp(ptr,"REPAIR",6)==0) {
status = do_repair(filename,lv,ts,ptr+6);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'S':
if (strncmp(ptr,"SETEATTR",8)==0) {
status = do_seteattr(filename,lv,ts,ptr+8);
} else if (strncmp(ptr,"SETGOAL",7)==0) {
status = do_setgoal(filename,lv,ts,ptr+7);
} else if (strncmp(ptr,"SETPATH",7)==0) {
status = do_setpath(filename,lv,ts,ptr+7);
} else if (strncmp(ptr,"SETTRASHTIME",12)==0) {
status = do_settrashtime(filename,lv,ts,ptr+12);
} else if (strncmp(ptr,"SETXATTR",8)==0) {
status = do_setxattr(filename,lv,ts,ptr+8);
} else if (strncmp(ptr,"SNAPSHOT",8)==0) {
status = do_snapshot(filename,lv,ts,ptr+8);
} else if (strncmp(ptr,"SYMLINK",7)==0) {
status = do_symlink(filename,lv,ts,ptr+7);
} else if (strncmp(ptr,"SESSION",7)==0) {
status = do_session(filename,lv,ts,ptr+7);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'T':
if (strncmp(ptr,"TRUNC",5)==0) {
status = do_trunc(filename,lv,ts,ptr+5);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'U':
if (strncmp(ptr,"UNLINK",6)==0) {
status = do_unlink(filename,lv,ts,ptr+6);
} else if (strncmp(ptr,"UNDEL",5)==0) {
status = do_undel(filename,lv,ts,ptr+5);
} else if (strncmp(ptr,"UNLOCK",6)==0) {
status = do_unlock(filename,lv,ts,ptr+6);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
case 'W':
if (strncmp(ptr,"WRITE",5)==0) {
status = do_write(filename,lv,ts,ptr+5);
} else {
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
break;
default:
printf("%s:%"PRIu64": unknown entry '%s'\n",filename,lv,ptr);
}
if (status>STATUS_OK) {
printf("%s:%"PRIu64": error: %d (%s)\n",filename,lv,status,errormsgs[status]);
}
return status;
}
void *
AbstractMenu_first_that( Handle self, void * actionProc, void * params, Bool useDisabled)
{
return actionProc ? do_link( self, var-> tree, ( PMenuProc) actionProc, params, useDisabled) : nil;
}
int recursive_hardlink(const char *src, const char *dst, struct conf **confs)
{
int n=-1;
int ret=0;
struct dirent **dir;
char *tmp=NULL;
char *fullpatha=NULL;
char *fullpathb=NULL;
//logp("in rec hl: %s %s\n", src, dst);
if(!(tmp=prepend_s(dst, "dummy"))) return -1;
if(mkpath(&tmp, dst))
{
logp("could not mkpath for %s\n", tmp);
free_w(&tmp);
return -1;
}
free_w(&tmp);
if((n=scandir(src, &dir, 0, 0))<0)
{
logp("recursive_hardlink scandir %s: %s\n",
src, strerror(errno));
return -1;
}
while(n--)
{
struct stat statp;
if(dir[n]->d_ino==0
|| !strcmp(dir[n]->d_name, ".")
|| !strcmp(dir[n]->d_name, ".."))
{ free(dir[n]); continue; }
free_w(&fullpatha);
free_w(&fullpathb);
if(!(fullpatha=prepend_s(src, dir[n]->d_name))
|| !(fullpathb=prepend_s(dst, dir[n]->d_name)))
break;
#ifdef _DIRENT_HAVE_D_TYPE
// Faster evaluation on most systems.
if(dir[n]->d_type==DT_DIR)
{
if(recursive_hardlink(fullpatha, fullpathb, confs))
break;
}
else
#endif
// Otherwise, we have to do an lstat() anyway, because we
// will need to check the number of hardlinks in do_link().
if(lstat(fullpatha, &statp))
{
logp("could not lstat %s\n", fullpatha);
}
else if(S_ISDIR(statp.st_mode))
{
if(recursive_hardlink(fullpatha, fullpathb, confs))
break;
}
else
{
//logp("hardlinking %s to %s\n", fullpathb, fullpatha);
if(write_status(CNTR_STATUS_SHUFFLING, fullpathb,
get_cntr(confs))
|| do_link(fullpatha, fullpathb, &statp, confs,
0 /* do not overwrite target */))
break;
}
free(dir[n]);
}
if(n>0)
{
ret=-1;
for(; n>0; n--) free(dir[n]);
}
free(dir);
free_w(&fullpatha);
free_w(&fullpathb);
return ret;
}
static int inflate_or_link_oldfile(const char *oldpath, const char *infpath, int compression, struct config *cconf)
{
int ret=0;
struct stat statp;
if(lstat(oldpath, &statp))
{
logp("could not lstat %s\n", oldpath);
return -1;
}
if(dpth_is_compressed(compression, oldpath))
{
FILE *source=NULL;
FILE *dest=NULL;
//logp("inflating...\n");
if(!(dest=open_file(infpath, "wb")))
{
close_fp(&dest);
return -1;
}
if(!statp.st_size)
{
// Empty file - cannot inflate.
// just close the destination and we have duplicated a
// zero length file.
logp("asked to inflate zero length file: %s\n", oldpath);
if(close_fp(&dest))
{
logp("error closing %s in inflate_or_link_oldfile\n", infpath);
return -1;
}
return 0;
}
if(!(source=open_file(oldpath, "rb")))
{
close_fp(&dest);
return -1;
}
if((ret=zlib_inflate(source, dest))!=Z_OK)
logp("zlib_inflate returned: %d\n", ret);
close_fp(&source);
if(close_fp(&dest))
{
logp("error closing %s in inflate_or_link_oldfile\n",
infpath);
return -1;
}
}
else
{
// If it was not a compressed file, just hard link it.
// It is possible that infpath already exists, if the server
// was interrupted on a previous run just after this point.
if(do_link(oldpath, infpath, &statp, cconf,
TRUE /* allow overwrite of infpath */))
ret=-1;
}
return ret;
}
int check_trigger_sub(int trigger_num, int pnum)
{
if (pnum == Player_num) {
if (Triggers[trigger_num].flags & TRIGGER_SHIELD_DAMAGE) {
Players[Player_num].shields -= Triggers[trigger_num].value;
mprintf((0,"BZZT!\n"));
}
if (Triggers[trigger_num].flags & TRIGGER_EXIT) {
start_endlevel_sequence();
mprintf((0,"WOOHOO! (leaving the mine!)\n"));
}
if (Triggers[trigger_num].flags & TRIGGER_SECRET_EXIT) {
if (Newdemo_state == ND_STATE_RECORDING) // stop demo recording
Newdemo_state = ND_STATE_PAUSED;
Fuelcen_control_center_destroyed = 0;
mprintf((0,"Exiting to secret level\n"));
#ifdef NETWORK
if (Game_mode & GM_MULTI)
multi_send_endlevel_start(1);
#endif
#ifdef NETWORK
if (Game_mode & GM_NETWORK)
network_do_frame(1, 1);
#endif
gr_palette_fade_out(gr_palette, 32, 0);
PlayerFinishedLevel(1); //1 means go to secret level
return 1;
}
if (Triggers[trigger_num].flags & TRIGGER_ENERGY_DRAIN) {
Players[Player_num].energy -= Triggers[trigger_num].value;
mprintf((0,"SLURP!\n"));
}
}
if (Triggers[trigger_num].flags & TRIGGER_CONTROL_DOORS) {
mprintf((0,"D"));
do_link(trigger_num);
}
if (Triggers[trigger_num].flags & TRIGGER_MATCEN) {
if (!(Game_mode & GM_MULTI) || (Game_mode & GM_MULTI_ROBOTS))
do_matcen(trigger_num);
}
if (Triggers[trigger_num].flags & TRIGGER_ILLUSION_ON) {
mprintf((0,"I"));
do_il_on(trigger_num);
}
if (Triggers[trigger_num].flags & TRIGGER_ILLUSION_OFF) {
// Triggers[trigger_num].time = TRIGGER_DELAY_DOOR;
mprintf((0,"i"));
do_il_off(trigger_num);
}
return 0;
}
static int jiggle(struct sdirs *sdirs, struct fdirs *fdirs, struct sbuf *sb,
int hardlinked_current, const char *deltabdir, const char *deltafdir,
const char *sigpath, struct fzp **delfp, struct conf **cconfs)
{
int ret=-1;
struct stat statp;
char *oldpath=NULL;
char *newpath=NULL;
char *finpath=NULL;
char *deltafpath=NULL;
const char *datapth=sb->protocol1->datapth.buf;
// If the previous backup was a hardlinked_archive, there will not be
// a currentdup directory - just directly use the file in the previous
// backup.
if(!(oldpath=prepend_s(hardlinked_current?
sdirs->currentdata:fdirs->currentdupdata, datapth))
|| !(newpath=prepend_s(fdirs->datadirtmp, datapth))
|| !(finpath=prepend_s(fdirs->datadir, datapth))
|| !(deltafpath=prepend_s(deltafdir, datapth)))
goto end;
if(!lstat(finpath, &statp) && S_ISREG(statp.st_mode))
{
// Looks like an interrupted jiggle did this file already.
static int donemsg=0;
if(!unlink(deltafpath))
logp("deleted unneeded forward delta: %s\n",
deltafpath);
if(!donemsg)
{
logp("skipping already present file: %s\n", finpath);
logp("to save log space, skips of other already present files will not be logged\n");
donemsg++;
}
ret=0;
goto end;
}
if(mkpath(&finpath, fdirs->datadir))
{
logp("could not create path for: %s\n", finpath);
goto end;
}
if(!lstat(deltafpath, &statp) && S_ISREG(statp.st_mode))
{
if(mkpath(&newpath, fdirs->datadirtmp))
{
logp("could not create path for: %s\n", newpath);
goto end;
}
ret=forward_patch_and_reverse_diff(
fdirs,
delfp,
deltabdir,
deltafdir,
deltafpath,
sigpath,
oldpath,
newpath,
datapth,
finpath,
hardlinked_current,
sb,
cconfs
);
goto end;
}
if(!lstat(newpath, &statp) && S_ISREG(statp.st_mode))
{
// Use the fresh new file.
// This needs to happen after checking
// for the forward delta, because the
// patching stuff writes to newpath.
// Rename race condition is of no consequence, because finpath
// will just get recreated automatically.
//logp("Using newly received file\n");
ret=do_rename(newpath, finpath);
goto end;
}
if(!lstat(oldpath, &statp) && S_ISREG(statp.st_mode))
{
// Use the old unchanged file.
// Hard link it first.
//logp("Hard linking to old file: %s\n", datapth);
if(do_link(oldpath, finpath, &statp, cconfs,
0 /* do not overwrite finpath (should never need to) */))
goto end;
else
{
// If we are not keeping a hardlinked
// archive, delete the old link.
if(!hardlinked_current)
{
//logp("Unlinking old file: %s\n", oldpath);
unlink(oldpath);
}
}
ret=0;
goto end;
}
logp("could not find: %s\n", oldpath);
end:
free_w(&oldpath);
free_w(&newpath);
free_w(&finpath);
free_w(&deltafpath);
return ret;
}
jint Java_pp_compiler_Compile_compiler(JNIEnv* env, jobject obj, jstring jname)
{
int e;
const char*path;
int i;
char*name; // index of the file name
initialize();
// error capture
e=0;
if ((e=setjmp(jmp_env))!=0)
{
terminate();
if (iStackPtr>0)
{
#ifdef DEBUG
return 12345; // for debug to stay in console
#else
return e;
#endif
// lauch editor on the error if e>0
// stay on the console on fatal error <0
}
return -1;
}
// Parameters are used in other functons such as emitChar
// so save them in globals
Env=env;
Obj=obj;
// compute the identifier of the Java Method used by the compiler
jclass cls = (*env)->GetObjectClass(env, obj);
emitcharID = (*env)->GetMethodID(env, cls, "emitChar", "(C)V");
if (emitcharID == NULL) ReportError(INTERNAL,"method not found"); // Humm, method not found
// get the path of the file to compile
path=(*env)->GetStringUTFChars(env,jname,NULL);
if (path==NULL) ReportError(OUTOFMEMORY); // out of memory
// copy the path in the Pool and split it
// split the path into the path and the name
// a terminal zero is included in place of the last '/'
// assign LoPoolMax to the end of the path
name=split(path);
(*env)->ReleaseStringUTFChars(env,jname,path);
prompt(name);
do_compile();
do_link();
build_exec();
terminate();
post_message();
return 0;
}
void *extra_self_tests(int arg1, void *arg2)
{
/* creating /test1/test2/ directories */
dbg(DBG_ERROR | DBG_VFS,"TEST: Creating directories\n");
do_mkdir("dir");
do_mkdir("dir/dir1");
do_mkdir("dir/dir2");
do_mkdir("dir/dir3");
do_mkdir("dir/dir4");
dbg(DBG_ERROR | DBG_VFS,"TEST: Directories are created\n");
int fd;
char *file2buf="File 2 write only test case";
char *file1buf="Testing file_1 for write operation";
char readbuf[150];
dbg(DBG_ERROR | DBG_VFS,"TEST: Change directory to dir/dir1\n");
do_chdir("dir/dir1");
/* file1.txt creation with O_CREAT|O_WRONLY flag*/
dbg(DBG_ERROR | DBG_VFS,"TEST: Create file1.txt with O_CREAT|O_WRONLY flag in directory dir/dir1\n");
fd = do_open("file1.txt", O_CREAT|O_WRONLY);
do_write(fd, file1buf, strlen(file1buf));
do_close(fd);
/* file2.txt creation with O_CREAT|O_RDONLY flag*/
dbg(DBG_ERROR | DBG_VFS,"TEST: Change directory to dir/dir2\n");
do_chdir("/dir/dir2");
dbg(DBG_ERROR | DBG_VFS,"TEST: Create file2.txt with O_CREAT | O_RDONLY flag in directory dir/dir2\n");
fd = do_open("file2.txt", O_CREAT | O_RDONLY);
do_close(fd);
/* Write into file2.txt using O_WRONLY flag*/
dbg(DBG_ERROR | DBG_VFS,"TEST: Write into file2.txt with O_WRONLY flag in directory dir/dir2\n");
fd = do_open("file2.txt", O_WRONLY);
do_write(fd, file2buf, strlen(file2buf));
do_close(fd);
dbg(DBG_ERROR | DBG_VFS,"TEST: written chars: \"%s\" in file2.txt\n",file2buf);
char *appendbuf=" Appending for O_WRONLY|O_APPEND mode";
/* Append into file2.txt using O_WRONLY|O_APPEND flag*/
dbg(DBG_ERROR | DBG_VFS,"TEST: Append into file2.txt with O_WRONLY|O_APPEND flag in directory dir/dir2\n");
fd = do_open("file2.txt", O_WRONLY|O_APPEND);
do_write(fd, appendbuf, strlen(appendbuf));
do_close(fd);
dbg(DBG_ERROR | DBG_VFS,"TEST: Appending chars: \"%s\" in file2.txt\n",appendbuf);
fd = do_open("file2.txt", O_RDONLY);
memset(readbuf,0,sizeof(char)*150);
do_read(fd,readbuf,strlen(file2buf)+strlen(appendbuf));
dbg(DBG_ERROR | DBG_VFS,"TEST: After Appending text in file2.txt is: \"%s\" \n",readbuf);
char *append2buf=" Appending for O_RDWR|O_APPEND mode in file2";
/* Append into file2.txt using O_RDWR|O_APPEND flag*/
dbg(DBG_ERROR | DBG_VFS,"TEST: Append into file2.txt with O_RDWR|O_APPEND flag in directory dir/dir2\n");
fd = do_open("file2.txt", O_RDWR|O_APPEND);
do_write(fd, append2buf, strlen(append2buf));
do_close(fd);
dbg(DBG_ERROR | DBG_VFS,"TEST: Appending chars: \"%s\" in file2.txt\n",append2buf);
fd = do_open("file2.txt", O_RDONLY);
memset(readbuf,0,sizeof(char)*150);
do_read(fd,readbuf,strlen(file2buf)+strlen(append2buf)+strlen(appendbuf));
dbg(DBG_ERROR | DBG_VFS,"TEST: After Appending text in file2.txt is: \"%s\" \n",readbuf);
dbg(DBG_ERROR | DBG_VFS,"TEST:Linking Source directory => /dir/dir2, Destination directory => /dir/linkofdir2 \n");
do_chdir("/");
do_link("dir/dir2","dir/linkofdir2");
dbg(DBG_ERROR | DBG_VFS,"TEST:Linking Source file => /dir/dir1/file1.txt, to the Destination => /dir/linkoffile1 \n");
do_link("dir/dir1/file1.txt","dir/linkoffile1");
dbg(DBG_ERROR | DBG_VFS,"TEST: Renaming directory from dir/dir3 to dir/renamed \n");
do_rename("dir/dir3","dir/renameddir3");
dbg(DBG_ERROR | DBG_VFS,"TEST: Renaming file from dir/dir1/file1.txt to dir/dir1/renamedfile1.txt \n");
do_rename("dir/dir1/file1.txt","dir/dir1/renamedfile1.txt");
dbg(DBG_ERROR | DBG_VFS,"TEST: Removing directory dir/dir4 \n");
do_rmdir("dir/dir4");
dbg(DBG_ERROR | DBG_VFS,"TEST: reading 18 chars from file: /dir/linkoffile2 which is hard link of /dir/dir2/file2.txt \n");
fd = do_open("dir/linkoffile2", O_RDONLY);
memset(readbuf,0,sizeof(char)*150);
do_close(fd);
dbg(DBG_ERROR | DBG_VFS,"TEST: read 18 chars: \"%s\" from file: /dir/linkoffile1\n",readbuf);
dbg(DBG_ERROR | DBG_VFS,"TEST: reading file using lseek function on /dir/linkoffile2 which is hard link of /dir/dir2/file2.txt \n");
memset(readbuf,0,sizeof(char)*150);
fd = do_open("dir/linkoffile2", O_RDONLY);
do_lseek(fd,-19,2);
do_read(fd,readbuf,19);
do_close(fd);
dbg(DBG_ERROR | DBG_VFS,"TEST: read chars: \"%s\" using lseek from file: /dir/linkoffile1\n",readbuf);
dbg(DBG_ERROR | DBG_VFS,"TEST: creating a duplicate file descriptor of file: /dir/dir2/file2.txt using do_dup()\n");
fd = do_open("/dir/dir2/file2.txt", O_RDONLY);
int fd2= do_dup(fd);
dbg(DBG_ERROR | DBG_VFS,"TEST: duplicate file descriptor is :\"%d\" of file: /dir/dir2/file2.txt \n",fd2);
do_close(fd); do_close(fd2);
dbg(DBG_ERROR | DBG_VFS,"TEST: creating a duplicate file descriptor of file: /dir/dir2/file2.txt using do_dup2()\n");
fd = do_open("/dir/dir2/file2.txt", O_RDONLY);
fd2= do_dup2(fd,20);
dbg(DBG_ERROR | DBG_VFS,"TEST: custom file descriptor is :\"%d\" of file: /dir/dir2/file2.txt \n",fd2);
do_close(fd); do_close(fd2);
/* Testing stat
struct *statbuf;
dbg(DBG_ERROR | DBG_VFS,"TEST: Testing the stat system call for directory dir\n");
do_stat("dir",statbuf);
dbg(DBG_ERROR | DBG_VFS,"TEST: Output of stat for directory dir is :\"%s\" \n",statbuf);*/
shellTest();
return NULL;
}
void link_cmd (void)
{
do_link (0, selection (current_panel)->fname);
}
void
process_command(int descr, dbref player, char *command)
{
char *arg1;
char *arg2;
char *full_command, *commandline=command, *commandstuff;
char *p; /* utility */
char pbuf[BUFFER_LEN];
char xbuf[BUFFER_LEN];
char ybuf[BUFFER_LEN];
const char *path;
struct frame *tmpfr;
if (command == 0)
abort();
/* robustify player */
if (player < 0 || player >= db_top ||
(Typeof(player) != TYPE_PLAYER && Typeof(player) != TYPE_THING)) {
log_status("process_command: bad player %d\n", player);
return;
}
if ((tp_log_commands || (tp_log_guests && Guest(OWNER(player)))) &&
(!(FLAGS(player)&(INTERACTIVE | READMODE)))) {
log_command("%s%s%s%s(%d) in %s(%d):%s %s\n",
Mage(OWNER(player)) ? "WIZ: " : "",
(Typeof(player) != TYPE_PLAYER) ? NAME(player) : "",
(Typeof(player) != TYPE_PLAYER) ? " by " : "",
NAME(OWNER(player)), (int) player,
NAME(DBFETCH(player)->location),
(int) DBFETCH(player)->location,
(FLAGS(player) & INTERACTIVE) ?
" [interactive]" : " ", command);
}
if (FLAGS(player) & INTERACTIVE) {
interactive(descr, player, command);
return;
}
/* eat leading whitespace */
while (*command && isspace(*command))
command++;
commandstuff = command;
/* check for single-character commands */
if (*command == SAY_TOKEN || *command == '\'') {
sprintf(pbuf, "say %s", command + 1);
command = &pbuf[0];
} else if (*command == POSE_TOKEN || *command == ';') {
sprintf(pbuf, "pose %s", command + 1);
command = &pbuf[0];
} else if ((*command == '|' || (*commandstuff++ == '\\' && *commandstuff == '\\') ) && can_move(descr, player, "spoof", 0)) {
if(*command = '\\')
sprintf(pbuf, "spoof %s", command + 2);
else
sprintf(pbuf, "spoof %s", command + 1);
command = &pbuf[0];
}
/* if player is a wizard, and uses overide token to start line...*/
/* ... then do NOT run actions, but run the command they specify. */
if (!strcmp(command, WHO_COMMAND)) {
char xxbuf[BUFFER_LEN];
strcpy(xxbuf, "@");
strcat(xxbuf, WHO_COMMAND);
strcat(xxbuf, " ");
strcat(xxbuf, command + sizeof(WHO_COMMAND) - 1);
if (can_move(descr, player, xxbuf, 5)) {
do_move(descr, player, xxbuf, 5);
} else {
pdump_who_users(descr, command + sizeof(WHO_COMMAND) - 1);
}
return;
}
if (!( *command == OVERIDE_TOKEN && TMage(player) )) {
if( can_move(descr, player, command, 0) ) {
do_move(descr, player, command, 0); /* command is exact match for exit */
*match_args = 0;
*match_cmdname = 0;
return;
}
}
if (*command == OVERIDE_TOKEN && TMage(player))
command++;
full_command = strcpy(xbuf, command);
for (; *full_command && !isspace(*full_command); full_command++);
if (*full_command)
full_command++;
/* find arg1 -- move over command word */
command = strcpy(ybuf, command);
for (arg1 = command; *arg1 && !isspace(*arg1); arg1++);
/* truncate command */
if (*arg1)
*arg1++ = '\0';
/* remember command for programs */
strcpy(match_cmdname, command);
/* move over spaces */
while (*arg1 && isspace(*arg1))
arg1++;
/* find end of arg1, start of arg2 */
for (arg2 = arg1; *arg2 && *arg2 != ARG_DELIMITER; arg2++);
/* truncate arg1 */
for (p = arg2 - 1; p >= arg1 && isspace(*p); p--)
*p = '\0';
/* go past delimiter if present */
if (*arg2)
*arg2++ = '\0';
while (*arg2 && isspace(*arg2))
arg2++;
strcpy(match_cmdname, command);
strcpy(match_args, full_command);
switch (command[0]) {
case '@':
switch (command[1]) {
case 'a':
case 'A':
/* @action, @attach */
switch (command[2]) {
case 'c':
case 'C':
Matched("@action");
do_action(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
if (string_compare(command, "@armageddon"))
goto bad;
do_armageddon(player, full_command);
break;
case 't':
case 'T':
Matched("@attach");
do_attach(descr, player, arg1, arg2);
break;
case 'n':
case 'N':
Matched("@ansidescribe");
do_ansidescribe(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'b':
case 'B':
Matched("@boot");
do_boot(player, arg1);
break;
case 'c':
case 'C':
/* chown, contents, create */
switch (command[2]) {
case 'h':
case 'H':
switch (command[3]) {
case 'l':
case 'L':
Matched("@chlock");
do_chlock(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("@chown");
do_chown(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'o':
case 'O':
switch (command[4]) {
case 'l':
case 'L':
Matched("@conlock");
do_conlock(descr, player, arg1, arg2);
break;
case 't':
case 'T':
Matched("@contents");
do_contents(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
if (string_compare(command, "@credits")) {
Matched("@create");
do_create(player, arg1, arg2);
} else {
do_credits(player);
}
break;
default:
goto bad;
}
break;
case 'd':
case 'D':
/* describe, dequeue, dig, or dump */
switch (command[2]) {
case 'b':
case 'B':
Matched("@dbginfo");
do_serverdebug(descr, player, arg1, arg2);
break;
case 'e':
case 'E':
#ifdef DELTADUMPS
if(command[3] == 'l' || command[3] == 'L') {
Matched("@delta");
do_delta(player);
} else
#endif
{
if( (command[3] == 's' || command[3] == 'S') &&
(command[4] == 't' || command[4] == 'T') ) {
Matched("@destroy");
do_recycle(descr, player, arg1);
} else {
Matched("@describe");
do_describe(descr, player, arg1, arg2);
}
}
break;
case 'i':
case 'I':
Matched("@dig");
do_dig(descr, player, arg1, arg2);
break;
#ifdef DELTADUMPS
case 'l':
case 'L':
Matched("@dlt");
do_delta(player);
break;
#endif
case 'o':
case 'O':
Matched("@doing");
if (!tp_who_doing) goto bad;
do_doing(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
Matched("@drop");
do_drop_message(descr, player, arg1, arg2);
break;
case 'u':
case 'U':
Matched("@dump");
do_dump(player, full_command);
break;
default:
goto bad;
}
break;
case 'e':
case 'E':
switch (command[2]) {
case 'd':
case 'D':
Matched("@edit");
do_edit(descr, player, arg1);
break;
case 'n':
case 'N':
Matched("@entrances");
do_entrances(descr, player, arg1, arg2);
break;
case 'x':
case 'X':
Matched("@examine");
sane_dump_object(player, arg1);
break;
default:
goto bad;
}
break;
case 'f':
case 'F':
/* fail, find, force, or frob */
switch (command[2]) {
case 'a':
case 'A':
Matched("@fail");
do_fail(descr, player, arg1, arg2);
break;
case 'i':
case 'I':
if(command[3] == 'x' || command[3] == 'X') {
Matched("@fixwizbits");
do_fixw(player, full_command);
} else {
Matched("@find");
do_find(player, arg1, arg2);
}
break;
case 'l':
case 'L':
Matched("@flock");
do_flock(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("@force");
do_force(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
if (string_compare(command, "@frob"))
goto bad;
do_frob(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'h':
case 'H':
switch (command[2]) {
case 'T':
case 't':
Matched("@htmldescribe");
do_htmldescribe(descr, player, arg1, arg2);
break;
default:
Matched("@hopper");
do_hopper(player, arg1);
break;
}
break;
case 'i':
case 'I':
switch(command[2]) {
case 'h':
case 'H':
Matched("@ihtmldescribe");
do_ihtmldescribe(descr, player, arg1, arg2);
break;
case 'a':
case 'A':
Matched("@iansidescribe");
do_iansidescribe(descr, player, arg1, arg2);
break;
default:
Matched("@idescribe");
do_idescribe(descr, player, arg1, arg2);
break;
}
break;
case 'k':
case 'K':
Matched("@kill");
do_dequeue(descr, player, arg1);
break;
case 'l':
case 'L':
/* lock or link */
switch (command[2]) {
case 'i':
case 'I':
switch (command[3]) {
case 'n':
case 'N':
Matched("@link");
do_link(descr, player, arg1, arg2);
break;
case 's':
case 'S':
Matched("@list");
match_and_list(descr, player, arg1, arg2, 1);
break;
default:
goto bad;
}
break;
case 'o':
case 'O':
Matched("@lock");
do_lock(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'm':
case 'M':
switch (command[2]) {
case 'e':
case 'E':
Matched("@memory");
do_memory(player);
break;
case 'c':
case 'C':
switch (command[4]) {
case '2':
Matched("@mcp2muf");
match_and_list(descr, player, arg1, arg2, 0);
break;
default:
Matched("@mcp");
do_prog(descr, player, arg1, 1);
break;
}
default:
goto bad;
}
break;
case 'n':
case 'N':
/* @name or @newpassword */
switch (command[2]) {
case 'a':
case 'A':
Matched("@name");
do_name(descr, player, arg1, arg2);
break;
case 'e':
case 'E':
if (string_compare(command, "@newpassword"))
goto bad;
do_newpassword(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'o':
case 'O':
switch (command[2]) {
case 'd':
case 'D':
Matched("@odrop");
do_odrop(descr, player, arg1, arg2);
break;
case 'e':
case 'E':
Matched("@oecho");
do_oecho(descr, player, arg1, arg2);
break;
case 'f':
case 'F':
Matched("@ofail");
do_ofail(descr, player, arg1, arg2);
break;
case 'p':
case 'P':
Matched("@open");
do_open(descr, player, arg1, arg2);
break;
case 's':
case 'S':
Matched("@osuccess");
do_osuccess(descr, player, arg1, arg2);
break;
case 'w':
case 'W':
Matched("@owned");
do_owned(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'p':
case 'P':
switch (command[2]) {
case 'a':
case 'A':
Matched("@password");
do_password(player, arg1, arg2);
break;
case 'c':
case 'C':
Matched("@pcreate");
do_pcreate(player, arg1, arg2);
break;
case 'e':
case 'E':
Matched("@pecho");
do_pecho(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
if (string_prefix("@program", command)) {
do_prog(descr, player, arg1, 0);
break;
} else if (string_prefix("@proginfo", command)) {
do_proginfo(player, arg1);
break;
} else {
Matched("@propset");
do_propset(descr, player, arg1, arg2);
break;
}
case 's':
case 'S':
Matched("@ps");
list_events(player);
break;
case 'u':
case 'U':
Matched("@purge");
do_purge(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
switch (command[3]) {
case 'c':
case 'C':
Matched("@recycle");
do_recycle(descr, player, arg1);
break;
case 's':
case 'S':
if (!string_compare(command, "@restart")) {
do_restart(player, full_command);
} else if (!string_compare(command, "@restrict")) {
do_restrict(player, arg1);
} else {
goto bad;
}
break;
default:
goto bad;
}
break;
case 's':
case 'S':
/* set, shutdown, success */
switch (command[2]) {
case 'a':
case 'A':
if (!string_compare(command, "@sanity")) {
sanity(player);
} else if (!string_compare(command, "@sanchange")) {
sanechange(player, full_command);
} else if (!string_compare(command, "@sanfix")) {
sanfix(player);
} else {
goto bad;
}
break;
case 'e':
case 'E':
Matched("@set");
do_set(descr, player, arg1, arg2);
break;
case 'h':
case 'H':
if (!string_compare(command, "@shout")) {
do_wall(player, full_command);
break;
}
if (string_compare(command, "@shutdown"))
goto bad;
do_shutdown(player, arg1);
break;
case 't':
case 'T':
Matched("@stats");
do_stats(player, arg1);
break;
case 'u':
case 'U':
Matched("@success");
do_success(descr, player, arg1, arg2);
break;
case 'w':
case 'W':
Matched("@sweep");
do_sweep(descr, player, arg1);
break;
default:
goto bad;
}
break;
case 't':
case 'T':
switch (command[2]) {
case 'e':
case 'E':
Matched("@teleport");
do_teleport(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
if (string_compare(command, "@toad"))
goto bad;
do_frob(descr, player, arg1, arg2);
break;
case 'r':
case 'R':
Matched("@trace");
do_trace(descr, player, arg1, atoi(arg2));
break;
case 'u':
case 'U':
Matched("@tune");
do_tune(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'u':
case 'U':
switch (command[2]) {
case 'N':
case 'n':
if (string_prefix(command, "@unlink")) {
do_unlink(descr, player, arg1);
} else if (string_prefix(command, "@unlock")) {
do_unlock(descr, player, arg1);
} else if (string_prefix(command, "@uncompile")) {
do_uncompile(player);
} else {
goto bad;
}
break;
#ifndef NO_USAGE_COMMAND
case 'S':
case 's':
Matched("@usage");
do_usage(player);
break;
#endif
default:
goto bad;
break;
}
break;
case 'v':
case 'V':
Matched("@version");
anotify_nolisten2(player, CRIMSON "ProtoMUCK " PROTOBASE PURPLE " (" RED VERSION WHITE " -- " AQUA NEONVER PURPLE ")" );
break;
case 'w':
case 'W':
if (string_compare(command, "@wall"))
goto bad;
do_wall(player, full_command);
break;
default:
goto bad;
}
break;
case '&':
do_mush_set(descr, player, arg1, arg2, command);
break;
case 'd':
case 'D':
switch (command[1]) {
case 'b':
case 'B':
Matched("dboot");
do_dboot(player, arg1);
break;
case 'i':
case 'I':
Matched("dinfo");
do_dinfo(player, arg1);
break;
case 'r':
case 'R':
Matched("drop");
do_drop(descr, player, arg1, arg2);
break;
case 'w':
case 'W':
Matched("dwall");
do_dwall(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'e':
case 'E':
switch (command[1]) {
case 'm':
case 'M':
Matched("emote");
do_pose(descr, player, full_command);
break;
case 'x':
case 'X':
case '\0':
Matched("examine");
do_examine(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'g':
case 'G':
/* get, give, go, or gripe */
switch (command[1]) {
case 'e':
case 'E':
Matched("get");
do_get(descr, player, arg1, arg2);
break;
case 'i':
case 'I':
Matched("give");
do_give(descr, player, arg1, atoi(arg2));
break;
case 'o':
case 'O':
Matched("goto");
do_move(descr, player, arg1, 0);
break;
case 'r':
case 'R':
if(command[2]=='i' || command[2]=='I') {
if (string_compare(command, "gripe"))
goto bad;
do_gripe(player, full_command);
break;
}
default:
goto bad;
}
break;
case 'h':
case 'H':
switch (command[1]) {
case 'a':
case 'A':
Matched("hand");
do_drop(descr, player, arg1, arg2);
break;
case 'e':
case 'E':
Matched("help");
do_help(player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'i':
case 'I':
if (string_compare(command, "info")) {
Matched("inventory");
do_inventory(player);
} else {
do_info(player, arg1, arg2);
}
break;
case 'l':
case 'L':
if (string_prefix("look", command)) {
do_look_at(descr, player, arg1, arg2);
break;
} else {
Matched("leave");
do_leave(descr, player);
break;
}
case 'm':
case 'M':
if (string_prefix(command, "move")) {
do_move(descr, player, arg1, 0);
break;
} else if (!string_compare(command, "motd")) {
do_motd(player, full_command);
break;
} else if (!string_compare(command, "mpi")) {
do_mpihelp(player, arg1, arg2);
break;
} else {
if (string_compare(command, "man"))
goto bad;
do_man(player, arg1, arg2);
}
break;
case 'n':
case 'N':
/* news */
Matched("news");
do_news(player, arg1, arg2);
break;
case 'p':
case 'P':
switch (command[1]) {
case 'a':
case 'A':
case '\0':
Matched("page");
do_page(descr, player, arg1, arg2);
break;
case 'o':
case 'O':
Matched("pose");
do_pose(descr, player, full_command);
break;
case 'u':
case 'U':
Matched("put");
do_drop(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'r':
case 'R':
switch (command[1]) {
case 'e':
case 'E':
if(command[2] == 'q' || command[2] == 'Q'){
Matched("request");
request(player, NULL, commandline);
} else {
Matched("read"); /* undocumented alias for look */
do_look_at(descr, player, arg1, arg2);
}
break;
default:
goto bad;
}
break;
case 's':
case 'S':
/* say, "score" */
switch (command[1]) {
case 'a':
case 'A':
Matched("say");
do_say(descr, player, full_command);
break;
case 'c':
case 'C':
case '\0':
if( command[1] &&
(command[2] == 'a' || command[2] == 'A' )) {
Matched("scan");
do_sweep(descr, player, arg1);
} else {
Matched("score");
do_score(player, 1);
}
break;
default:
goto bad;
}
break;
case 't':
case 'T':
switch (command[1]) {
case 'a':
case 'A':
Matched("take");
do_get(descr, player, arg1, arg2);
break;
case 'h':
case 'H':
Matched("throw");
do_drop(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
case 'w':
case 'W':
switch (command[1]){
case 'c':
case 'C':
Matched("wc");
do_wizchat(player, full_command);
break;
case 'i':
case 'I':
Matched("wizchat");
do_wizchat(player, arg1);
break;
case 'h':
case 'H':
case '\0':
Matched("whisper");
do_whisper(descr, player, arg1, arg2);
break;
default:
goto bad;
}
break;
default:
bad:
if ( Typeof(tp_huh_command) == TYPE_PROGRAM && !(player == -1)) {
tmpfr = interp(descr, player, DBFETCH(player)->location, tp_huh_command, (dbref)-4, FOREGROUND, STD_REGUID);
if (!tmpfr)
goto bad2;
(void) interp_loop(player, tp_huh_command, tmpfr, 0);
} else {
bad2:
anotify_fmt(player, CINFO "%s",tp_huh_mesg);
if (tp_log_failed_commands && !controls(player, DBFETCH(player)->location)) {
log_status("HUH from %s(%d) in %s(%d)[%s]: %s %s\n", NAME(player), player,
NAME(DBFETCH(player)->location),
DBFETCH(player)->location,
NAME(OWNER(DBFETCH(player)->location)), command,
full_command);
}
}
break;
}
}
int vfs_selftest(kshell_t *kshell, int argc, char **argv)
{
int fd1,fd2;
char *y="/ab/fil";
char x[2];
int err;
do_mkdir("/ab");
do_mknod("/ab/new", S_IFCHR,MKDEVID(1,1));
fd1=do_open("/ab/new",2);
fd2=do_dup2(fd1,NFILES+1);
if(fd2<0)
{
dbg(DBG_PRINT,"File not created\n");
}
do_mknod("/ab/notmade",4096,MKDEVID(1,1));
do_mknod("/ab/new/not",S_IFCHR,MKDEVID(1,1));
do_mknod("/ab/new", S_IFCHR,MKDEVID(1,1));
do_mknod("", S_IFCHR,MKDEVID(1,1));
/*do_close(fd1);*/
for(fd2=1;fd2<35;fd2++)
{
sprintf(x,"%d",fd2);
strcat(y,x);
do_mknod(y,S_IFCHR,MKDEVID(1,0));
err=do_open(y,2);
if(err<0)
{
break;
}
if(fd2<10)
{
y[strlen(y)-1]='\0';
}
else
{
y[strlen(y)-2]='\0';
}
}
do_mknod("/ab/new1", S_IFCHR,MKDEVID(1,1));
err=do_dup(fd1);
do_unlink("/ab/new/ab");
do_unlink("/ab/new");
do_close(fd1);
for(fd2=NFILES-1;fd2>0;fd2--)
{
err=do_close(fd2);
sprintf(x,"%d",fd2);
strcat(y,x);
do_unlink(y);
if(err<0)
{
break;
}
if(fd2<10)
{
y[strlen(y)-1]='\0';
}
else
{
y[strlen(y)-2]='\0';
}
}
do_link("/a","/dev");
do_link("/dev","/a");
do_link("/dev","/a");
do_rmdir("/a");
/* mkdir("/k");
do_link("/ab","/k");*/
do_rmdir("/ab");
/*do_rmdir("/k");*/
/*GS: SELF TESTS*/
dbg(DBG_PRINT,"\n*************************************************************\n");
dbg(DBG_PRINT,"\n\n\n\n(GRADING2C)(kmain.c)(selftest_proc_run) selftests begin\n");
int retVal = 0;
int i = 0;
/* 1. dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_stat) strlen too long, return -ENAMETOOLONG\n");*/
char longPath[1024 + 1] = {0};
for(i = 0; i < 1025; i++)
longPath[i] = 'a';
struct stat buf;
retVal = do_stat(longPath, &buf);
retVal=do_chdir(longPath);
/*2. dbg(DBG_PRINT, "(GRADING2B) ENOTDIR or ENOENT\n");*/
retVal = do_stat("", &buf);
/*3. dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_getdent) Invalid file descriptor fd, return -EBADF\n");*/
struct dirent dirp;
retVal = do_getdent(-1, &dirp);
/*4. dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_getdent) Invalid file descriptor fd, return -EBADF\n");*/
retVal = do_getdent(1, &dirp);
/*5. dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_getdent) File descriptor does not refer to a directory, return -ENOTDIR\n");*/
do_mknod("/./file", S_IFCHR,MKDEVID(1,1));
fd1 = do_open("/./file",2);
retVal = do_getdent(fd1, &dirp);
do_unlink("/./file");
do_close(fd1);
/*6. dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_rename) Both are valid names \n");*/
/* and */
/*7. dbg(DBG_PRINT, "(GRADING2C) (vfs_syscall.c) (do_rename) error do_link, return error\n"); \n");*/
retVal = do_rename("/./aaa", "/./bbb");
dbg(DBG_PRINT,"\n\nretVal=%d",retVal);
dbg(DBG_PRINT,"\n*************************************************************\n");
return 0;
}
static int jiggle(const char *datapth, const char *currentdata, const char *datadirtmp, const char *datadir, const char *deltabdir, const char *deltafdir, const char *sigpath, const char *endfile, int hardlinked, int compression, struct cntr *cntr, struct config *cconf)
{
int ret=0;
struct stat statp;
char *oldpath=NULL;
char *newpath=NULL;
char *finpath=NULL;
char *deltafpath=NULL;
if(!(oldpath=prepend_s(currentdata, datapth, strlen(datapth)))
|| !(newpath=prepend_s(datadirtmp, datapth, strlen(datapth)))
|| !(finpath=prepend_s(datadir, datapth, strlen(datapth)))
|| !(deltafpath=prepend_s(deltafdir, datapth, strlen(datapth))))
{
logp("out of memory\n");
ret=-1;
goto cleanup;
}
else if(!lstat(finpath, &statp) && S_ISREG(statp.st_mode))
{
// Looks like an interrupted jiggle
// did this file already.
static int donemsg=0;
if(!lstat(deltafpath, &statp) && S_ISREG(statp.st_mode))
{
logp("deleting unneeded forward delta: %s\n",
deltafpath);
unlink(deltafpath);
}
if(!donemsg)
{
logp("skipping already present file: %s\n", finpath);
logp("to save log space, skips of other already present files will not be logged\n");
donemsg++;
}
}
else if(mkpath(&finpath, datadir))
{
logp("could not create path for: %s\n", finpath);
ret=-1;
goto cleanup;
}
else if(mkpath(&newpath, datadirtmp))
{
logp("could not create path for: %s\n", newpath);
ret=-1;
goto cleanup;
}
else if(!lstat(deltafpath, &statp) && S_ISREG(statp.st_mode))
{
char *infpath=NULL;
// Got a forward patch to do.
// First, need to gunzip the old file,
// otherwise the librsync patch will take
// forever, because it will be doing seeks
// all over the place, and gzseeks are slow.
if(!(infpath=prepend_s(deltafdir,
"inflate", strlen("inflate"))))
{
logp("out of memory\n");
ret=-1;
goto cleanup;
}
//logp("Fixing up: %s\n", datapth);
if(inflate_or_link_oldfile(oldpath, infpath, compression, cconf))
{
logp("error when inflating old file: %s\n", oldpath);
ret=-1;
goto cleanup;
}
if(do_patch(infpath, deltafpath, newpath, cconf->compression,
compression /* from the manifest */, cntr, cconf))
{
logp("error when patching\n");
ret=-1;
// Remove anything that got written.
unlink(newpath);
goto cleanup;
}
// Get rid of the inflated old file.
// This will also remove it if there was an
// error.
unlink(infpath);
free(infpath);
// Need to generate a reverse diff,
// unless we are keeping a hardlinked
// archive.
if(!hardlinked)
{
if(gen_rev_delta(sigpath, deltabdir,
oldpath, newpath, datapth, endfile,
compression, cntr, cconf))
{
ret=-1;
goto cleanup;
}
}
// Power interruptions should be
// recoverable. If it happens before
// this point, the data jiggle for
// this file has to be done again.
// Once finpath is in place, no more
// jiggle is required.
// Use the fresh new file.
if(do_rename(newpath, finpath))
{
ret=-1;
goto cleanup;
}
else
{
// Remove the forward delta, as it is
// no longer needed. There is a
// reverse diff and the finished
// finished file is in place.
//logp("Deleting delta.forward...\n");
unlink(deltafpath);
// Remove the old file. If a power
// cut happens just before this,
// the old file will hang around
// forever.
// TODO: Put in something to
// detect this.
// ie, both a reverse delta and the
// old file exist.
if(!hardlinked)
{
//logp("Deleting oldpath...\n");
unlink(oldpath);
}
}
}
else if(!lstat(newpath, &statp) && S_ISREG(statp.st_mode))
{
// Use the fresh new file.
// This needs to happen after checking
// for the forward delta, because the
// patching stuff writes to newpath.
//logp("Using newly received file\n");
if(do_rename(newpath, finpath))
{
ret=-1;
goto cleanup;
}
}
else if(!lstat(oldpath, &statp) && S_ISREG(statp.st_mode))
{
// Use the old unchanged file.
// Hard link it first.
//logp("Hard linking to old file: %s\n", datapth);
if(do_link(oldpath, finpath, &statp, cconf))
{
ret=-1;
goto cleanup;
}
else
{
// If we are not keeping a hardlinked
// archive, delete the old link.
if(!hardlinked)
{
//logp("Unlinking old file: %s\n", oldpath);
unlink(oldpath);
}
}
}
else
{
logp("could not find: %s\n", oldpath);
ret=-1;
goto cleanup;
}
cleanup:
if(oldpath) { free(oldpath); oldpath=NULL; }
if(newpath) { free(newpath); newpath=NULL; }
if(finpath) { free(finpath); finpath=NULL; }
if(deltafpath) { free(deltafpath); deltafpath=NULL; }
return ret;
}
int recursive_hardlink(const char *src, const char *dst, const char *client, struct cntr *p1cntr, struct cntr *cntr, struct config *conf)
{
int n=-1;
int ret=0;
struct dirent **dir;
char *tmp=NULL;
//logp("in rec hl: %s %s\n", src, dst);
if(!(tmp=prepend_s(dst, "dummy", strlen("dummy"))))
return -1;
if(mkpath(&tmp, dst))
{
logp("could not mkpath for %s\n", tmp);
free(tmp);
return -1;
}
free(tmp);
if((n=scandir(src, &dir, 0, 0))<0)
{
logp("recursive_hardlink scandir %s: %s\n",
src, strerror(errno));
return -1;
}
while(n--)
{
struct stat statp;
char *fullpatha=NULL;
char *fullpathb=NULL;
if(dir[n]->d_ino==0
|| !strcmp(dir[n]->d_name, ".")
|| !strcmp(dir[n]->d_name, ".."))
{ free(dir[n]); continue; }
if(!(fullpatha=prepend_s(src,
dir[n]->d_name, strlen(dir[n]->d_name)))
|| !(fullpathb=prepend_s(dst,
dir[n]->d_name, strlen(dir[n]->d_name))))
{
if(fullpatha) free(fullpatha);
if(fullpathb) free(fullpathb);
break;
}
if(lstat(fullpatha, &statp))
{
logp("could not lstat %s\n", fullpatha);
}
else if(S_ISDIR(statp.st_mode))
{
if(recursive_hardlink(fullpatha, fullpathb, client,
p1cntr, cntr, conf))
{
free(fullpatha);
free(fullpathb);
break;
}
}
else
{
//logp("hardlinking %s to %s\n", fullpathb, fullpatha);
write_status(client, STATUS_SHUFFLING, fullpathb,
p1cntr, cntr);
if(do_link(fullpatha, fullpathb, &statp, conf,
FALSE /* do not overwrite target */))
{
free(fullpatha);
free(fullpathb);
break;
}
}
free(fullpatha);
free(fullpathb);
free(dir[n]);
}
if(n>0)
{
ret=-1;
for(; n>0; n--) free(dir[n]);
}
free(dir);
return ret;
}
