zebraapi.c

harvest是一个下载html网页得机器人

        yaz_log (LOG_WARN, "no register root specified");
        return 0;  /* no path for register - fail! */
    }
    return res;
}

static void zebra_close_res (ZebraHandle zh)
{
    ASSERTZH;
    zh->errCode=0;
    if (zh->res != zh->service->global_res)
        res_close (zh->res);
    zh->res = 0;
}

static int zebra_select_register (ZebraHandle zh, const char *new_reg)
{
    ASSERTZH;
    zh->errCode=0;
    if (zh->res && strcmp (zh->reg_name, new_reg) == 0)
        return 0;
    if (!zh->res)
    {
        assert (zh->reg == 0);
        assert (*zh->reg_name == 0);
    }
    else
    {
        if (zh->reg)
        {
            resultSetInvalidate (zh);
            zebra_register_close (zh->service, zh->reg);
            zh->reg = 0;
        }
        zebra_close_res(zh);
    }
    xfree (zh->reg_name);
    zh->reg_name = xstrdup (new_reg);

    xfree (zh->path_reg);
    zh->path_reg = 0;
    if (zh->service->path_root)
    {
        zh->path_reg = xmalloc (strlen(zh->service->path_root) + 
                                strlen(zh->reg_name) + 3);
        strcpy (zh->path_reg, zh->service->path_root);
        if (*zh->reg_name)
        {
            strcat (zh->path_reg, "/");
            strcat (zh->path_reg, zh->reg_name);
        }
    }
    zh->res = zebra_open_res (zh);
    
    if (zh->lock_normal)
        zebra_lock_destroy (zh->lock_normal);
    zh->lock_normal = 0;

    if (zh->lock_shadow)
        zebra_lock_destroy (zh->lock_shadow);
    zh->lock_shadow = 0;

    if (zh->res)
    {
        char fname[512];
        const char *lock_area  =res_get (zh->res, "lockDir");
        
        if (!lock_area && zh->path_reg)
            res_put (zh->res, "lockDir", zh->path_reg);
        sprintf (fname, "norm.%s.LCK", zh->reg_name);
        zh->lock_normal =
            zebra_lock_create (res_get(zh->res, "lockDir"), fname, 0);
        
        sprintf (fname, "shadow.%s.LCK", zh->reg_name);
        zh->lock_shadow =
            zebra_lock_create (res_get(zh->res, "lockDir"), fname, 0);

    }
    return 1;
}

void map_basenames_func (void *vp, const char *name, const char *value)
{
    struct map_baseinfo *p = (struct map_baseinfo *) vp;
    int i, no;
    char fromdb[128], todb[8][128];
    
    no =
	sscanf (value, "%127s %127s %127s %127s %127s %127s %127s %127s %127s",
		fromdb,	todb[0], todb[1], todb[2], todb[3], todb[4],
		todb[5], todb[6], todb[7]);
    if (no < 2)
	return ;
    no--;
    for (i = 0; i<p->num_bases; i++)
	if (p->basenames[i] && !STRCASECMP (p->basenames[i], fromdb))
	{
	    p->basenames[i] = 0;
	    for (i = 0; i < no; i++)
	    {
		if (p->new_num_bases == p->new_num_max)
		    return;
		p->new_basenames[(p->new_num_bases)++] = 
		    nmem_strdup (p->mem, todb[i]);
	    }
	    return;
	}
}

void map_basenames (ZebraHandle zh, ODR stream,
		    int *num_bases, char ***basenames)
{
    struct map_baseinfo info;
    struct map_baseinfo *p = &info;
    int i;
    ASSERTZH;
    yaz_log(LOG_API,"map_basenames ");
    zh->errCode=0;

    info.zh = zh;
    info.num_bases = *num_bases;
    info.basenames = *basenames;
    info.new_num_max = 128;
    info.new_num_bases = 0;
    info.new_basenames = (char **)
	odr_malloc (stream, sizeof(*info.new_basenames) * info.new_num_max);
    info.mem = stream->mem;

    res_trav (zh->service->global_res, "mapdb", &info, map_basenames_func);
    
    for (i = 0; i<p->num_bases; i++)
	if (p->basenames[i] && p->new_num_bases < p->new_num_max)
	{
	    p->new_basenames[(p->new_num_bases)++] = 
		nmem_strdup (p->mem, p->basenames[i]);
	}
    *num_bases = info.new_num_bases;
    *basenames = info.new_basenames;
    for (i = 0; i<*num_bases; i++)
	logf (LOG_LOG, "base %s", (*basenames)[i]);
}

