ndmpd/ndmp/ndmpd_dtime.c

/*
 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2015 by Delphix. All rights reserved.
 */

/*
 * BSD 3 Clause License
 *
 * Copyright (c) 2007, The Storage Networking Industry Association.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  - Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *  - 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.
 *
 *  - Neither the name of The Storage Networking Industry Association (SNIA)
 *    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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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/param.h>
#include <sys/types.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <libnvpair.h>
#include "ndmpd_log.h"
#include "ndmpd.h"

/*
 * The dumpdates file on file system.
 */
#define NDMP_DUMPDATES  "dumpdates"


/*
 * Offsets into the ctime string to various parts.
 */
#define E_MONTH     4
#define E_DAY       8
#define E_HOUR      11
#define E_MINUTE    14
#define E_SECOND    17
#define E_YEAR      20


/*
 * The contents of the file dumpdates is maintained on a linked list.
 */
typedef struct dumpdates {
    char dd_name[TLM_MAX_PATH_NAME];
    char dd_level;
    time_t dd_ddate;
    struct dumpdates *dd_next;
} dumpdates_t;


/*
 * Month names used in ctime string.
 */
static char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";


/*
 * Binary lock for accessing the dumpdates file.
 */
mutex_t ndmp_dd_lock = DEFAULTMUTEX;

int ndmp_isdst = -1;

char *zfs_dumpdate_props[] = {
    "dumpdates:level0",
    "dumpdates:level1",
    "dumpdates:level2",
    "dumpdates:level3",
    "dumpdates:level4",
    "dumpdates:level5",
    "dumpdates:level6",
    "dumpdates:level7",
    "dumpdates:level8",
    "dumpdates:level9",
};


/*
 * lookup
 *
 * Look up the month (3-character) name and return its number.
 *
 * Returns -1 if the months name is not valid.
 */
static int
lookup(char *str)
{
    register char *cp, *cp2;

    if (!str)
        return (-1);

    for (cp = months, cp2 = str; *cp != '\0'; cp += 3)
        if (strncmp(cp, cp2, 3) == 0)
            return ((cp-months) / 3);
    return (-1);
}


/*
 * unctime
 *
 * Convert a ctime(3) format string into a system format date.
 * Return the date thus calculated.
 *
 * Return -1 if the string is not in ctime format.
 */
static int
unctime(char *str, time_t *t)
{
    struct tm then;
    char dbuf[26];

    if (!str || !t)
        return (-1);

    (void) memset(&then, 0, sizeof (then));
    (void) strlcpy(dbuf, str, sizeof (dbuf) - 1);
    dbuf[sizeof (dbuf) - 1] = '\0';
    dbuf[E_MONTH+3] = '\0';
    if ((then.tm_mon = lookup(&dbuf[E_MONTH])) < 0)
        return (-1);

    then.tm_mday = atoi(&dbuf[E_DAY]);
    then.tm_hour = atoi(&dbuf[E_HOUR]);
    then.tm_min = atoi(&dbuf[E_MINUTE]);
    then.tm_sec = atoi(&dbuf[E_SECOND]);
    then.tm_year = atoi(&dbuf[E_YEAR]) - 1900;
    then.tm_isdst = ndmp_isdst;

    NDMP_LOG(LOG_DEBUG,
        "yday %d wday %d %d/%d/%d %02d:%02d:%02d",
        then.tm_yday, then.tm_wday, then.tm_year, then.tm_mon,
        then.tm_mday, then.tm_hour, then.tm_min, then.tm_sec);

    *t = mktime(&then);

    return (0);
}


/*
 * ddates_pathname
 *
 * Create the dumpdates file full path name.
 */
static char *
ddates_pathname(char *buf)
{
    return (ndmpd_make_bk_dir_path(buf, NDMP_DUMPDATES));
}


/*
 * getaline
 *
 * Get a line from the file and handle the continued lines.
 */
static char *
getaline(FILE *fp, char *line, int llen)
{
    char *save;
    int len;

    if (!fp || !line)
        return (NULL);

    *(save = line) = '\0';
    do {
        if (fgets(line, llen, fp) != line)
            return (NULL);

        /* comment line? */
        if (*line == '#')
            continue;

        len = strlen(line);
        /* short line */
        if (len <= 0)
            continue;

        line += len-1;
        if (*line != '\n')
            return (NULL);

        /* trim the trailing new line */
        *line = '\0';
        if (--len <= 0)
            break;

        if (*(line-1) != '\\')
            break;

        *(line-1) = '\n';
        llen -= len;
    } while (llen > 0);

    return (save);
}


