taperscan.c

来自「开源备份软件源码 AMANDA, the Advanced Marylan」· C语言 代码 · 共 586 行 · 第 1/2 页

        if (label_result == 1 || label_result == 3 ||
            (label_result == 2 && !ct->backwards)) {
            *(ct->tapedev) = stralloc(device);
            ct->tape_status = label_result;
            amfree(ct->slotstr);
            ct->slotstr = stralloc(slotstr);
            result = 1;
        } else {
	    if ((label_result == 2) && (ct->first_labelstr_slot == NULL))
		ct->first_labelstr_slot = stralloc(slotstr);
	    result = 0;
	}
	break;
    }
    ct->output_callback(ct->output_data, *(ct->error_message));
    amfree(*(ct->error_message));
    return result;
}

static int 
scan_init(
    void *data,
    int rc,
    G_GNUC_UNUSED int nslots,
    int backwards,
    G_GNUC_UNUSED int searchable)
{
    changertrack_t *ct = ((changertrack_t*)data);

    if (rc) {
	*(ct->error_message) = newvstrallocf(*(ct->error_message),
		_("%scould not get changer info: %s\n"),
		*(ct->error_message), changer_resultstr);
	ct->output_callback(ct->output_data, *(ct->error_message));
	amfree(*(ct->error_message));
    }

    ct->backwards = backwards;
    return 0;
}

int
changer_taper_scan(
    char *wantlabel,
    char **gotlabel,
    char **timestamp,
    char **tapedev,
    taper_scan_tracker_t * tracker,
    TaperscanOutputFunctor taperscan_output_callback,
    void *output_data,
    TaperscanProlongFunctor prolong_callback,
    void * prolong_data)
{
    char *error_message = NULL;
    changertrack_t local_data;
    char *outslotstr = NULL;
    int result;

    *gotlabel = *timestamp = *tapedev = NULL;
    local_data.wantlabel = wantlabel;
    local_data.gotlabel  = gotlabel;
    local_data.timestamp = timestamp;
    local_data.error_message = &error_message;
    local_data.tapedev = tapedev;
    local_data.first_labelstr_slot = NULL;
    local_data.backwards = 0;
    local_data.tape_status = 0;
    local_data.output_callback  = taperscan_output_callback;
    local_data.output_data = output_data;
    local_data.prolong_callback = prolong_callback;
    local_data.prolong_data = prolong_data;
    local_data.persistent = tracker;
    local_data.slotstr = NULL;

    changer_find(&local_data, scan_init, scan_slot, wantlabel);
    
    if (*(local_data.tapedev)) {
        /* We got it, and it's loaded. */
        if (local_data.persistent != NULL && local_data.slotstr != NULL) {
            g_hash_table_insert(local_data.persistent->scanned_slots,
                                local_data.slotstr, NULL);
        } else {
            amfree(local_data.slotstr);
        }
	amfree(local_data.first_labelstr_slot);
        return local_data.tape_status;
    } else if (local_data.first_labelstr_slot) {
        /* Use plan B. */
        if (prolong_callback && !prolong_callback(prolong_data)) {
            return -1;
        }
        result = changer_loadslot(local_data.first_labelstr_slot,
                                  &outslotstr, tapedev);
	amfree(local_data.first_labelstr_slot);
        amfree(outslotstr);
        if (result == 0) {
	    amfree(*gotlabel);
	    amfree(*timestamp);
            result = scan_read_label(*tapedev, NULL, NULL,
                                     gotlabel, timestamp,
                                     &error_message);
            taperscan_output_callback(output_data, error_message);
            amfree(error_message);
            if (result > 0 && local_data.persistent != NULL &&
                local_data.slotstr != NULL) {
                g_hash_table_insert(local_data.persistent->scanned_slots,
                                    local_data.slotstr, NULL);
            } else {
                amfree(local_data.slotstr);
            }
            return result;
        }
    }

    /* Didn't find a tape. :-( */
    assert(local_data.tape_status <= 0);
    return -1;
}

int taper_scan(char* wantlabel,
               char** gotlabel, char** timestamp, char** tapedev,
               taper_scan_tracker_t * tracker,
               TaperscanOutputFunctor output_functor,
               void *output_data,
               TaperscanProlongFunctor prolong_functor,
	       void *prolong_data) {
    char *error_message = NULL;
    int result;
    *gotlabel = *timestamp = NULL;

    if (wantlabel == NULL) {
        tape_t *tmp;
        tmp = lookup_last_reusable_tape(0);
        if (tmp != NULL) {
            wantlabel = tmp->label;
        }
    }

    if (changer_init()) {
        result =  changer_taper_scan(wantlabel, gotlabel, timestamp,
	                             tapedev, tracker,
                                     output_functor, output_data,
                                     prolong_functor, prolong_data);
    } else {
        /* Note that the tracker is not used in this case. */
	*tapedev = stralloc(getconf_str(CNF_TAPEDEV));
	if (*tapedev == NULL) {
	    result = -1;
	    output_functor(output_data, _("No tapedev specified"));
	} else {
	    result =  scan_read_label(*tapedev, NULL, wantlabel, gotlabel,
                                      timestamp, &error_message);
            output_functor(output_data, error_message);
	    amfree(error_message);
	}
    }

    return result;
}