int zebra_select_database (ZebraHandle zh, const char *basename)
{
    ASSERTZH;
    yaz_log(LOG_API,"zebra_select_database %s",basename);
    zh->errCode=0;
    return zebra_select_databases (zh, 1, &basename);
}

int zebra_select_databases (ZebraHandle zh, int num_bases,
                            const char **basenames)
{
    int i;
    const char *cp;
    int len = 0;
    char *new_reg = 0;
    ASSERTZH;
    yaz_log(LOG_API,"zebra_select_databases n=%d [0]=%s",
		    num_bases,basenames[0]);
    zh->errCode=0;
    
    if (num_bases < 1)
    {
        zh->errCode = 23;
        return -1;
    }
    for (i = 0; i < zh->num_basenames; i++)
        xfree (zh->basenames[i]);
    xfree (zh->basenames);
    
    zh->num_basenames = num_bases;
    zh->basenames = xmalloc (zh->num_basenames * sizeof(*zh->basenames));
    for (i = 0; i < zh->num_basenames; i++)
        zh->basenames[i] = xstrdup (basenames[i]);

    cp = strrchr(basenames[0], '/');
    if (cp)
    {
        len = cp - basenames[0];
        new_reg = xmalloc (len + 1);
        memcpy (new_reg, basenames[0], len);
        new_reg[len] = '\0';
    }
    else
        new_reg = xstrdup ("");
    for (i = 1; i<num_bases; i++)
    {
        const char *cp1;

        cp1 = strrchr (basenames[i], '/');
        if (cp)
        {
            if (!cp1)
            {
                zh->errCode = 23;
                return -1;
            }
            if (len != cp1 - basenames[i] ||
                memcmp (basenames[i], new_reg, len))
            {
                zh->errCode = 23;
                return -1;
            }
        }
        else
        {
            if (cp1)
            {
                zh->errCode = 23;
                return -1;
            }
        }
    }
    zebra_select_register (zh, new_reg);
    xfree (new_reg);
    if (!zh->res)
    {
        zh->errCode = 109;
        return -1;
    }
    if (!zh->lock_normal || !zh->lock_shadow)
    {
        zh->errCode = 2;
	return -1;
    }
    return 0;
}

int zebra_search_RPN (ZebraHandle zh, ODR o,
		       Z_RPNQuery *query, const char *setname, int *hits)
{
    ASSERTZH;
    yaz_log(LOG_API,"zebra_search_rpn");
    zh->errCode=0;
    zh->hits = 0;
    *hits = 0;

    if (zebra_begin_read (zh))
	return 1;

    zebra_livcode_transform(zh, query);

    resultSetAddRPN (zh, odr_extract_mem(o), query, 
                     zh->num_basenames, zh->basenames, setname);

    zebra_end_read (zh);

    *hits = zh->hits;
    return 0;
}