/*
 * get_ddname
 *
 * Get the path name from the buffer passed.
 *
 * Returns the beginning of the path name.  The buffer pointer is moved
 * forward to point to where the next field (the dump level) begins.
 */
static char *
get_ddname(char **bpp)
{
    char *h, *t, *save;

    if (!bpp || !*bpp)
        return (NULL);

    *bpp += strspn(*bpp, "\t ");
    save = h = t = *bpp;
    while (*t) {
        if (*t == '\t' || *t == ' ') {
            /* consume the '\t' or space character */
            t++;
            break;
        }

        if (*t == '\\')
            switch (*(t+1)) {
            case '\t':
            case ' ':
                t++; /* skip the '\\' */
            default:
                break;  /* nothing */
            }

        *h++ = *t++;
    }

    *bpp = t;
    *h++ = '\0';
    return (save);
}


/*
 * get_ddlevel
 *
 * Get the dump level from the buffer passed.
 *
 * Returns the dump level found.  The buffer pointer is moved
 * forward to point to where the next field (the dump date) begins.
 */
static int
get_ddlevel(char **bpp)
{
    char *t, *save;

    if (!bpp || !*bpp)
        return (-1);

    *bpp += strspn(*bpp, "\t ");
    save = t = *bpp;

    /*
     * For 'F', 'A', 'I', and 'D' return the character itself.
     */
    if (IS_LBR_BKTYPE(*t)) {
        NDMP_LOG(LOG_DEBUG, "Lbr bk type %c", *t);
        /*
         * Skip the backup type character and null terminate the
         * string.
         */
        *++t = '\0';
        *bpp = ++t;
        return (toupper(*save));
    }

    while (isdigit(*t))
        t++;

    *t++ = '\0';
    *bpp = t;
    return (atoi(save));
}


/*
 * get_ddate
 *
 * Get the dump date from the buffer passed.
 *
 * Returns the dump date string. The buffer pointer is moved
 * forward.  It points to the end of the buffer now.
 */
static char *
get_ddate(char **bpp)
{
    char *save;

    if (!bpp || !*bpp)
        return (NULL);

    *bpp += strspn(*bpp, "\t ");
    save = *bpp;
    *bpp += strlen(*bpp);
    return (save);
}


/*
 * put_ddname
 *
 * Print the dump path name to the dumpdates file.  It escapes the space,
 * '\t' and new line characters in the path name.  The same characters are
 * considered in the get_ddname().
 */
static void
put_ddname(FILE *fp, char *nm)
{
    if (!nm)
        return;

    while (*nm)
        switch (*nm) {
        case ' ':
        case '\n':
        case '\t':
            (void) fputc('\\', fp);
            /* FALLTHROUGH */
        default:
            (void) fputc(*nm++, fp);
        }
}


/*
 * put_ddlevel
 *
 * Print the dump level into the dumpdates file.
 */
static void
put_ddlevel(FILE *fp, int level)
{
    if (!fp)
        return;

    (void) fprintf(fp, IS_LBR_BKTYPE(level) ? "%c" : "%d", level);
}


/*
 * put_ddate
 *
 * Print the dump date into the dumpdates file.
 */
static void put_ddate(FILE *fp,
    time_t t)
{
    char tbuf[64];

    if (!fp)
        return;

    NDMP_LOG(LOG_DEBUG, "[%u]", t);

    (void) ctime_r(&t, tbuf, sizeof (tbuf));
    /* LINTED variable format specifier */
    (void) fprintf(fp, tbuf);
}


/*
 * dd_free
 *
 * Free the linked list of dumpdates entries.
 */
static void
dd_free(dumpdates_t *ddheadp)
{
    dumpdates_t *save;

    if (!ddheadp)
        return;

    ddheadp = ddheadp->dd_next;
    while (ddheadp) {
        save = ddheadp->dd_next;
        free(ddheadp);
        ddheadp = save;
    }
}


/*
 * makedumpdate
 *
 * Make the dumpdate node based on the string buffer passed to it.
 */
