static int
eraseoldlocks()
{
	register int i;

	/* cannot use maxledgerno() here, because we need to find a lock name
	 * before starting everything (including the dungeon initialization
	 * that sets astral_level, needed for maxledgerno()) up
	 */
	for(i = 1; i <= MAXDUNGEON*MAXLEVEL + 1; i++) {
		/* try to remove all */
		set_levelfile_name(lock, i);
		(void) unlink(fqname(lock, LEVELPREFIX, 0));
	}
	set_levelfile_name(lock, 0);
	if(unlink(fqname(lock, LEVELPREFIX, 0)))
		return 0;				/* cannot remove it */
	return(1);					/* success! */
}
Exemple #2
0
static int
open_levelfile(int lev, const char *directory)
{
    int fd;
    char levelfile[BUFSIZ];

    set_levelfile_name(lev);
    if (directory) {
        snprintf(levelfile, BUFSIZ, "%s/%s", directory, lock);
    } else {
        strcpy(levelfile, lock);
    }
#if defined(MICRO) || defined(WIN32) || defined(MSDOS)
    fd = open(levelfile, O_RDONLY | O_BINARY);
#else
    fd = open(levelfile, O_RDONLY, 0);
#endif
    return fd;
}
Exemple #3
0
int
restore_savefile(char *basename, const char *directory)
{
    int gfd, lfd, sfd;
    int lev, savelev, hpid;
    xchar levc;
    struct version_info version_data;

    /* level 0 file contains:
     *	pid of creating process (ignored here)
     *	level number for current level of save file
     *	name of save file nethack would have created
     *	and game state
     */
    (void) strcpy(lock, basename);
    gfd = open_levelfile(0, directory);
    if (gfd < 0) {
#if defined(WIN32) && !defined(WIN_CE)
        if(errno == EACCES) {
            Fprintf(stderr,
                    "\nThere are files from a game in progress under your name.");
            Fprintf(stderr,"\nThe files are locked or inaccessible.");
            Fprintf(stderr,"\nPerhaps the other game is still running?\n");
        } else
            Fprintf(stderr,
                    "\nTrouble accessing level 0 (errno = %d).\n", errno);
#endif
        Fprintf(stderr, "Cannot open level 0 for %s.\n", basename);
        return(-1);
    }
    if (read(gfd, (genericptr_t) &hpid, sizeof hpid) != sizeof hpid) {
        Fprintf(stderr, "%s\n%s%s%s\n",
                "Checkpoint data incompletely written or subsequently clobbered;",
                "recovery for \"", basename, "\" impossible.");
        Close(gfd);
        return(-1);
    }
    if (read(gfd, (genericptr_t) &savelev, sizeof(savelev))
            != sizeof(savelev)) {
        Fprintf(stderr,
                "Checkpointing was not in effect for %s -- recovery impossible.\n",
                basename);
        Close(gfd);
        return(-1);
    }
    if ((read(gfd, (genericptr_t) savename, sizeof savename)
            != sizeof savename) ||
            (read(gfd, (genericptr_t) &version_data, sizeof version_data)
             != sizeof version_data)) {
        Fprintf(stderr, "Error reading %s -- can't recover.\n", lock);
        Close(gfd);
        return(-1);
    }

    /* save file should contain:
     *	version info
     *	current level (including pets)
     *	(non-level-based) game state
     *	other levels
     */
    sfd = create_savefile();
    if (sfd < 0) {
        Fprintf(stderr, "Cannot create savefile %s.\n", savename);
        Close(gfd);
        return(-1);
    }

    lfd = open_levelfile(savelev, directory);
    if (lfd < 0) {
        Fprintf(stderr, "Cannot open level of save for %s.\n", basename);
        Close(gfd);
        Close(sfd);
        return(-1);
    }

    if (write(sfd, (genericptr_t) &version_data, sizeof version_data)
            != sizeof version_data) {
        Fprintf(stderr, "Error writing %s; recovery failed.\n", savename);
        Close(gfd);
        Close(sfd);
        return(-1);
    }

    copy_bytes(lfd, sfd);
    Close(lfd);
    (void) unlink(lock);

    copy_bytes(gfd, sfd);
    Close(gfd);
    set_levelfile_name(0);
    (void) unlink(lock);

    for (lev = 1; lev < 256; lev++) {
        /* level numbers are kept in xchars in save.c, so the
         * maximum level number (for the endlevel) must be < 256
         */
        if (lev != savelev) {
            lfd = open_levelfile(lev, directory);
            if (lfd >= 0) {
                /* any or all of these may not exist */
                levc = (xchar) lev;
                write(sfd, (genericptr_t) &levc, sizeof(levc));
                copy_bytes(lfd, sfd);
                Close(lfd);
                (void) unlink(lock);
            }
        }
    }

    Close(sfd);

#if 0 /* OBSOLETE, HackWB is no longer in use */
#ifdef AMIGA
    /* we need to create an icon for the saved game
     * or HackWB won't notice the file.
     */
    {
        char iconfile[FILENAME];
        int in, out;

        (void) sprintf(iconfile, "%s.info", savename);
        in = open("NetHack:default.icon", O_RDONLY);
        out = open(iconfile, O_WRONLY | O_TRUNC | O_CREAT);
        if(in > -1 && out > -1) {
            copy_bytes(in,out);
        }
        if(in > -1)close(in);
        if(out > -1)close(out);
    }
#endif
#endif
    return(0);
}
void
getlock()
{
	const char *fq_lock;
	char tbuf[BUFSZ];
	TCHAR wbuf[BUFSZ];
	HANDLE f;
	int fd;
	int choice;

	/* regularize(lock); */ /* already done in pcmain */
	Sprintf(tbuf, "%s", fqname(lock, LEVELPREFIX, 0));
	set_levelfile_name(lock, 0);
	fq_lock = fqname(lock, LEVELPREFIX, 1);

	f = CreateFile(
			NH_A2W(fq_lock, wbuf, BUFSZ),
			GENERIC_READ,
			0,
			NULL,
			OPEN_EXISTING,
			FILE_ATTRIBUTE_NORMAL,
			NULL);
	if( f==INVALID_HANDLE_VALUE ) {
		if(GetLastError()==ERROR_FILE_NOT_FOUND) goto gotlock;    /* no such file */
		error("Cannot open %s", fq_lock);
	}

	CloseHandle(f);

	/* prompt user that the game alredy exist */
	choice = MessageBox(
		GetNHApp()->hMainWnd,
		TEXT("There are files from a game in progress under your name. Recover?"),
		TEXT("Nethack"),
		MB_YESNO | MB_DEFBUTTON1 
		);
	switch(choice) {
	case IDYES:
		if(recover_savefile()) {
			goto gotlock;
		} else {
			error("Couldn't recover old game.");
		}
		break;

	case IDNO: 
		unlock_file(HLOCK);
		error("%s", "Cannot start a new game.");
		break;
	};

gotlock:
	fd = creat(fq_lock, FCMASK);
	if(fd == -1) {
		error("cannot creat lock file (%s.)", fq_lock);
	} else {
		if(write(fd, (char *) &hackpid, sizeof(hackpid))
		    != sizeof(hackpid)){
			error("cannot write lock (%s)", fq_lock);
		}
		if(close(fd) == -1) {
			error("cannot close lock (%s)", fq_lock);
		}
	}
}