int zebra_records_retrieve (ZebraHandle zh, ODR stream,
			     const char *setname, Z_RecordComposition *comp,
			     oid_value input_format, int num_recs,
			     ZebraRetrievalRecord *recs)
{
    ZebraPosSet poset;
    int i, *pos_array, ret = 0;
    ASSERTZH;
    yaz_log(LOG_API,"zebra_records_retrieve n=%d",num_recs);
    zh->errCode=0;

    if (!zh->res)
    {
        zh->errCode = 30;
        zh->errString = odr_strdup (stream, setname);
        return -1;
    }
    
    zh->errCode = 0;

    if (zebra_begin_read (zh))
	return -1;

    pos_array = (int *) xmalloc (num_recs * sizeof(*pos_array));
    for (i = 0; i<num_recs; i++)
	pos_array[i] = recs[i].position;
    poset = zebraPosSetCreate (zh, setname, num_recs, pos_array);
    if (!poset)
    {
        logf (LOG_DEBUG, "zebraPosSetCreate error");
        zh->errCode = 30;
        zh->errString = nmem_strdup (stream->mem, setname);
	ret = -1;
    }
    else
    {
	for (i = 0; i<num_recs; i++)
	{
	    if (poset[i].term)
	    {
		recs[i].errCode = 0;
		recs[i].format = VAL_SUTRS;
		recs[i].len = strlen(poset[i].term);
		recs[i].buf = poset[i].term;
		recs[i].base = poset[i].db;
	    }
	    else if (poset[i].sysno)
	    {
		recs[i].errCode =
		    zebra_record_fetch (zh, poset[i].sysno, poset[i].score,
					stream, input_format, comp,
					&recs[i].format, &recs[i].buf,
					&recs[i].len,
					&recs[i].base);
		recs[i].errString = NULL;
	    }
	    else
	    {
	        char num_str[20];

		sprintf (num_str, "%d", pos_array[i]);	
		zh->errCode = 13;
                zh->errString = odr_strdup (stream, num_str);
		ret = -1;
                break;
	    }
	}
	zebraPosSetDestroy (zh, poset, num_recs);
    }
    zebra_end_read (zh);
    xfree (pos_array);
    return ret;
}

int zebra_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
		 oid_value attributeset,
		 int *position, int *num_entries, ZebraScanEntry **entries,
		 int *is_partial)
{
    ASSERTZH;
    yaz_log(LOG_API,"zebra_scan");
    zh->errCode=0;
    if (zebra_begin_read (zh))
    {
	*entries = 0;
	*num_entries = 0;
	return 1;
    }
    rpn_scan (zh, stream, zapt, attributeset,
	      zh->num_basenames, zh->basenames, position,
	      num_entries, entries, is_partial, 0, 0);
    zebra_end_read (zh);
    return 0;
}

int zebra_sort (ZebraHandle zh, ODR stream,
		 int num_input_setnames, const char **input_setnames,
		 const char *output_setname, Z_SortKeySpecList *sort_sequence,
		 int *sort_status)
{
    ASSERTZH;
    yaz_log(LOG_API,"zebra_sort");
    zh->errCode=0;
    if (zebra_begin_read (zh))
	return 1;
    resultSetSort (zh, stream->mem, num_input_setnames, input_setnames,
		   output_setname, sort_sequence, sort_status);
    zebra_end_read(zh);
    return 0;
}

int zebra_deleleResultSet(ZebraHandle zh, int function,
			  int num_setnames, char **setnames,
			  int *statuses)
{
    int i, status;
    ASSERTZH;
    yaz_log(LOG_API,"zebra_deleleResultSet n=%d",num_setnames);
    zh->errCode=0;
    if (zebra_begin_read(zh))
	return Z_DeleteStatus_systemProblemAtTarget;
    switch (function)
    {
    case Z_DeleteRequest_list:
	resultSetDestroy (zh, num_setnames, setnames, statuses);
	break;
    case Z_DeleteRequest_all:
	resultSetDestroy (zh, -1, 0, statuses);
	break;
    }
    zebra_end_read (zh);
    status = Z_DeleteStatus_success;
    for (i = 0; i<num_setnames; i++)
	if (statuses[i] == Z_DeleteStatus_resultSetDidNotExist)
	    status = statuses[i];
    return status;
}

int zebra_errCode (ZebraHandle zh)
{
    if (zh)
    {
        yaz_log(LOG_API,"zebra_errCode: %d",zh->errCode);
        return zh->errCode;
    }
    yaz_log(LOG_API,"zebra_errCode: o");
    return 0; 
}

const char *zebra_errString (ZebraHandle zh)
{
    const char *e="";
    if (zh)
        e= diagbib1_str (zh->errCode);
    yaz_log(LOG_API,"zebra_errString: %s",e);
    return e;
}