static int
makedumpdate(dumpdates_t *ddp, char *tbuf)
{
    char *nmp, *un_buf;
    int rv;

    /*
     * While parsing each line, if a line contains one of the
     * LBR-type levels, then checking the return value of
     * get_ddlevel() against negative values, it OK.  Because
     * neither of the 'F', 'A', 'I' nor 'D' have negative
     * ASCII value.
     */
    if (!ddp || !tbuf)
        rv = -1;
    else if (!(nmp = get_ddname(&tbuf))) {
        rv = -1;
        NDMP_LOG(LOG_DEBUG, "get_ddname failed 0x%p", nmp);
    } else if ((ddp->dd_level = get_ddlevel(&tbuf)) < 0) {
        rv = -1;
        NDMP_LOG(LOG_DEBUG, "dd_level < 0 %d", ddp->dd_level);
    } else if (!(un_buf = get_ddate(&tbuf))) {
        rv = -1;
        NDMP_LOG(LOG_DEBUG, "get_ddate failed 0x%p", un_buf);
    } else if (unctime(un_buf, &ddp->dd_ddate) < 0) {
        rv = -1;
        NDMP_LOG(LOG_DEBUG, "unctime failed \"%s\"", un_buf);
    } else {
        (void) strlcpy(ddp->dd_name, nmp, TLM_MAX_PATH_NAME);
        rv = 0;
    }

    return (rv);
}


/*
 * getrecord
 *
 * Read a record of dumpdates file and parse it.
 * The records that span multiple lines are covered.
 *
 * Returns:
 *   0 on success
 *   < 0 on error
 */
static int
getrecord(FILE *fp, dumpdates_t *ddatep, int *recno)
{
    char tbuf[BUFSIZ];

    if (!fp || !ddatep || !recno)
        return (-1);

    do {
        if (getaline(fp, tbuf, sizeof (tbuf)) != tbuf)
            return (-1);
    } while (!*tbuf);

    if (makedumpdate(ddatep, tbuf) < 0)
        NDMP_LOG(LOG_DEBUG,
            "Unknown intermediate format in %s, line %d", tbuf, *recno);

    (*recno)++;

    if (IS_LBR_BKTYPE(ddatep->dd_level & 0xff)) {
        NDMP_LOG(LOG_DEBUG, "Lbr: [%s][%c][%u]",
            ddatep->dd_name, ddatep->dd_level, ddatep->dd_ddate);
    } else
        NDMP_LOG(LOG_DEBUG, "[%s][%d][%u]",
            ddatep->dd_name, ddatep->dd_level, ddatep->dd_ddate);

    return (0);
}


/*
 * readdumptimes
 *
 * Read the dumpdates file and make a linked list of its entries.
 *
 * Returns:
 *   0 on success
 *   < 0 on error
 */
static int
readdumptimes(FILE *fp, dumpdates_t *ddheadp)
{
    int recno;
    register struct dumpdates *ddwalk;

    if (!fp || !ddheadp)
        return (-1);

    recno = 1;
    (void) memset((void *)ddheadp, 0, sizeof (*ddheadp));
    for (; ; ) {
        ddwalk = ndmp_malloc(sizeof (*ddwalk));
        if (!ddwalk)
            return (-1);

        if (getrecord(fp, ddwalk, &recno) < 0) {
            free(ddwalk);
            break;
        }

        ddwalk->dd_next = ddheadp->dd_next;
        ddheadp->dd_next = ddwalk;
        ddheadp = ddwalk;
    }

    return (0);
}


/*
 * dumprecout
 *
 * Print a record into the dumpdates file.
 */
static void
dumprecout(FILE *fp, dumpdates_t *ddp)
{
    if (!ddp)
        return;

    if (IS_LBR_BKTYPE(ddp->dd_level)) {
        NDMP_LOG(LOG_DEBUG, "Lbr: [%s][%c][%u]",
            ddp->dd_name, ddp->dd_level, ddp->dd_ddate);
    } else
        NDMP_LOG(LOG_DEBUG, "[%s][%d][%u]",
            ddp->dd_name, ddp->dd_level, ddp->dd_ddate);

    put_ddname(fp, ddp->dd_name);
    (void) fputc('\t', fp);
    put_ddlevel(fp, ddp->dd_level);
    (void) fputc('\t', fp);
    put_ddate(fp, ddp->dd_ddate);
}


/*
 * initdumptimes
 *
 * Open the dumpdates file and read it into memory.
 *
 * Returns:
 *   0 on success
 *   < 0 on error
 *
 */
