Exemple #1
0
void run_alarms(void)
{
	int done = 0;
	struct zevent_alarm *a = NULL;
	unsigned int clientreg;
	struct timeval t_now;

	/*
	 *      * Loop through everything we have repeatedly looking for the next thing to
	 *           * call until all events are finally in the future again.  
	 *                */

	while(!done) {
		if((a = sa_find_next()) == NULL) {
			return;
		}

		gettimeofday(&t_now, NULL);

		if((a->t_next.tv_sec < t_now.tv_sec) ||
				((a->t_next.tv_sec == t_now.tv_sec) &&
				 (a->t_next.tv_usec < t_now.tv_usec))) {
			clientreg = a->clientreg;
			printf("run alarm %d\n", clientreg);
			(*(a->thecallback)) (clientreg, a->clientarg);
			printf("alarm %d completed\n", clientreg);

			if((a = sa_find_specific(clientreg)) != NULL) {
				a->t_last.tv_sec = t_now.tv_sec;
				a->t_last.tv_usec = t_now.tv_usec;
				a->t_next.tv_sec = 0;
				a->t_next.tv_usec = 0;
				sa_update_entry(a);
			}
			else {
				printf("alarm %d deleted itself\n", clientreg);
			}
		}
		else {
			done = 1;
		}
	}
}
Exemple #2
0
int
handle_nsCacheTable(netsnmp_mib_handler *handler,
                    netsnmp_handler_registration *reginfo,
                    netsnmp_agent_request_info *reqinfo,
                    netsnmp_request_info *requests)
{
    long status;
    netsnmp_request_info       *request     = NULL;
    netsnmp_table_request_info *table_info  = NULL;
    netsnmp_cache              *cache_entry = NULL;

    switch (reqinfo->mode) {

    case MODE_GET:
        for (request=requests; request; request=request->next) {
            if (request->processed != 0)
                continue;

            cache_entry = (netsnmp_cache*)netsnmp_extract_iterator_context(request);
            table_info  =                 netsnmp_extract_table_info(request);

            switch (table_info->colnum) {
            case NSCACHE_TIMEOUT:
                if (!cache_entry) {
                    netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE);
                    continue;
                }
                status = cache_entry->timeout;
                snmp_set_var_typed_value(request->requestvb, ASN_INTEGER,
                                         (u_char*)&status, sizeof(status));
                break;

            case NSCACHE_STATUS:
                if (!cache_entry) {
                    netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE);
                    continue;
                }
                status = (cache_entry->enabled ?
                          (cache_entry->timestamp ?
                           (!atime_ready(cache_entry->timestamp,
                                         1000*cache_entry->timeout) ?
                            NSCACHE_STATUS_ACTIVE:
                            NSCACHE_STATUS_EXPIRED) :
                           NSCACHE_STATUS_EMPTY) :
                          NSCACHE_STATUS_DISABLED);
                snmp_set_var_typed_value(request->requestvb, ASN_INTEGER,
                                         (u_char*)&status, sizeof(status));
                break;

            default:
                netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
                continue;
            }
        }
        break;


#ifndef NETSNMP_NO_WRITE_SUPPORT
    case MODE_SET_RESERVE1:
        for (request=requests; request; request=request->next) {
            if (request->processed != 0)
                continue;
            if ( request->status != 0 ) {
                return SNMP_ERR_NOERROR;	/* Already got an error */
            }
            cache_entry = (netsnmp_cache*)netsnmp_extract_iterator_context(request);
            table_info  =                 netsnmp_extract_table_info(request);

            switch (table_info->colnum) {
            case NSCACHE_TIMEOUT:
                if (!cache_entry) {
                    netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION);
                    return SNMP_ERR_NOCREATION;
                }
                if ( request->requestvb->type != ASN_INTEGER ) {
                    netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGTYPE);
                    return SNMP_ERR_WRONGTYPE;
                }
                if (*request->requestvb->val.integer < 0 ) {
                    netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGVALUE);
                    return SNMP_ERR_WRONGVALUE;
                }
                break;

            case NSCACHE_STATUS:
                if (!cache_entry) {
                    netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION);
                    return SNMP_ERR_NOCREATION;
                }
                if ( request->requestvb->type != ASN_INTEGER ) {
                    netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGTYPE);
                    return SNMP_ERR_WRONGTYPE;
                }
                status = *request->requestvb->val.integer;
                if (!((status == NSCACHE_STATUS_ENABLED  ) ||
                        (status == NSCACHE_STATUS_DISABLED ) ||
                        (status == NSCACHE_STATUS_EMPTY  ))) {
                    netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGVALUE);
                    return SNMP_ERR_WRONGVALUE;
                }
                break;

            default:
                netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION);
                return SNMP_ERR_NOCREATION;	/* XXX - is this right ? */
            }
        }
        break;


    case MODE_SET_COMMIT:
        for (request=requests; request; request=request->next) {
            if (request->processed != 0)
                continue;
            if ( request->status != 0 ) {
                return SNMP_ERR_NOERROR;	/* Already got an error */
            }
            cache_entry = (netsnmp_cache*)netsnmp_extract_iterator_context(request);
            if (!cache_entry) {
                netsnmp_set_request_error(reqinfo, request, SNMP_ERR_COMMITFAILED);
                return SNMP_ERR_COMMITFAILED;	/* Shouldn't happen! */
            }
            table_info  =                 netsnmp_extract_table_info(request);

            switch (table_info->colnum) {
            case NSCACHE_TIMEOUT:
                cache_entry->timeout = *request->requestvb->val.integer;
                /*
                 * check for auto repeat
                 */
                if (cache_entry->timer_id) {
                    struct snmp_alarm * sa =
                        sa_find_specific(cache_entry->timer_id);
                    if (NULL != sa)
                        sa->t.tv_sec = cache_entry->timeout;
                }
                break;

            case NSCACHE_STATUS:
                switch (*request->requestvb->val.integer) {
                case NSCACHE_STATUS_ENABLED:
                    cache_entry->enabled = 1;
                    break;
                case NSCACHE_STATUS_DISABLED:
                    cache_entry->enabled = 0;
                    break;
                case NSCACHE_STATUS_EMPTY:
                    cache_entry->free_cache(cache_entry, cache_entry->magic);
                    free(cache_entry->timestamp);
                    cache_entry->timestamp = NULL;
                    break;
                }
                break;
            }
        }
        break;
#endif /* !NETSNMP_NO_WRITE_SUPPORT */
    }

    return SNMP_ERR_NOERROR;
}