char *zebra_errAdd (ZebraHandle zh)
{
    char *a="";
    if (zh)
        a= zh->errString;
    yaz_log(LOG_API,"zebra_errAdd: %s",a);
    return a;
}

void zebra_clearError(ZebraHandle zh)
{
    if (zh)
    {
        zh->errCode=0;
        zh->errString="";
    }
}

int zebra_auth (ZebraHandle zh, const char *user, const char *pass)
{
    ZebraService zs;
    ASSERTZH;
    yaz_log(LOG_API,"zebra_auth u=%s p=%s",user,pass);
    zh->errCode=0;
    zs= zh->service;
    if (!zs->passwd_db || !passwd_db_auth (zs->passwd_db, user, pass))
    {
        logf(LOG_APP,"AUTHOK:%s", user?user:"ANONYMOUS");
	return 0;
    }

    logf(LOG_APP,"AUTHFAIL:%s", user?user:"ANONYMOUS");
    return 1;
}

int zebra_admin_import_begin (ZebraHandle zh, const char *database,
                               const char *record_type)
{
    ASSERTZH;
    yaz_log(LOG_API,"zebra_admin_import_begin db=%s rt=%s", 
		     database, record_type);
    zh->errCode=0;
    if (zebra_select_database(zh, database))
        return 1;
    zebra_begin_trans (zh, 1);
    xfree (zh->admin_databaseName);
    zh->admin_databaseName = xstrdup(database);
    return 0;
}

int zebra_admin_import_end (ZebraHandle zh)
{
    ASSERTZH;
    yaz_log(LOG_API,"zebra_admin_import_end");
    zh->errCode=0;
    zebra_end_trans (zh);
    return 0;
}

int zebra_admin_import_segment (ZebraHandle zh, Z_Segment *segment)
{
    int sysno;
    int i;
    ASSERTZH;
    yaz_log(LOG_API,"zebra_admin_import_segment");
    zh->errCode=0;
    for (i = 0; i<segment->num_segmentRecords; i++)
    {
	Z_NamePlusRecord *npr = segment->segmentRecords[i];
	const char *databaseName = npr->databaseName;

	if (!databaseName)
	    databaseName = zh->admin_databaseName;
	printf ("--------------%d--------------------\n", i);
	if (npr->which == Z_NamePlusRecord_intermediateFragment)
	{
	    Z_FragmentSyntax *fragment = npr->u.intermediateFragment;
	    if (fragment->which == Z_FragmentSyntax_notExternallyTagged)
	    {
		Odr_oct *oct = fragment->u.notExternallyTagged;
		printf ("%.*s", (oct->len > 100 ? 100 : oct->len) ,
			oct->buf);
		
		sysno = 0;
		extract_rec_in_mem (zh, "grs.sgml",
				    oct->buf, oct->len,
				    databaseName,
				    0 /* delete_flag */,
				    0 /* test_mode */,
				    &sysno /* sysno */,
				    1 /* store_keys */,
				    1 /* store_data */,
				    0 /* match criteria */);
	    }
	}
    }
    return 0;
}

int zebra_admin_exchange_record (ZebraHandle zh,
                                 const char *database,
                                 const char *rec_buf,
                                 size_t rec_len,
                                 const char *recid_buf, size_t recid_len,
                                 int action)
{
    int sysno = 0;
    char *rinfo = 0;
    char recid_z[256];
    ASSERTZH;
    yaz_log(LOG_API,"zebra_admin_exchange_record db=%s ac=%d",
		    database, action);
    zh->errCode=0;

    if (!recid_buf || recid_len <= 0 || recid_len >= sizeof(recid_z))
        return -1;
    memcpy (recid_z, recid_buf, recid_len);
    recid_z[recid_len] = 0;

    zebra_begin_trans(zh,1);

    rinfo = dict_lookup (zh->reg->matchDict, recid_z);
    if (rinfo)
    {
        if (action == 1)  /* fail if insert */
        {
	     zebra_end_trans(zh);
	     return -1;
	}

        memcpy (&sysno, rinfo+1, sizeof(sysno));
    }