static int
initdumptimes(dumpdates_t *ddheadp)
{
    char fname[PATH_MAX];
    int rv;
    FILE *fp;

    if (!ddheadp)
        return (-1);

    if (!ddates_pathname(fname))
        return (-1);

    fp = fopen(fname, "r");
    if (!fp) {
        if (errno != ENOENT) {
            NDMP_LOG(LOG_ERR, "Cannot read %s: %m.", fname);
            return (-1);
        }
        /*
         * Dumpdates does not exist, make an empty one.
         */
        NDMP_LOG(LOG_DEBUG,
            "No file `%s', making an empty one", fname);

        fp = fopen(fname, "w");
        if (!fp) {
            NDMP_LOG(LOG_ERR, "Cannot create %s: %m.", fname);
            return (-1);
        }
        (void) fclose(fp);

        fp = fopen(fname, "r");
        if (!fp) {
            NDMP_LOG(LOG_ERR,
                "Cannot read %s after creating it. %m.", fname);
            return (-1);
        }
    }

    rv = readdumptimes(fp, ddheadp);
    (void) fclose(fp);

    return (rv);
}


/*
 * putdumptime
 *
 * Put the record specified by path, level and backup date to the file.
 * Update the record if such entry already exists; append if not.
 *
 * Returns:
 *   0 on success
 *   < 0 on error
 */
static int
putdumptime(char *path, int level, time_t ddate)
{
    int found;
    char fname[PATH_MAX], bakfname[PATH_MAX];
    FILE *rfp, *wfp;
    dumpdates_t ddhead, tmpdd;
    register dumpdates_t *ddp;
    int rv;

    if (!path)
        return (-1);

    if (IS_LBR_BKTYPE(level)) {
        NDMP_LOG(LOG_DEBUG, "Lbr: [%s][%c][%u]", path, level, ddate);
    } else {
        NDMP_LOG(LOG_DEBUG, "[%s][%d][%u]", path, level, ddate);
    }

    if (!ddates_pathname(fname)) {
        NDMP_LOG(LOG_ERR, "Cannot get dumpdate file path name.");
        return (-1);
    }

    rfp = fopen(fname, "r");
    if (!rfp) {
        NDMP_LOG(LOG_DEBUG, "Creating %s.", fname);
        (void) memset((void *)&ddhead, 0, sizeof (ddhead));
        if (initdumptimes(&ddhead) < 0) {
            NDMP_LOG(LOG_ERR, "Could not initialize %s.",
                NDMP_DUMPDATES);
            dd_free(&ddhead);
            return (-1);
        }
    } else {
        rv = readdumptimes(rfp, &ddhead);

        if (rv < 0) {
            NDMP_LOG(LOG_ERR, "Error reading dumpdates file.");
            (void) fclose(rfp);
            dd_free(&ddhead);
            return (-1);
        }
        (void) fclose(rfp);
    }

    (void) snprintf(bakfname, PATH_MAX, "%s.bak", fname);
    wfp = fopen(bakfname, "w");
    if (!wfp) {
        NDMP_LOG(LOG_ERR, "Cannot open %s: %m.", bakfname);
        dd_free(&ddhead);
        return (-1);
    }

    NDMP_LOG(LOG_DEBUG, "[%s][%s]", fname, bakfname);

    /* try to locate the entry in the file */
    found = 0;
    for (ddp = ddhead.dd_next; ddp; ddp = ddp->dd_next) {
        if (ddp->dd_level != level)
            continue;
        if (strcmp(path, ddp->dd_name))
            continue;

        NDMP_LOG(LOG_DEBUG, "Found: [%s][%d][%u]",
            ddp->dd_name, ddp->dd_level, ddp->dd_ddate);

        /* update the record for the entry */
        found = 1;
        ddp->dd_ddate = ddate;

        NDMP_LOG(LOG_DEBUG,
            "Updated to: [%s][%d][%u]",
            ddp->dd_name, ddp->dd_level, ddp->dd_ddate);
    }

    /* dump all the read records */
    for (ddp = ddhead.dd_next; ddp; ddp = ddp->dd_next)
        dumprecout(wfp, ddp);

    dd_free(&ddhead);

    /* append a new record */
    if (!found) {
        (void) strlcpy(tmpdd.dd_name, path, TLM_MAX_PATH_NAME);
        tmpdd.dd_level = level;
        tmpdd.dd_ddate = ddate;
        dumprecout(wfp, &tmpdd);
    }

    (void) fclose(wfp);
    (void) rename(bakfname, fname);

    return (0);
}


