/**************************************************************
* Copyright (C) 2001 Alex Rozin, Optical Access
*
* All Rights Reserved
*
* Permission to use, copy, modify and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appear in all copies and that
* both that copyright notice and this permission notice appear in
* supporting documentation.
*
* ALEX ROZIN DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
* ALEX ROZIN BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
* ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
******************************************************************/
#include <net-snmp/net-snmp-config.h>
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include "agutil_api.h"
#include "rows.h"
#include "row_api.h"
#define MAX_CREATION_TIME 60
/*
* ***************************
*/
/*
* static file scope functions
*/
/*
* ***************************
*/
static void
rowapi_delete(RMON_ENTRY_T * eold)
{
register RMON_ENTRY_T *eptr;
register RMON_ENTRY_T *prev = NULL;
TABLE_DEFINTION_T *table_ptr;
table_ptr = (TABLE_DEFINTION_T *) eold->table_ptr;
/*
* delete timout scheduling
*/
snmp_alarm_unregister(eold->timer_id);
ag_trace("Entry %ld in %s has been deleted",
eold->ctrl_index, table_ptr->name);
/*
* It it was valid entry => deactivate it
*/
if (RMON1_ENTRY_VALID == eold->status) {
if (table_ptr->ClbkDeactivate)
table_ptr->ClbkDeactivate(eold);
}
/*
* delete it in users's sence
*/
if (table_ptr->ClbkDelete)
table_ptr->ClbkDelete((RMON_ENTRY_T *) eold->body);
if (eold->body) {
AGFREE(eold->body);
}
if (eold->owner)
AGFREE(eold->owner);
/*
* delete it from the list in table
*/
table_ptr->current_number_of_entries--;
for (eptr = table_ptr->first; eptr; eptr = eptr->next) {
if (eptr == eold)
break;
prev = eptr;
}
if (prev)
prev->next = eold->next;
else
table_ptr->first = eold->next;
AGFREE(eold);
}
static void
rowapi_too_long_creation_callback(unsigned int clientreg, void *clientarg)
{
RMON_ENTRY_T *eptr;
TABLE_DEFINTION_T *table_ptr;
eptr = (RMON_ENTRY_T *) clientarg;
table_ptr = (TABLE_DEFINTION_T *) eptr->table_ptr;
if (RMON1_ENTRY_VALID != eptr->status) {
ag_trace("row #%d in %s was under creation more then %ld sec.",
eptr->ctrl_index, table_ptr->name,
(long) MAX_CREATION_TIME);
rowapi_delete(eptr);
} else {
snmp_alarm_unregister(eptr->timer_id);
}
}
static int
rowapi_deactivate(TABLE_DEFINTION_T * table_ptr, RMON_ENTRY_T * eptr)
{
if (RMON1_ENTRY_UNDER_CREATION == eptr->status) {
/*
* nothing to do
*/
return SNMP_ERR_NOERROR;
}
if (table_ptr->ClbkDeactivate)
table_ptr->ClbkDeactivate(eptr);
eptr->status = RMON1_ENTRY_UNDER_CREATION;
eptr->timer_id = snmp_alarm_register(MAX_CREATION_TIME, 0,
rowapi_too_long_creation_callback,
eptr);
ag_trace("Entry %ld in %s has been deactivated",
eptr->ctrl_index, table_ptr->name);
return SNMP_ERR_NOERROR;
}
static int
rowapi_activate(TABLE_DEFINTION_T * table_ptr, RMON_ENTRY_T * eptr)
{
RMON1_ENTRY_STATUS_T prev_status = eptr->status;
eptr->status = RMON1_ENTRY_VALID;
if (table_ptr->ClbkActivate) {
if (0 != table_ptr->ClbkActivate(eptr)) {
ag_trace("Can't activate entry #%ld in %s",
eptr->ctrl_index, table_ptr->name);
eptr->status = prev_status;
return SNMP_ERR_BADVALUE;
}
}
snmp_alarm_unregister(eptr->timer_id);
eptr->timer_id = 0;
ag_trace("Entry %ld in %s has been activated",
eptr->ctrl_index, table_ptr->name);
return SNMP_ERR_NOERROR;
}
/*
* creates an entry, locats it in proper sorted order by index
* Row is initialized to zero,
* except: 'next', 'table_ptr', 'index',
* 'timer_id' & 'status'=(RMON1_ENTRY_UNDER_CREATION)
* Calls (if need) ClbkCreate.
* Schedules for timeout under entry creation (id of this
* scheduling is saved in 'timer_id').
* Returns 0: OK,
-1:max. number exedes;
-2:malloc failed;
-3:ClbkCreate failed */
int
ROWAPI_new(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
register RMON_ENTRY_T *prev = NULL;
register RMON_ENTRY_T *enew;
/*
* check on 'max.number'
*/
if (table_ptr->max_number_of_entries > 0 &&
table_ptr->current_number_of_entries >=
table_ptr->max_number_of_entries)
return -1;
/*
* allocate memory for the header
*/
enew = (RMON_ENTRY_T *) AGMALLOC(sizeof(RMON_ENTRY_T));
if (!enew)
return -2;
/*
* init the header
*/
memset(enew, 0, sizeof(RMON_ENTRY_T));
enew->ctrl_index = ctrl_index;
enew->table_ptr = (void *) table_ptr;
enew->status = RMON1_ENTRY_UNDER_CREATION;
enew->only_just_created = 1;
/*
* create the body: alloc it and set defaults
*/
if (table_ptr->ClbkCreate) {
if (0 != table_ptr->ClbkCreate(enew)) {
AGFREE(enew);
return -3;
}
}
table_ptr->current_number_of_entries++;
/*
* find the place : before 'eptr' and after 'prev'
*/
for (eptr = table_ptr->first; eptr; eptr = eptr->next) {
if (ctrl_index < eptr->ctrl_index)
break;
prev = eptr;
}
/*
* insert it
*/
enew->next = eptr;
if (prev)
prev->next = enew;
else
table_ptr->first = enew;
enew->timer_id = snmp_alarm_register(MAX_CREATION_TIME, 0,
rowapi_too_long_creation_callback,
enew);
ag_trace("Entry %ld in %s has been created",
enew->ctrl_index, table_ptr->name);
return 0;
}
/*
* ******************************
*/
/*
* external usage (API) functions
*/
/*
* ******************************
*/
void
ROWAPI_init_table(TABLE_DEFINTION_T * table_ptr,
const char *name,
u_long max_number_of_entries,
ENTRY_CALLBACK_T * ClbkCreate,
ENTRY_CALLBACK_T * ClbkClone,
ENTRY_CALLBACK_T * ClbkDelete,
ENTRY_CALLBACK_T * ClbkValidate,
ENTRY_CALLBACK_T * ClbkActivate,
ENTRY_CALLBACK_T * ClbkDeactivate,
ENTRY_CALLBACK_T * ClbkCopy)
{
table_ptr->name = name;
if (!table_ptr->name)
table_ptr->name = NETSNMP_REMOVE_CONST(char*,"Unknown");
table_ptr->max_number_of_entries = max_number_of_entries;
table_ptr->ClbkCreate = ClbkCreate;
table_ptr->ClbkClone = ClbkClone;
table_ptr->ClbkDelete = ClbkDelete;
table_ptr->ClbkValidate = ClbkValidate;
table_ptr->ClbkActivate = ClbkActivate;
table_ptr->ClbkDeactivate = ClbkDeactivate;
table_ptr->ClbkCopy = ClbkCopy;
table_ptr->first = NULL;
table_ptr->current_number_of_entries = 0;
}
void
ROWAPI_delete_clone(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (eptr) {
if (eptr->new_owner)
AGFREE(eptr->new_owner);
if (eptr->tmp) {
if (table_ptr->ClbkDelete)
table_ptr->ClbkDelete((RMON_ENTRY_T *) eptr->tmp);
AGFREE(eptr->tmp);
}
if (eptr->only_just_created) {
rowapi_delete(eptr);
}
}
}
RMON_ENTRY_T *
ROWAPI_get_clone(TABLE_DEFINTION_T * table_ptr,
u_long ctrl_index, size_t body_size)
{
register RMON_ENTRY_T *eptr;
if (ctrl_index < 1 || ctrl_index > 0xFFFFu) {
ag_trace("%s: index %ld out of range (1..65535)",
table_ptr->name, (long) ctrl_index);
return NULL;
}
/*
* get it
*/
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (!eptr) { /* try to create */
if (0 != ROWAPI_new(table_ptr, ctrl_index)) {
return NULL;
}
/*
* get it
*/
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (!eptr) /* it is unbelievable, but ... :( */
return NULL;
}
eptr->new_status = eptr->status;
eptr->tmp = AGMALLOC(body_size);
if (!eptr->tmp) {
if (eptr->only_just_created)
rowapi_delete(eptr);
return NULL;
}
memcpy(eptr->tmp, eptr->body, body_size);
if (table_ptr->ClbkClone)
table_ptr->ClbkClone(eptr);
if (eptr->new_owner)
AGFREE(eptr->new_owner);
return eptr->tmp;
}
RMON_ENTRY_T *
ROWAPI_first(TABLE_DEFINTION_T * table_ptr)
{
return table_ptr->first;
}
/*
* returns an entry with the smallest index
* which index > prev_index
*/
RMON_ENTRY_T *
ROWAPI_next(TABLE_DEFINTION_T * table_ptr, u_long prev_index)
{
register RMON_ENTRY_T *eptr;
for (eptr = table_ptr->first; eptr; eptr = eptr->next)
if (eptr->ctrl_index > prev_index)
return eptr;
return NULL;
}
RMON_ENTRY_T *
ROWAPI_find(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
for (eptr = table_ptr->first; eptr; eptr = eptr->next) {
if (eptr->ctrl_index == ctrl_index)
return eptr;
if (eptr->ctrl_index > ctrl_index)
break;
}
return NULL;
}
int
ROWAPI_action_check(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (!eptr) {
ag_trace("Smth wrong ?");
return SNMP_ERR_GENERR;
}
/*
* test owner string
*/
if (RMON1_ENTRY_UNDER_CREATION != eptr->status) {
/*
* Only the same value is allowed
*/
if (eptr->new_owner &&
(!eptr->owner
|| strncmp(eptr->new_owner, eptr->owner, MAX_OWNERSTRING))) {
ag_trace("invalid owner string in ROWAPI_action_check");
ag_trace("eptr->new_owner=%p eptr->owner=%p", eptr->new_owner,
eptr->owner);
return SNMP_ERR_BADVALUE;
}
}
switch (eptr->new_status) { /* this status we want to set */
case RMON1_ENTRY_CREATE_REQUEST:
if (RMON1_ENTRY_UNDER_CREATION != eptr->status)
return SNMP_ERR_BADVALUE;
break;
case RMON1_ENTRY_INVALID:
break;
case RMON1_ENTRY_VALID:
if (RMON1_ENTRY_VALID == eptr->status) {
break; /* nothing to do */
}
if (RMON1_ENTRY_UNDER_CREATION != eptr->status) {
ag_trace("Validate %s: entry %ld has wrong status %d",
table_ptr->name, (long) ctrl_index,
(int) eptr->status);
return SNMP_ERR_BADVALUE;
}
/*
* Our MIB understanding extension: we permit to set
* VALID when entry doesn't exit, in this case PDU has to have
* the nessessary & valid set of non-default values
*/
if (table_ptr->ClbkValidate) {
return table_ptr->ClbkValidate(eptr);
}
break;
case RMON1_ENTRY_UNDER_CREATION:
/*
* Our MIB understanding extension: we permit to travel from
* VALID to 'UNDER_CREATION' state
*/
break;
}
return SNMP_ERR_NOERROR;
}
int
ROWAPI_commit(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (!eptr) {
ag_trace("Smth wrong ?");
return SNMP_ERR_GENERR;
}
eptr->only_just_created = 0;
switch (eptr->new_status) { /* this status we want to set */
case RMON1_ENTRY_CREATE_REQUEST: /* copy tmp => eprt */
if (eptr->new_owner) {
if (eptr->owner)
AGFREE(eptr->owner);
eptr->owner = AGSTRDUP(eptr->new_owner);
}
if (table_ptr->ClbkCopy && eptr->tmp)
table_ptr->ClbkCopy(eptr);
break;
case RMON1_ENTRY_INVALID:
ROWAPI_delete_clone(table_ptr, ctrl_index);
rowapi_delete(eptr);
#if 0 /* for debug */
dbg_f_AG_MEM_REPORT();
#endif
break;
case RMON1_ENTRY_VALID: /* copy tmp => eprt and activate */
/*
* Our MIB understanding extension: we permit to set
* VALID when entry doesn't exit, in this case PDU has to have
* the nessessary & valid set of non-default values
*/
if (eptr->new_owner) {
if (eptr->owner)
AGFREE(eptr->owner);
eptr->owner = AGSTRDUP(eptr->new_owner);
}
if (table_ptr->ClbkCopy && eptr->tmp)
table_ptr->ClbkCopy(eptr);
if (RMON1_ENTRY_VALID != eptr->status) {
rowapi_activate(table_ptr, eptr);
}
break;
case RMON1_ENTRY_UNDER_CREATION: /* deactivate (if need) and copy tmp => eprt */
/*
* Our MIB understanding extension: we permit to travel from
* VALID to 'UNDER_CREATION' state
*/
rowapi_deactivate(table_ptr, eptr);
if (eptr->new_owner) {
if (eptr->owner)
AGFREE(eptr->owner);
eptr->owner = AGSTRDUP(eptr->new_owner);
}
if (table_ptr->ClbkCopy && eptr->tmp)
table_ptr->ClbkCopy(eptr);
break;
}
ROWAPI_delete_clone(table_ptr, ctrl_index);
return SNMP_ERR_NOERROR;
}
RMON_ENTRY_T *
ROWAPI_header_ControlEntry(struct variable * vp, oid * name,
size_t * length, int exact,
size_t * var_len,
TABLE_DEFINTION_T * table_ptr,
void *entry_ptr, size_t entry_size)
{
long ctrl_index;
RMON_ENTRY_T *hdr = NULL;
if (0 != AGUTIL_advance_index_name(vp, name, length, exact)) {
ag_trace("cannot advance_index_name");
return NULL;
}
ctrl_index = vp->namelen >= *length ? 0 : name[vp->namelen];
if (exact) {
if (ctrl_index)
hdr = ROWAPI_find(table_ptr, ctrl_index);
} else {
if (ctrl_index)
hdr = ROWAPI_next(table_ptr, ctrl_index);
else
hdr = ROWAPI_first(table_ptr);
if (hdr) { /* set new index */
name[vp->namelen] = hdr->ctrl_index;
*length = vp->namelen + 1;
}
}
if (hdr)
memcpy(entry_ptr, hdr->body, entry_size);
return hdr;
}
int
ROWAPI_do_another_action(oid * name, int tbl_first_index_begin,
int action, int *prev_action,
TABLE_DEFINTION_T * table_ptr, size_t entry_size)
{
long long_temp;
RMON_ENTRY_T *tmp;
if (action == *prev_action)
return SNMP_ERR_NOERROR; /* I want to process it only once ! */
*prev_action = action;
long_temp = name[tbl_first_index_begin];
switch (action) {
case RESERVE1:
tmp = ROWAPI_get_clone(table_ptr, long_temp, entry_size);
if (!tmp) {
ag_trace("RESERVE1: cannot get clone\n");
return SNMP_ERR_TOOBIG;
}
break;
case FREE: /* if RESERVEx failed: release any resources that have been allocated */
case UNDO: /* if ACTION failed: release any resources that have been allocated */
ROWAPI_delete_clone(table_ptr, long_temp);
break;
case ACTION:
long_temp = ROWAPI_action_check(table_ptr, long_temp);
if (0 != long_temp)
return long_temp;
break;
case COMMIT:
long_temp = ROWAPI_commit(table_ptr, long_temp);
if (0 != long_temp) /* it MUST NOT be */
return long_temp;
break;
default:
ag_trace("Unknown action %d", (int) action);
return SNMP_ERR_GENERR;
} /* of switch by actions */
return SNMP_ERR_NOERROR;
}
/*
* data tables API section
*/
int
ROWDATAAPI_init(SCROLLER_T * scrlr,
u_long data_requested,
u_long max_number_of_entries,
size_t data_size,
int (*data_destructor) (struct data_scroller *, void *))
{
scrlr->data_granted = 0;
scrlr->data_created = 0;
scrlr->data_total_number = 0;
scrlr->first_data_ptr =
scrlr->last_data_ptr = scrlr->current_data_ptr = NULL;
scrlr->max_number_of_entries = max_number_of_entries;
scrlr->data_size = data_size;
scrlr->data_destructor = data_destructor;
ROWDATAAPI_set_size(scrlr, data_requested, 0);
return 0;
}
static int
delete_data_entry(SCROLLER_T * scrlr, void *delete_me)
{
NEXTED_PTR_T *data_ptr = delete_me;
register NEXTED_PTR_T *tmp;
if (data_ptr == scrlr->first_data_ptr) {
scrlr->first_data_ptr = data_ptr->next;
if (data_ptr == scrlr->last_data_ptr)
scrlr->last_data_ptr = NULL;
} else { /* not first */
for (tmp = scrlr->first_data_ptr; tmp; tmp = tmp->next) {
if (tmp->next == data_ptr) {
if (data_ptr == scrlr->last_data_ptr)
scrlr->last_data_ptr = tmp;
tmp->next = data_ptr->next;
break;
}
} /* for */
} /* not first */
if (data_ptr == scrlr->current_data_ptr)
scrlr->current_data_ptr = data_ptr->next;
if (scrlr->data_destructor)
scrlr->data_destructor(scrlr, data_ptr);
AGFREE(data_ptr);
scrlr->data_created--;
scrlr->data_stored--;
return 0;
}
static void
realloc_number_of_data(SCROLLER_T * scrlr, long dlong)
{
void *bptr; /* DATA_ENTRY_T */
NEXTED_PTR_T *prev = NULL;
void *first = NULL;
if (dlong > 0) {
for (; dlong; dlong--, prev = bptr, scrlr->data_created++) {
bptr = AGMALLOC(scrlr->data_size);
if (!bptr) {
ag_trace("Err: no memory for data");
break;
}
memset(bptr, 0, scrlr->data_size);
if (prev)
prev->next = bptr;
else
first = bptr;
} /* of loop by malloc bucket */
if (!scrlr->current_data_ptr)
scrlr->current_data_ptr = first;
if (scrlr->last_data_ptr) {
scrlr->last_data_ptr->next = first;
} else
scrlr->first_data_ptr = first;
scrlr->last_data_ptr = bptr;
} else {
for (; dlong && scrlr->data_created > 0; dlong++) {
if (scrlr->current_data_ptr)
delete_data_entry(scrlr, scrlr->current_data_ptr);
else
delete_data_entry(scrlr, scrlr->first_data_ptr);
}
}
}
void
ROWDATAAPI_set_size(SCROLLER_T * scrlr,
u_long data_requested, u_char do_allocation)
{
long dlong;
scrlr->data_requested = data_requested;
scrlr->data_granted = (data_requested < scrlr->max_number_of_entries) ?
data_requested : scrlr->max_number_of_entries;
if (do_allocation) {
dlong = (long) scrlr->data_granted - (long) scrlr->data_created;
realloc_number_of_data(scrlr, dlong);
}
}
void
ROWDATAAPI_descructor(SCROLLER_T * scrlr)
{
register NEXTED_PTR_T *bptr;
register void *next;
for (bptr = scrlr->first_data_ptr; bptr; bptr = next) {
next = bptr->next;
if (scrlr->data_destructor)
scrlr->data_destructor(scrlr, bptr);
AGFREE(bptr);
}
scrlr->data_created = 0;
scrlr->data_granted = 0;
scrlr->first_data_ptr =
scrlr->last_data_ptr = scrlr->current_data_ptr = NULL;
}
void *
ROWDATAAPI_locate_new_data(SCROLLER_T * scrlr)
{
register NEXTED_PTR_T *bptr;
if (!scrlr->current_data_ptr) { /* there was wrap */
bptr = scrlr->first_data_ptr;
if (!bptr) {
ag_trace("Err: SCROLLER_T:locate_new_data: internal error :(");
return NULL;
}
scrlr->first_data_ptr = bptr->next;
scrlr->last_data_ptr->next = bptr;
scrlr->last_data_ptr = (NEXTED_PTR_T *) bptr;
bptr->next = NULL;
} else {
bptr = scrlr->current_data_ptr;
scrlr->current_data_ptr = bptr->next;
++scrlr->data_stored;
}
scrlr->data_total_number++;
return bptr;
}
u_long
ROWDATAAPI_get_total_number(SCROLLER_T * scrlr)
{
return scrlr->data_total_number;
}
RMON_ENTRY_T *
ROWDATAAPI_header_DataEntry(struct variable * vp, oid * name,
size_t * length, int exact,
size_t * var_len,
TABLE_DEFINTION_T * table_ptr,
SCROLLER_T * (*extract_scroller) (void *body),
size_t data_size, void *entry_ptr)
{
long ctrl_indx, data_index;
RMON_ENTRY_T *hdr = NULL;
SCROLLER_T *scrlr;
NEXTED_PTR_T *bptr = NULL;
register u_long iii;
if (0 != AGUTIL_advance_index_name(vp, name, length, exact)) {
ag_trace("cannot advance_index_name");
return NULL;
}
ctrl_indx = vp->namelen >= *length ? 0 : name[vp->namelen];
if (ctrl_indx)
data_index =
((int)(vp->namelen + 1) >= (int)*length) ? 0 : name[vp->namelen + 1];
else
data_index = 0;
if (exact) {
if (ctrl_indx && data_index) {
hdr = ROWAPI_find(table_ptr, ctrl_indx);
if (hdr) {
scrlr = extract_scroller(hdr->body);
bptr = scrlr->first_data_ptr;
for (iii = 0; iii < scrlr->data_stored && bptr;
iii++, bptr = bptr->next) {
if ((long)bptr->data_index == data_index)
break;
}
if (!bptr)
hdr = NULL;
}
}
} else {
if (ctrl_indx)
hdr = ROWAPI_find(table_ptr, ctrl_indx);
else
hdr = ROWAPI_first(table_ptr);
if (hdr) {
scrlr = extract_scroller(hdr->body);
/*
* ag_trace ("get next after (%d %d)", (int) ctrl_indx, (int) data_index);
*/
bptr = scrlr->first_data_ptr;
for (iii = 0; iii < scrlr->data_stored && bptr;
iii++, bptr = bptr->next) {
if (bptr->data_index && (long)bptr->data_index > data_index)
break;
}
if (bptr && (long)bptr->data_index <= data_index)
bptr = NULL;
if (!bptr) { /* travel to next row */
/*
* ag_trace ("Dbg: travel to next row");
*/
for (hdr = hdr->next; hdr; hdr = hdr->next) {
if (RMON1_ENTRY_VALID != hdr->status)
continue;
scrlr = extract_scroller(hdr->body);
if (scrlr->data_stored <= 0)
continue;
for (bptr = scrlr->first_data_ptr; bptr;
bptr = bptr->next) {
if (bptr->data_index)
break;
}
if (bptr)
break;
}
}
if (bptr) { /* set new index */
/*
* ag_trace ("Dbg: So (%d %d)", (int) hdr->index, (int) bptr->data_index);
*/
name[vp->namelen] = hdr->ctrl_index;
name[vp->namelen + 1] = bptr->data_index;
*length = vp->namelen + 2;
} else
hdr = NULL;
}
}
if (hdr)
memcpy(entry_ptr, bptr, data_size);
return hdr;
}
void
init_rows(void)
{
}