This file is indexed.

/usr/include/net-snmp/agent/watcher.h is in libsnmp-dev 5.7.3+dfsg-1.8ubuntu3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/*
 * watcher.h 
 */
#ifndef NETSNMP_WATCHER_H
#define NETSNMP_WATCHER_H

#ifdef __cplusplus
extern "C" {
#endif

/** @ingroup watcher
 *  @{
 */

/*
 * if handler flag has this bit set, the timestamp will be
 * treated as a pointer to the timestamp. If this bit is
 * not set (the default), the timestamp is a struct timeval
 * that must be compared to the agent starttime.
 */
#define NETSNMP_WATCHER_DIRECT MIB_HANDLER_CUSTOM1

/** The size of the watched object is constant.
 *  @hideinitializer
 */
#define WATCHER_FIXED_SIZE     0x01
/** The maximum size of the watched object is stored in max_size.
 *  If WATCHER_SIZE_STRLEN is set then it is supposed that max_size + 1
 *  bytes could be stored in the buffer.
 *  @hideinitializer
 */
#define WATCHER_MAX_SIZE       0x02
/** If set then the variable data_size_p points to is supposed to hold the
 *  current size of the watched object and will be updated on writes.
 *  @hideinitializer
 *  @since Net-SNMP 5.5
 */
#define WATCHER_SIZE_IS_PTR    0x04
/** If set then data is suppposed to be a zero-terminated character array
 *  and both data_size and data_size_p are ignored. Additionally \\0 is a
 *  forbidden character in the data set.
 *  @hideinitializer
 *  @since Net-SNMP 5.5
 */
#define WATCHER_SIZE_STRLEN    0x08
/** If set then size is in units of object identifiers.
 *  This is useful if you have an OID and tracks the OID_LENGTH of it as
 *  opposed to it's size.
 *  @hideinitializer
 *  @since Net-SNMP 5.5.1
 */
#define WATCHER_SIZE_UNIT_OIDS 0x10

typedef struct netsnmp_watcher_info_s {
    void     *data;
    size_t    data_size;
    size_t    max_size;
    u_char    type;
    int       flags;
    size_t   *data_size_p;
} netsnmp_watcher_info;

/** @} */

int netsnmp_register_watched_instance( netsnmp_handler_registration *reginfo,
                                       netsnmp_watcher_info         *winfo);
int netsnmp_register_watched_instance2(netsnmp_handler_registration *reginfo,
                                       netsnmp_watcher_info         *winfo);
int netsnmp_register_watched_scalar(   netsnmp_handler_registration *reginfo,
                                       netsnmp_watcher_info         *winfo);
int netsnmp_register_watched_scalar2(  netsnmp_handler_registration *reginfo,
                                       netsnmp_watcher_info         *winfo);
int netsnmp_register_watched_timestamp(netsnmp_handler_registration *reginfo,
                                       marker_t timestamp);
int netsnmp_watched_timestamp_register(netsnmp_mib_handler *whandler,
                                       netsnmp_handler_registration *reginfo,
                                       marker_t timestamp);
int netsnmp_register_watched_spinlock(netsnmp_handler_registration *reginfo,
                                      int *spinlock);    

/*
 * Convenience registration calls
 */

int netsnmp_register_ulong_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              u_long * it,
                              Netsnmp_Node_Handler * subhandler);
int netsnmp_register_read_only_ulong_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              u_long * it,
                              Netsnmp_Node_Handler * subhandler);
int netsnmp_register_long_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              long * it,
                              Netsnmp_Node_Handler * subhandler);
int netsnmp_register_read_only_long_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              long * it,
                              Netsnmp_Node_Handler * subhandler);
int netsnmp_register_int_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              int * it,
                              Netsnmp_Node_Handler * subhandler);
int netsnmp_register_read_only_int_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              int * it,
                              Netsnmp_Node_Handler * subhandler);
int netsnmp_register_read_only_counter32_scalar(const char *name,
                              const oid * reg_oid, size_t reg_oid_len,
                              u_long * it,
                              Netsnmp_Node_Handler * subhandler);

#define WATCHER_HANDLER_NAME "watcher"

netsnmp_mib_handler  *netsnmp_get_watcher_handler(void);

netsnmp_watcher_info *
netsnmp_init_watcher_info(netsnmp_watcher_info *, void *, size_t, u_char, int);

netsnmp_watcher_info *
netsnmp_init_watcher_info6(netsnmp_watcher_info *,
			   void *, size_t, u_char, int, size_t, size_t*);

netsnmp_watcher_info *
netsnmp_create_watcher_info(void *, size_t, u_char, int);

netsnmp_watcher_info *
netsnmp_create_watcher_info6(void *, size_t, u_char, int, size_t, size_t*);

netsnmp_watcher_info *
netsnmp_clone_watcher_info(netsnmp_watcher_info *winfo);
void
netsnmp_owns_watcher_info(netsnmp_mib_handler *handler);

Netsnmp_Node_Handler  netsnmp_watcher_helper_handler;

netsnmp_mib_handler  *netsnmp_get_watched_timestamp_handler(void);
Netsnmp_Node_Handler  netsnmp_watched_timestamp_handler;

netsnmp_mib_handler  *netsnmp_get_watched_spinlock_handler(void);
Netsnmp_Node_Handler  netsnmp_watched_spinlock_handler;

#ifdef __cplusplus
}
#endif

#endif /** NETSNMP_WATCHER_H */