/*
 * append_dumptime
 *
 * Append the record specified by path, level and backup date to the file.
 */
static int
append_dumptime(char *fname, char *path, int level, time_t ddate)
{
    char fpath[PATH_MAX], bakfpath[PATH_MAX];
    FILE *fp;
    dumpdates_t tmpdd;

    if (!fname || !*fname || !path || !*path)
        return (-1);

    if (IS_LBR_BKTYPE(level & 0xff)) {
        NDMP_LOG(LOG_DEBUG,
            "Lbr: [%s][%s][%c][%u]",
            fname, path, level, ddate);
    } else
        NDMP_LOG(LOG_DEBUG, "[%s][%s][%d][%u]",
            fname, path, level, ddate);

    if (!ndmpd_make_bk_dir_path(fpath, fname)) {
        NDMP_LOG(LOG_ERR, "Cannot get dumpdate file path name %s.",
            fname);
        return (-1);
    }

    (void) snprintf(bakfpath, PATH_MAX, "%s.bak", fpath);

    /*
     * If the file is there and can be opened then make a
     * backup copy it.
     */
    fp = fopen(fpath, "r");
    if (fp) {
        (void) fclose(fp);
        if (filecopy(bakfpath, fpath) != 0) {
            NDMP_LOG(LOG_ERR, "Cannot copy %s to %s: %m.",
                fpath, bakfpath);
            return (-1);
        }
    }

    /* open the new copy to append the record to it */
    fp = fopen(bakfpath, "a");
    if (!fp) {
        NDMP_LOG(LOG_ERR, "Cannot open %s: %m.", bakfpath);
        return (-1);
    }

    NDMP_LOG(LOG_DEBUG, "[%s][%s]", fpath, bakfpath);

    /* append a new record */
    (void) strlcpy(tmpdd.dd_name, path, TLM_MAX_PATH_NAME);
    tmpdd.dd_level = level;
    tmpdd.dd_ddate = ddate;
    dumprecout(fp, &tmpdd);

    (void) fclose(fp);
    (void) rename(bakfpath, fpath);

    return (0);
}


/*
 * find_date
 *
 * Find the specified date
 */
static dumpdates_t *
find_date(dumpdates_t *ddp, char *path, int level, time_t t)
{
    for (; ddp; ddp = ddp->dd_next)
        if (ddp->dd_level == level && ddp->dd_ddate > t &&
            strcmp(path, ddp->dd_name) == 0)
            break;

    return (ddp);
}


/*
 * Get the dumpdate of the last level backup done on the path.
 * The last level normally is (level - 1) in case of NetBackup
 * but some DMAs allow that previous level could be anything
 * between 0 and the current level.
 *
 * Returns:
 *   0 on success
 *   < 0 on error
 */
int
ndmpd_get_dumptime(char *path, int *level, time_t *ddate)
{
    int i;
    dumpdates_t ddhead, *ddp, *save;
    char vol[ZFS_MAX_DATASET_NAME_LEN];
    nvlist_t *userprops;
    zfs_handle_t *zhp;
    nvlist_t *propval = NULL;
    char *strval = NULL;

    if (!path || !level || !ddate)
        return (-1);

    NDMP_LOG(LOG_DEBUG, "[%s] level %d",
        path, *level);

    if (*level == 0) {
        *ddate = (time_t)0;
        return (0);
    }

    (void) mutex_lock(&zlib_mtx);
    /* Check if this is a ZFS dataset */
    if ((zlibh != NULL) &&
        (get_zfsvolname(vol, sizeof (vol), path) == 0) &&
        ((zhp = zfs_open(zlibh, vol, ZFS_TYPE_DATASET)) != NULL)) {
        if ((userprops = zfs_get_user_props(zhp)) == NULL) {
            *level = 0;
            *ddate = (time_t)0;
            zfs_close(zhp);
            (void) mutex_unlock(&zlib_mtx);
            return (0);
        }
        for (i = *level - 1; i >= 0; i--) {
            if (nvlist_lookup_nvlist(userprops,
                zfs_dumpdate_props[i], &propval) == 0) {
                *level = i;
                break;
            }
        }
        if (propval == NULL ||
            nvlist_lookup_string(propval, ZPROP_VALUE,
            &strval) != 0) {
            *level = 0;
            *ddate = (time_t)0;
            zfs_close(zhp);
            (void) mutex_unlock(&zlib_mtx);
            return (0);
        }
        if (unctime(strval, ddate) < 0) {
            zfs_close(zhp);
            (void) mutex_unlock(&zlib_mtx);
            return (-1);
        }

        zfs_close(zhp);
        (void) mutex_unlock(&zlib_mtx);
        return (0);
    }
    (void) mutex_unlock(&zlib_mtx);

    (void) memset((void *)&ddhead, 0, sizeof (ddhead));
    if (initdumptimes(&ddhead) < 0) {
        dd_free(&ddhead);
        return (-1);
    }

    /*
     * Empty dumpdates file means level 0 for all paths.
     */
    if ((ddp = ddhead.dd_next) == 0) {
        if (!IS_LBR_BKTYPE(*level & 0xff))
            *level = 0;
        *ddate = 0;
        return (0);
    }

    /*
     * If it's not level backup, then find the exact record
     * type.
     */
    if (IS_LBR_BKTYPE(*level & 0xff)) {
        save = find_date(ddp, path, *level, *ddate);

        NDMP_LOG(LOG_DEBUG,
            "LBR_BKTYPE save 0x%p", save);

        *ddate = save ? save->dd_ddate : (time_t)0;
    } else {
        /*
         * Go find the entry with the same name for a maximum of a
         * lower increment and older date.
         */
        save = NULL;
        for (i = *level - 1; i >= 0; i--) {
            save = find_date(ddp, path, i, *ddate);
            if (save) {
                *level = save->dd_level;
                *ddate = save->dd_ddate;
                break;
            }
        }

        if (!save) {
            *level = 0;
            *ddate = (time_t)0;
        }
    }

    dd_free(&ddhead);

    return (0);
}