#define AUTO_LABEL_MAX_LEN 1024
char *
find_brand_new_tape_label(void)
{
    char *format;
    char newlabel[AUTO_LABEL_MAX_LEN];
    char tmpnum[30]; /* 64-bit integers can be 21 digists... */
    char tmpfmt[16];
    char *auto_pos = NULL;
    int i;
    ssize_t label_len, auto_len;
    tape_t *tp;

    if (!getconf_seen(CNF_LABEL_NEW_TAPES)) {
        return NULL;
    }
    format = getconf_str(CNF_LABEL_NEW_TAPES);

    memset(newlabel, 0, AUTO_LABEL_MAX_LEN);
    label_len = 0;
    auto_len = -1; /* Only find the first '%' */
    while (*format != '\0') {
        if (label_len + 4 > AUTO_LABEL_MAX_LEN) {
            g_fprintf(stderr, _("Auto label format is too long!\n"));
            return NULL;
        }

        if (*format == '\\') {
            /* Copy the next character. */
            newlabel[label_len++] = format[1];
            format += 2;
        } else if (*format == '%' && auto_len == -1) {
            /* This is the format specifier. */
            auto_pos = newlabel + label_len;
            auto_len = 0;
            while (*format == '%' && label_len < AUTO_LABEL_MAX_LEN) {
                newlabel[label_len++] = '%';
                auto_len ++;
                format ++;
            }
        } else {
            /* Just copy a character. */
            newlabel[label_len++] = *(format++);
        }     
    }

    /* Sometimes we copy the null, sometimes not. */
    if (newlabel[label_len] != '\0') {
        newlabel[label_len++] = '\0';
    }

    if (auto_pos == NULL) {
        g_fprintf(stderr, _("Auto label template contains no '%%'!\n"));
        return NULL;
    }

    g_snprintf(tmpfmt, SIZEOF(tmpfmt), "%%0%zdd",
	     (size_t)auto_len);

    for (i = 1; i < INT_MAX; i ++) {
        g_snprintf(tmpnum, SIZEOF(tmpnum), tmpfmt, i);
        if (strlen(tmpnum) != (size_t)auto_len) {
            g_fprintf(stderr, _("All possible auto-labels used.\n"));
            return NULL;
        }

        strncpy(auto_pos, tmpnum, (size_t)auto_len);

        tp = lookup_tapelabel(newlabel);
        if (tp == NULL) {
            /* Got it. Double-check that this is a labelstr match. */
            if (!match(getconf_str(CNF_LABELSTR), newlabel)) {
                g_fprintf(stderr, _("New label %s does not match labelstr %s from amanda.conf\n"),
                        newlabel, getconf_str(CNF_LABELSTR));
                return 0;
            }
            return stralloc(newlabel);
        }
    }

    /* Should not get here unless you have over two billion tapes. */
    g_fprintf(stderr, _("Taper internal error in find_brand_new_tape_label."));
    return 0;
}

void
FILE_taperscan_output_callback(
    void *data,
    char *msg)
{
    if(!msg) return;
    if(strlen(msg) == 0) return;

    if(data)
	g_fprintf((FILE *)data, "%s", msg);
    else
	g_printf("%s", msg);
}

void
CHAR_taperscan_output_callback(
    /*@keep@*/	void *data,
    		char *msg)
{
    char **s = (char **)data;

    if(!msg) return;
    if(strlen(msg) == 0) return;

    if(*s)
	strappend(*s, msg);
    else
	*s = stralloc(msg);
}

taper_scan_tracker_t * taper_scan_tracker_new(void) {
    taper_scan_tracker_t * rval = malloc(sizeof(*rval));
    
    rval->scanned_slots = g_hash_table_new_full(g_str_hash, g_str_equal,
                                                g_free, NULL);

    return rval;
}

void taper_scan_tracker_free(taper_scan_tracker_t * tracker) {
    if (tracker->scanned_slots != NULL) {
        g_hash_table_destroy(tracker->scanned_slots);
    }
    
    free(tracker);
}