Logo Search packages:      
Sourcecode: hfsprogs version File versions  Download package

utilities.c

/*
 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * "Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
 * Reserved.  This file contains Original Code and/or Modifications of
 * Original Code as defined in and that are subject to the Apple Public
 * Source License Version 1.0 (the 'License').  You may not use this file
 * except in compliance with the License.  Please obtain a copy of the
 * License at http://www.apple.com/publicsource and read it before using
 * this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License."
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1980, 1986, 1993
 *    The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    This product includes software developed by the University of
 *    California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/stat.h>

#include <ctype.h>
#include <err.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h> 
#include <stdlib.h>

#include "fsck_hfs.h"

char *rawname __P((char *name));
char *unrawname __P((char *name));


int
reply(char *question)
{
      int persevere;
      char c;

      if (preen)
            pfatal("INTERNAL ERROR: GOT TO reply()");
      persevere = !strcmp(question, "CONTINUE");
      printf("\n");
      if (!persevere && (nflag || fswritefd < 0)) {
            printf("%s? no\n\n", question);
            return (0);
      }
      if (yflag || (persevere && nflag)) {
            printf("%s? yes\n\n", question);
            return (1);
      }
      do    {
            printf("%s? [yn] ", question);
            (void) fflush(stdout);
            c = getc(stdin);
            while (c != '\n' && getc(stdin) != '\n')
                  if (feof(stdin))
                        return (0);
      } while (c != 'y' && c != 'Y' && c != 'n' && c != 'N');
      printf("\n");
      if (c == 'y' || c == 'Y')
            return (1);
      return (0);
}


void
ckfini(markclean)
      int markclean;
{
//    register struct bufarea *bp, *nbp;
//    int ofsmodified, cnt = 0;

      (void) CacheDestroy(&fscache);

      if (fswritefd < 0) {
            (void)close(fsreadfd);
            return;
      }
#if 0
      flush(fswritefd, &sblk);
      if (havesb && sblk.b_bno != SBOFF / dev_bsize &&
          !preen && reply("UPDATE STANDARD SUPERBLOCK")) {
            sblk.b_bno = SBOFF / dev_bsize;
            sbdirty();
            flush(fswritefd, &sblk);
      }
      flush(fswritefd, &cgblk);
      free(cgblk.b_un.b_buf);
      for (bp = bufhead.b_prev; bp && bp != &bufhead; bp = nbp) {
            cnt++;
            flush(fswritefd, bp);
            nbp = bp->b_prev;
            free(bp->b_un.b_buf);
            free((char *)bp);
      }
      if (bufhead.b_size != cnt)
            errx(EEXIT, "Panic: lost %d buffers", bufhead.b_size - cnt);
      pbp = pdirbp = (struct bufarea *)0;
      if (markclean && sblock.fs_clean == 0) {
            sblock.fs_clean = 1;
            sbdirty();
            ofsmodified = fsmodified;
            flush(fswritefd, &sblk);
            fsmodified = ofsmodified;
            if (!preen)
                  printf("\n***** FILE SYSTEM MARKED CLEAN *****\n");
      }
      if (debug)
            printf("cache missed %ld of %ld (%d%%)\n", diskreads,
                totalreads, (int)(diskreads * 100 / totalreads));
#endif
      (void)close(fsreadfd);
      (void)close(fswritefd);
}


char *
blockcheck(char *origname)
{
      struct stat stslash, stblock, stchar;
      char *newname, *raw;
      int retried = 0;

      hotroot = 0;
      if (stat("/", &stslash) < 0) {
            perror("/");
            printf("Can't stat root\n");
            return (origname);
      }
      newname = origname;
retry:
      if (stat(newname, &stblock) < 0) {
            perror(newname);
            printf("Can't stat %s\n", newname);
            return (origname);
      }
      if ((stblock.st_mode & S_IFMT) == S_IFBLK) {
            if (stslash.st_dev == stblock.st_rdev)
                  hotroot++;
            raw = rawname(newname);
            if (stat(raw, &stchar) < 0) {
                  perror(raw);
                  printf("Can't stat %s\n", raw);
                  return (origname);
            }
            if ((stchar.st_mode & S_IFMT) == S_IFCHR) {
                  return (raw);
            } else {
                  printf("%s is not a character device\n", raw);
                  return (origname);
            }
      } else if ((stblock.st_mode & S_IFMT) == S_IFCHR && !retried) {
            newname = unrawname(newname);
            retried++;
            goto retry;
      }
      /*
       * Not a block or character device, just return name and
       * let the caller decide whether to use it.
       */
      return (origname);
}


char *
rawname(char *name)

{
      static char rawbuf[32];
      char *dp;

      if ((dp = strrchr(name, '/')) == 0)
            return (0);
      *dp = 0;
      (void)strcpy(rawbuf, name);
      *dp = '/';
      (void)strcat(rawbuf, "/r");
      (void)strcat(rawbuf, &dp[1]);

      return (rawbuf);
}


char *
unrawname(char *name)
{
      char *dp;
      struct stat stb;

      if ((dp = strrchr(name, '/')) == 0)
            return (name);
      if (stat(name, &stb) < 0)
            return (name);
      if ((stb.st_mode & S_IFMT) != S_IFCHR)
            return (name);
      if (dp[1] != 'r')
            return (name);
      (void)strcpy(&dp[1], &dp[2]);

      return (name);
}


void
catch(sig)
      int sig;
{
      if (!upgrading)
            ckfini(0);
      exit(12);
}


#if __STDC__
#include <stdarg.h>
#else
#include <varargs.h>
#endif

/*
 * An unexpected inconsistency occured.
 * Die if preening, otherwise just print message and continue.
 */
void
#if __STDC__
pfatal(const char *fmt, ...)
#else
pfatal(fmt, va_alist)
      char *fmt;
      va_dcl
#endif
{
      va_list ap;
#if __STDC__
      va_start(ap, fmt);
#else
      va_start(ap);
#endif
      if (!preen) {
            (void)vfprintf(stderr, fmt, ap);
            va_end(ap);
            return;
      }
      (void)fprintf(stderr, "%s: ", cdevname);
      (void)vfprintf(stderr, fmt, ap);
      (void)fprintf(stderr,
          "\n%s: UNEXPECTED INCONSISTENCY; RUN fsck_hfs MANUALLY.\n",
          cdevname);
      exit(EEXIT);
}

/*
 * Pwarn just prints a message when not preening,
 * or a warning (preceded by filename) when preening.
 */
void
#if __STDC__
pwarn(const char *fmt, ...)
#else
pwarn(fmt, va_alist)
      char *fmt;
      va_dcl
#endif
{
      va_list ap;
#if __STDC__
      va_start(ap, fmt);
#else
      va_start(ap);
#endif
      if (preen)
            (void)fprintf(stderr, "%s: ", cdevname);
      (void)vfprintf(stderr, fmt, ap);
      va_end(ap);
}


Generated by  Doxygen 1.6.0   Back to index