/*
 * Put the date and the level of the back up for the
 * specified path in the dumpdates file.  If there is a line
 * for the same path and the same level, the date is updated.
 * Otherwise, a line is appended to the file.
 *
 * Returns:
 *   0 on success
 *   < 0 on error
 */
int
ndmpd_put_dumptime(char *path, int level, time_t ddate)
{
    char vol[ZFS_MAX_DATASET_NAME_LEN];
    zfs_handle_t *zhp;
    char tbuf[64];
    int rv;

    NDMP_LOG(LOG_DEBUG, "[%s][%d][%u]", path, level,
        ddate);

    /* Check if this is a ZFS dataset */
    (void) mutex_lock(&zlib_mtx);
    if ((zlibh != NULL) &&
        (get_zfsvolname(vol, sizeof (vol), path) == 0) &&
        ((zhp = zfs_open(zlibh, vol, ZFS_TYPE_DATASET)) != NULL)) {

        (void) ctime_r(&ddate, tbuf, sizeof (tbuf));
        rv = zfs_prop_set(zhp, zfs_dumpdate_props[level], tbuf);
        zfs_close(zhp);

        (void) mutex_unlock(&zlib_mtx);
        return (rv);
    }
    (void) mutex_unlock(&zlib_mtx);

    (void) mutex_lock(&ndmp_dd_lock);
    rv = putdumptime(path, level, ddate);
    (void) mutex_unlock(&ndmp_dd_lock);

    return (rv);
}


/*
 * Append a backup date record to the specified file.
 */
int
ndmpd_append_dumptime(char *fname, char *path, int level, time_t ddate)
{
    char vol[ZFS_MAX_DATASET_NAME_LEN];
    zfs_handle_t *zhp;
    char tbuf[64];
    int rv;

    NDMP_LOG(LOG_DEBUG, "[%s][%s][%d][%u]", fname,
        path, level, ddate);

    /* Check if this is a ZFS dataset */
    (void) mutex_lock(&zlib_mtx);
    if ((zlibh != NULL) &&
        (get_zfsvolname(vol, sizeof (vol), path) == 0) &&
        ((zhp = zfs_open(zlibh, vol, ZFS_TYPE_DATASET)) != NULL)) {

        (void) ctime_r(&ddate, tbuf, sizeof (tbuf));
        rv = zfs_prop_set(zhp, zfs_dumpdate_props[level], tbuf);
        zfs_close(zhp);

        (void) mutex_unlock(&zlib_mtx);
        return (rv);
    }
    (void) mutex_unlock(&zlib_mtx);

    (void) mutex_lock(&ndmp_dd_lock);
    rv = append_dumptime(fname, path, level, ddate);
    (void) mutex_unlock(&ndmp_dd_lock);

    return (rv);
}