/*
* Ported to Linux's Second Extended File System as part of the
* dump and restore backup suit
- * Remy Card <card@Linux.EU.Org>, 1994, 1995, 1996
- *
+ * Remy Card <card@Linux.EU.Org>, 1994-1997
+ * Stelian Pop <pop@cybercable.fr>, 1999
*/
/*
*/
#ifndef lint
-static char sccsid[] = "@(#)symtab.c 8.3 (Berkeley) 4/28/95";
+static const char rcsid[] =
+ "$Id: symtab.c,v 1.6 1999/10/13 09:57:21 stelian Exp $";
#endif /* not lint */
/*
#endif /* __linux__ */
#include <errno.h>
+#include <compaterr.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
* Look up an entry by inode number
*/
struct entry *
-lookupino(inum)
- ino_t inum;
+lookupino(ino_t inum)
{
register struct entry *ep;
* Add an entry into the entry table
*/
static void
-addino(inum, np)
- ino_t inum;
- struct entry *np;
+addino(ino_t inum, struct entry *np)
{
struct entry **epp;
* Delete an entry from the entry table
*/
void
-deleteino(inum)
- ino_t inum;
+deleteino(ino_t inum)
{
register struct entry *next;
struct entry **prev;
* Look up an entry by name
*/
struct entry *
-lookupname(name)
- char *name;
+lookupname(char *name)
{
register struct entry *ep;
register char *np, *cp;
cp = name;
for (ep = lookupino(ROOTINO); ep != NULL; ep = ep->e_entries) {
- for (np = buf; *cp != '/' && *cp != '\0'; )
+ for (np = buf; *cp != '/' && *cp != '\0' &&
+ np < &buf[sizeof(buf)]; )
*np++ = *cp++;
+ if (np == &buf[sizeof(buf)])
+ break;
*np = '\0';
for ( ; ep != NULL; ep = ep->e_sibling)
if (strcmp(ep->e_name, buf) == 0)
* Look up the parent of a pathname
*/
static struct entry *
-lookupparent(name)
- char *name;
+lookupparent(char *name)
{
struct entry *ep;
char *tailindex;
* Determine the current pathname of a node or leaf
*/
char *
-myname(ep)
- register struct entry *ep;
+myname(struct entry *ep)
{
register char *cp;
static char namebuf[MAXPATHLEN];
for (cp = &namebuf[MAXPATHLEN - 2]; cp > &namebuf[ep->e_namlen]; ) {
cp -= ep->e_namlen;
- memmove(cp, ep->e_name, (long)ep->e_namlen);
+ memmove(cp, ep->e_name, (size_t)ep->e_namlen);
if (ep == lookupino(ROOTINO))
return (cp);
*(--cp) = '/';
}
/*
- * Unused symbol table entries are linked together on a freelist
+ * Unused symbol table entries are linked together on a free list
* headed by the following pointer.
*/
static struct entry *freelist = NULL;
* add an entry to the symbol table
*/
struct entry *
-addentry(name, inum, type)
- char *name;
- ino_t inum;
- int type;
+addentry(char *name, ino_t inum, int type)
{
register struct entry *np, *ep;
if (freelist != NULL) {
np = freelist;
freelist = np->e_next;
- memset(np, 0, (long)sizeof(struct entry));
+ memset(np, 0, sizeof(struct entry));
} else {
np = (struct entry *)calloc(1, sizeof(struct entry));
if (np == NULL)
if (type & LINK) {
ep = lookupino(inum);
if (ep == NULL)
- panic("link to non-existant name\n");
+ panic("link to non-existent name\n");
np->e_ino = inum;
np->e_links = ep->e_links;
ep->e_links = np;
* delete an entry from the symbol table
*/
void
-freeentry(ep)
- register struct entry *ep;
+freeentry(struct entry *ep)
{
register struct entry *np;
ino_t inum;
* Relocate an entry in the tree structure
*/
void
-moveentry(ep, newname)
- register struct entry *ep;
- char *newname;
+moveentry(struct entry *ep, char *newname)
{
struct entry *np;
char *cp;
* Remove an entry in the tree structure
*/
static void
-removeentry(ep)
- register struct entry *ep;
+removeentry(struct entry *ep)
{
register struct entry *np;
/*
* Table of unused string entries, sorted by length.
- *
+ *
* Entries are allocated in STRTBLINCR sized pieces so that names
* of similar lengths can use the same entry. The value of STRTBLINCR
* is chosen so that every entry has at least enough space to hold
* a "struct strtbl" header. Thus every entry can be linked onto an
- * apprpriate free list.
+ * appropriate free list.
*
* NB. The macro "allocsize" below assumes that "struct strhdr"
* has a size that is a power of two.
* has an appropriate sized entry, and if not allocates a new one.
*/
char *
-savename(name)
- char *name;
+savename(char *name)
{
struct strhdr *np;
long len;
* appropriate free list.
*/
void
-freename(name)
- char *name;
+freename(char *name)
{
struct strhdr *tp, *np;
-
+
tp = &strtblhdr[strlen(name) / STRTBLINCR];
np = (struct strhdr *)name;
np->next = tp->next;
* Useful quantities placed at the end of a dumped symbol table.
*/
struct symtableheader {
- long volno;
- long stringsize;
- long entrytblsize;
+ int32_t volno;
+ int32_t stringsize;
+ int32_t entrytblsize;
time_t dumptime;
time_t dumpdate;
ino_t maxino;
- long ntrec;
+ int32_t ntrec;
};
/*
* dump a snapshot of the symbol table
*/
void
-dumpsymtable(filename, checkpt)
- char *filename;
- long checkpt;
+dumpsymtable(char *filename, long checkpt)
{
register struct entry *ep, *tep;
register ino_t i;
FILE *fd;
struct symtableheader hdr;
- vprintf(stdout, "Check pointing the restore\n");
+ Vprintf(stdout, "Check pointing the restore\n");
if (Nflag)
return;
if ((fd = fopen(filename, "w")) == NULL) {
- fprintf(stderr, "fopen: %s\n", strerror(errno));
+ warn("fopen");
panic("cannot create save file %s for symbol table\n",
filename);
}
clearerr(fd);
/*
- * Assign indicies to each entry
+ * Assign indices to each entry
* Write out the string entries
*/
- for (i = WINO; i < maxino; i++) {
+ for (i = WINO; i <= maxino; i++) {
for (ep = lookupino(i); ep != NULL; ep = ep->e_links) {
ep->e_index = mynum++;
(void) fwrite(ep->e_name, sizeof(char),
*/
tep = &temp;
stroff = 0;
- for (i = WINO; i < maxino; i++) {
+ for (i = WINO; i <= maxino; i++) {
for (ep = lookupino(i); ep != NULL; ep = ep->e_links) {
- memmove(tep, ep, (long)sizeof(struct entry));
+ memmove(tep, ep, sizeof(struct entry));
tep->e_name = (char *)stroff;
stroff += allocsize(ep->e_namlen);
tep->e_parent = (struct entry *)ep->e_parent->e_index;
hdr.ntrec = ntrec;
(void) fwrite((char *)&hdr, sizeof(struct symtableheader), 1, fd);
if (ferror(fd)) {
- fprintf(stderr, "fwrite: %s\n", strerror(errno));
+ warn("fwrite");
panic("output error to file %s writing symbol table\n",
filename);
}
* Initialize a symbol table from a file
*/
void
-initsymtable(filename)
- char *filename;
+initsymtable(char *filename)
{
char *base;
long tblsize;
register long i;
int fd;
- vprintf(stdout, "Initialize symbol table.\n");
+ Vprintf(stdout, "Initialize symbol table.\n");
if (filename == NULL) {
entrytblsize = maxino / HASHFACTOR;
entry = (struct entry **)
return;
}
if ((fd = open(filename, O_RDONLY, 0)) < 0) {
- fprintf(stderr, "open: %s\n", strerror(errno));
+ warn("open");
panic("cannot open symbol table file %s\n", filename);
}
if (fstat(fd, &stbuf) < 0) {
- fprintf(stderr, "stat: %s\n", strerror(errno));
+ warn("stat");
panic("cannot stat symbol table file %s\n", filename);
}
tblsize = stbuf.st_size - sizeof(struct symtableheader);
panic("cannot allocate space for symbol table\n");
if (read(fd, base, (int)tblsize) < 0 ||
read(fd, (char *)&hdr, sizeof(struct symtableheader)) < 0) {
- fprintf(stderr, "read: %s\n", strerror(errno));
+ warn("read");
panic("cannot read symbol table file %s\n", filename);
}
switch (command) {
* For normal continuation, insure that we are using
* the next incremental tape
*/
- if (hdr.dumpdate != dumptime) {
- if (hdr.dumpdate < dumptime)
- fprintf(stderr, "Incremental tape too low\n");
- else
- fprintf(stderr, "Incremental tape too high\n");
- done(1);
- }
+ if (hdr.dumpdate != dumptime)
+ errx(1, "Incremental tape too %s",
+ (hdr.dumpdate < dumptime) ? "low" : "high");
break;
case 'R':
/*