1use libc;
2use std::os::raw;
3use auto::*;
4
5pub type marker_t = *mut raw::c_void;
6pub type const_marker_t = *const raw::c_void;
7
8#[repr(C)]
9pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
10impl <T> __BindgenUnionField<T> {
11 #[inline]
12 pub fn new() -> Self { __BindgenUnionField(::std::marker::PhantomData) }
13 #[inline]
14 pub unsafe fn as_ref(&self) -> &T { ::std::mem::transmute(self) }
15 #[inline]
16 pub unsafe fn as_mut(&mut self) -> &mut T { ::std::mem::transmute(self) }
17}
18impl <T> ::std::default::Default for __BindgenUnionField<T> {
19 #[inline]
20 fn default() -> Self { Self::new() }
21}
22impl <T> ::std::clone::Clone for __BindgenUnionField<T> {
23 #[inline]
24 fn clone(&self) -> Self { Self::new() }
25}
26impl <T> ::std::marker::Copy for __BindgenUnionField<T> { }
27impl <T> ::std::fmt::Debug for __BindgenUnionField<T> {
28 fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
29 fmt.write_str("__BindgenUnionField")
30 }
31}
32
33
34#[repr(C)]
35#[derive(Copy)]
36pub struct div_t {
37 pub quot: raw::c_int,
38 pub rem: raw::c_int,
39}
40impl Clone for div_t {
41 fn clone(&self) -> Self { *self }
42}
43
44pub type Netsnmp_Free_List_Data =
45 ::std::option::Option<unsafe extern "C" fn(arg1:
46 *mut raw::c_void)>;
47pub type Netsnmp_Save_List_Data =
48 ::std::option::Option<unsafe extern "C" fn(buf:
49 *mut raw::c_char,
50 buf_len: usize,
51 arg1:
52 *mut raw::c_void)
53 -> raw::c_int>;
54pub type Netsnmp_Read_List_Data =
55 ::std::option::Option<unsafe extern "C" fn(buf:
56 *mut raw::c_char,
57 buf_len: usize)
58 -> *mut raw::c_void>;
59#[repr(C)]
60#[derive(Copy)]
61pub struct netsnmp_data_list_s {
62 pub next: *mut netsnmp_data_list_s,
63 pub name: *mut raw::c_char,
64 pub data: *mut raw::c_void,
65 pub free_func: Netsnmp_Free_List_Data,
66}
67impl Clone for netsnmp_data_list_s {
68 fn clone(&self) -> Self { *self }
69}
70pub type netsnmp_data_list = netsnmp_data_list_s;
71#[repr(C)]
72#[derive(Copy)]
73pub struct netsnmp_data_list_saveinfo_s {
74 pub datalist: *mut *mut netsnmp_data_list,
75 pub type_: *const raw::c_char,
76 pub token: *const raw::c_char,
77 pub data_list_save_ptr: Netsnmp_Save_List_Data,
78 pub data_list_read_ptr: Netsnmp_Read_List_Data,
79 pub data_list_free_ptr: Netsnmp_Free_List_Data,
80}
81
82impl Clone for netsnmp_data_list_saveinfo_s {
83 fn clone(&self) -> Self { *self }
84}
85pub type netsnmp_data_list_saveinfo = netsnmp_data_list_saveinfo_s;
86extern "C" {
87 pub fn netsnmp_create_data_list(arg1: *const raw::c_char,
88 arg2: *mut raw::c_void,
89 arg3: Netsnmp_Free_List_Data)
90 -> *mut netsnmp_data_list;
91
92 pub fn netsnmp_data_list_add_node(head: *mut *mut netsnmp_data_list,
93 node: *mut netsnmp_data_list);
94
95 pub fn netsnmp_data_list_add_data(head: *mut *mut netsnmp_data_list,
96 name: *const raw::c_char,
97 data: *mut raw::c_void,
98 beer: Netsnmp_Free_List_Data)
99 -> *mut netsnmp_data_list;
100
101 pub fn netsnmp_get_list_data(head: *mut netsnmp_data_list,
102 node: *const raw::c_char)
103 -> *mut raw::c_void;
104
105 pub fn netsnmp_free_list_data(head: *mut netsnmp_data_list);
106
107 pub fn netsnmp_free_all_list_data(head: *mut netsnmp_data_list);
108
109 pub fn netsnmp_remove_list_node(realhead: *mut *mut netsnmp_data_list,
110 name: *const raw::c_char)
111 -> raw::c_int;
112
113 pub fn netsnmp_get_list_node(head: *mut netsnmp_data_list,
114 name: *const raw::c_char)
115 -> *mut netsnmp_data_list;
116
117 pub fn netsnmp_add_list_data(head: *mut *mut netsnmp_data_list,
118 node: *mut netsnmp_data_list);
119
120 pub fn netsnmp_register_save_list(datalist: *mut *mut netsnmp_data_list,
121 type_: *const raw::c_char,
122 token: *const raw::c_char,
123 data_list_save_ptr:
124 Netsnmp_Save_List_Data,
125 data_list_read_ptr:
126 Netsnmp_Read_List_Data,
127 data_list_free_ptr:
128 Netsnmp_Free_List_Data);
129
130 pub fn netsnmp_save_all_data(head: *mut netsnmp_data_list,
131 type_: *const raw::c_char,
132 token: *const raw::c_char,
133 data_list_save_ptr: Netsnmp_Save_List_Data)
134 -> raw::c_int;
135
136 pub fn netsnmp_save_all_data_callback(majorID: raw::c_int,
137 minorID: raw::c_int,
138 serverarg:
139 *mut raw::c_void,
140 clientarg:
141 *mut raw::c_void)
142 -> raw::c_int;
143
144 pub fn netsnmp_read_data_callback(token: *const raw::c_char,
145 line: *mut raw::c_char);
146
147 #[link_name = "log_addresses"]
148 pub static mut log_addresses: raw::c_int;
149
150 #[link_name = "lastAddrAge"]
151 pub static mut lastAddrAge: raw::c_int;
152}
153#[repr(C)]
154#[derive(Copy)]
155pub struct netsnmp_request_info_s {
156 pub requestvb: *mut netsnmp_variable_list,
157 pub parent_data: *mut netsnmp_data_list,
158 pub agent_req_info: *mut netsnmp_agent_request_info_s,
159 pub range_end: *mut oid,
160 pub range_end_len: usize,
161 pub delegated: raw::c_int,
162 pub processed: raw::c_int,
163 pub inclusive: raw::c_int,
164 pub status: raw::c_int,
165 pub index: raw::c_int,
166 pub repeat: raw::c_int,
167 pub orig_repeat: raw::c_int,
168 pub requestvb_start: *mut netsnmp_variable_list,
169 pub next: *mut netsnmp_request_info_s,
170 pub prev: *mut netsnmp_request_info_s,
171 pub subtree: *mut netsnmp_subtree_s,
172}
173
174impl Clone for netsnmp_request_info_s {
175 fn clone(&self) -> Self { *self }
176}
177pub type netsnmp_request_info = netsnmp_request_info_s;
178#[repr(C)]
179#[derive(Copy)]
180pub struct netsnmp_set_info_s {
181 pub action: raw::c_int,
182 pub stateRef: *mut raw::c_void,
183 pub oldData: *mut *mut raw::c_void,
184 pub setCleanupFlags: raw::c_int,
185}
186
187impl Clone for netsnmp_set_info_s {
188 fn clone(&self) -> Self { *self }
189}
190pub type netsnmp_set_info = netsnmp_set_info_s;
191#[repr(C)]
192#[derive(Copy)]
193pub struct netsnmp_tree_cache_s {
194 pub subtree: *mut netsnmp_subtree_s,
195 pub requests_begin: *mut netsnmp_request_info,
196 pub requests_end: *mut netsnmp_request_info,
197}
198
199impl Clone for netsnmp_tree_cache_s {
200 fn clone(&self) -> Self { *self }
201}
202pub type netsnmp_tree_cache = netsnmp_tree_cache_s;
203#[repr(C)]
204#[derive(Copy)]
205pub struct netsnmp_agent_request_info_s {
206 pub mode: raw::c_int,
207 pub asp: *mut netsnmp_agent_session_s,
208 pub agent_data: *mut netsnmp_data_list,
209}
210
211impl Clone for netsnmp_agent_request_info_s {
212 fn clone(&self) -> Self { *self }
213}
214pub type netsnmp_agent_request_info = netsnmp_agent_request_info_s;
215#[repr(C)]
216#[derive(Copy)]
217pub struct netsnmp_cachemap_s {
218 pub globalid: raw::c_int,
219 pub cacheid: raw::c_int,
220 pub next: *mut netsnmp_cachemap_s,
221}
222
223impl Clone for netsnmp_cachemap_s {
224 fn clone(&self) -> Self { *self }
225}
226pub type netsnmp_cachemap = netsnmp_cachemap_s;
227#[repr(C)]
228#[derive(Copy)]
229pub struct netsnmp_agent_session_s {
230 pub mode: raw::c_int,
231 pub session: *mut netsnmp_session,
232 pub pdu: *mut netsnmp_pdu,
233 pub orig_pdu: *mut netsnmp_pdu,
234 pub rw: raw::c_int,
235 pub exact: raw::c_int,
236 pub status: raw::c_int,
237 pub index: raw::c_int,
238 pub oldmode: raw::c_int,
239 pub next: *mut netsnmp_agent_session_s,
240 pub reqinfo: *mut netsnmp_agent_request_info,
241 pub requests: *mut netsnmp_request_info,
242 pub treecache: *mut netsnmp_tree_cache,
243 pub bulkcache: *mut *mut netsnmp_variable_list,
244 pub treecache_len: raw::c_int,
245 pub treecache_num: raw::c_int,
246 pub cache_store: *mut netsnmp_cachemap,
247 pub vbcount: raw::c_int,
248}
249
250impl Clone for netsnmp_agent_session_s {
251 fn clone(&self) -> Self { *self }
252}
253pub type netsnmp_agent_session = netsnmp_agent_session_s;
254extern "C" {
255 pub fn netsnmp_addrcache_initialise();
256
257 pub fn netsnmp_addrcache_destroy();
258
259 pub fn netsnmp_addrcache_age();
260
261 pub fn handle_snmp_packet(arg1: raw::c_int,
262 arg2: *mut netsnmp_session,
263 arg3: raw::c_int,
264 arg4: *mut netsnmp_pdu,
265 arg5: *mut raw::c_void)
266 -> raw::c_int;
267
268 pub fn snmp_agent_parse_config(arg1: *mut raw::c_char,
269 arg2: *mut raw::c_char);
270
271 pub fn init_agent_snmp_session(arg1: *mut netsnmp_session,
272 arg2: *mut netsnmp_pdu)
273 -> *mut netsnmp_agent_session;
274
275 pub fn free_agent_snmp_session(arg1: *mut netsnmp_agent_session);
276
277 pub fn netsnmp_remove_and_free_agent_snmp_session(asp:
278 *mut netsnmp_agent_session);
279
280 pub fn getNextSessID() -> raw::c_int;
281
282 pub fn dump_sess_list();
283
284 pub fn init_master_agent() -> raw::c_int;
285
286 pub fn shutdown_master_agent();
287
288 pub fn agent_check_and_process(block: raw::c_int)
289 -> raw::c_int;
290
291 pub fn netsnmp_check_outstanding_agent_requests();
292
293 pub fn netsnmp_request_set_error(request: *mut netsnmp_request_info,
294 error_value: raw::c_int)
295 -> raw::c_int;
296
297 pub fn netsnmp_check_requests_error(reqs: *mut netsnmp_request_info)
298 -> raw::c_int;
299
300 pub fn netsnmp_check_all_requests_error(asp: *mut netsnmp_agent_session,
301 look_for_specific:
302 raw::c_int)
303 -> raw::c_int;
304
305 pub fn netsnmp_set_all_requests_error(reqinfo:
306 *mut netsnmp_agent_request_info,
307 requests: *mut netsnmp_request_info,
308 error_value: raw::c_int)
309 -> raw::c_int;
310
311 pub fn netsnmp_request_set_error_idx(requests: *mut netsnmp_request_info,
312 error_value: raw::c_int,
313 idx: raw::c_int)
314 -> raw::c_int;
315
316 pub fn netsnmp_request_set_error_all(requests: *mut netsnmp_request_info,
317 error_value: raw::c_int)
318 -> raw::c_int;
319
320 pub fn netsnmp_set_request_error(reqinfo: *mut netsnmp_agent_request_info,
321 request: *mut netsnmp_request_info,
322 error_value: raw::c_int)
323 -> raw::c_int;
324
325 pub fn netsnmp_set_mode_request_error(mode: raw::c_int,
326 request: *mut netsnmp_request_info,
327 error_value: raw::c_int)
328 -> raw::c_int;
329
330 pub fn netsnmp_marker_uptime(pm: marker_t) -> raw::c_ulong;
331
332 pub fn netsnmp_timeval_uptime(tv: *mut libc::timeval) -> raw::c_ulong;
333
334 pub fn netsnmp_get_agent_starttime() -> const_marker_t;
335
336 pub fn netsnmp_get_agent_runtime() -> u64;
337
338 pub fn netsnmp_set_agent_starttime(s: marker_t);
339
340 pub fn netsnmp_get_agent_uptime() -> raw::c_ulong;
341
342 pub fn netsnmp_set_agent_uptime(hsec: raw::c_ulong);
343
344 pub fn netsnmp_check_transaction_id(transaction_id: raw::c_int)
345 -> raw::c_int;
346
347 pub fn netsnmp_agent_check_packet(arg1: *mut netsnmp_session,
348 arg2: *mut Struct_netsnmp_transport_s,
349 arg3: *mut raw::c_void,
350 arg4: raw::c_int)
351 -> raw::c_int;
352
353 pub fn netsnmp_agent_check_parse(arg1: *mut netsnmp_session,
354 arg2: *mut netsnmp_pdu,
355 arg3: raw::c_int)
356 -> raw::c_int;
357
358 pub fn netsnmp_allocate_globalcacheid() -> raw::c_int;
359
360 pub fn netsnmp_remove_delegated_requests_for_session(sess:
361 *mut netsnmp_session)
362 -> raw::c_int;
363
364 pub fn netsnmp_register_agent_nsap(t: *mut Struct_netsnmp_transport_s)
365 -> raw::c_int;
366
367 pub fn netsnmp_deregister_agent_nsap(handle: raw::c_int);
368
369 pub fn netsnmp_agent_add_list_data(agent: *mut netsnmp_agent_request_info,
370 node: *mut netsnmp_data_list);
371
372 pub fn netsnmp_agent_remove_list_data(ari:
373 *mut netsnmp_agent_request_info,
374 name: *const raw::c_char)
375 -> raw::c_int;
376
377 pub fn netsnmp_agent_get_list_data(agent: *mut netsnmp_agent_request_info,
378 name: *const raw::c_char)
379 -> *mut raw::c_void;
380
381 pub fn netsnmp_free_agent_data_set(agent:
382 *mut netsnmp_agent_request_info);
383
384 pub fn netsnmp_free_agent_data_sets(agent:
385 *mut netsnmp_agent_request_info);
386
387 pub fn netsnmp_free_agent_request_info(ari:
388 *mut netsnmp_agent_request_info);
389}
390#[repr(C)]
391pub struct variable {
392 pub magic: raw::c_uchar,
393 pub type_: raw::c_char,
394 pub acl: raw::c_ushort,
395 pub findVar: FindVarMethod,
396 pub namelen: raw::c_uchar,
397 pub name: [oid; 128usize],
398}
399
400extern "C" {
401 pub fn netsnmp_duplicate_variable(var: *const variable) -> *mut variable;
402}
403pub type WriteMethod =
404 ::std::option::Option<unsafe extern "C" fn(action: raw::c_int,
405 var_val: *mut raw::c_uchar,
406 var_val_type: raw::c_uchar,
407 var_val_len: usize,
408 statP: *mut raw::c_uchar,
409 name: *mut oid, length: usize)
410 -> raw::c_int>;
411pub type FindVarMethod =
412 ::std::option::Option<unsafe extern "C" fn(vp: *mut variable,
413 name: *mut oid,
414 length: *mut usize,
415 exact: raw::c_int,
416 var_len: *mut usize,
417 write_method: *mut WriteMethod)
418 -> *mut raw::c_uchar>;
419pub type AddVarMethod =
420 ::std::option::Option<unsafe extern "C" fn(asp:
421 *mut netsnmp_agent_session,
422 vbp:
423 *mut netsnmp_variable_list)
424 -> raw::c_int>;
425#[repr(C)]
426#[derive(Debug, Copy, Clone)]
427pub struct nlist([u8; 0]);
428extern "C" {
429 #[link_name = "long_return"]
430 pub static mut long_return: raw::c_long;
431
432 #[link_name = "return_buf"]
433 pub static mut return_buf: [raw::c_uchar; 0usize];
434
435 #[link_name = "nullOid"]
436 pub static mut nullOid: [oid; 0usize];
437
438 #[link_name = "nullOidLen"]
439 pub static mut nullOidLen: raw::c_int;
440
441 pub fn init_agent(arg1: *const raw::c_char)
442 -> raw::c_int;
443
444 pub fn shutdown_agent();
445
446 pub fn should_init(module_name: *const raw::c_char)
447 -> raw::c_int;
448
449 pub fn add_to_init_list(module_list: *mut raw::c_char);
450
451 pub fn netsnmp_enable_subagent();
452}
453#[repr(C)]
454#[derive(Copy)]
455pub struct netsnmp_handler_registration_s {
456 pub handlerName: *mut raw::c_char,
457 pub contextName: *mut raw::c_char,
458 pub rootoid: *mut oid,
459 pub rootoid_len: usize,
460 pub handler: *mut netsnmp_mib_handler,
461 pub modes: raw::c_int,
462 pub priority: raw::c_int,
463 pub range_subid: raw::c_int,
464 pub range_ubound: oid,
465 pub timeout: raw::c_int,
466 pub global_cacheid: raw::c_int,
467 pub my_reg_void: *mut raw::c_void,
468}
469
470impl Clone for netsnmp_handler_registration_s {
471 fn clone(&self) -> Self { *self }
472}
473#[repr(C)]
474#[derive(Copy)]
475pub struct netsnmp_mib_handler_s {
476 pub handler_name: *mut raw::c_char,
477 pub myvoid: *mut raw::c_void,
478 pub flags: raw::c_int,
479 pub access_method: ::std::option::Option<unsafe extern "C" fn(arg1:
480 *mut netsnmp_mib_handler_s,
481 arg2:
482 *mut netsnmp_handler_registration_s,
483 arg3:
484 *mut netsnmp_agent_request_info_s,
485 arg4:
486 *mut netsnmp_request_info_s)
487 -> raw::c_int>,
488 pub data_clone: ::std::option::Option<unsafe extern "C" fn(myvoid:
489 *mut raw::c_void)
490 -> *mut raw::c_void>,
491 pub data_free: ::std::option::Option<unsafe extern "C" fn(myvoid:
492 *mut raw::c_void)>,
493 pub next: *mut netsnmp_mib_handler_s,
494 pub prev: *mut netsnmp_mib_handler_s,
495}
496
497impl Clone for netsnmp_mib_handler_s {
498 fn clone(&self) -> Self { *self }
499}
500pub type netsnmp_mib_handler = netsnmp_mib_handler_s;
501pub type netsnmp_handler_registration = netsnmp_handler_registration_s;
502pub type Netsnmp_Node_Handler =
503 ::std::option::Option<unsafe extern "C" fn(handler:
504 *mut netsnmp_mib_handler,
505 reginfo:
506 *mut netsnmp_handler_registration,
507 reqinfo:
508 *mut netsnmp_agent_request_info,
509 requests:
510 *mut netsnmp_request_info)
511 -> raw::c_int>;
512#[repr(C)]
513#[derive(Copy)]
514pub struct netsnmp_handler_args_s {
515 pub handler: *mut netsnmp_mib_handler,
516 pub reginfo: *mut netsnmp_handler_registration,
517 pub reqinfo: *mut netsnmp_agent_request_info,
518 pub requests: *mut netsnmp_request_info,
519}
520
521impl Clone for netsnmp_handler_args_s {
522 fn clone(&self) -> Self { *self }
523}
524pub type netsnmp_handler_args = netsnmp_handler_args_s;
525#[repr(C)]
526#[derive(Copy)]
527pub struct netsnmp_delegated_cache_s {
528 pub transaction_id: raw::c_int,
529 pub handler: *mut netsnmp_mib_handler,
530 pub reginfo: *mut netsnmp_handler_registration,
531 pub reqinfo: *mut netsnmp_agent_request_info,
532 pub requests: *mut netsnmp_request_info,
533 pub localinfo: *mut raw::c_void,
534}
535
536impl Clone for netsnmp_delegated_cache_s {
537 fn clone(&self) -> Self { *self }
538}
539pub type netsnmp_delegated_cache = netsnmp_delegated_cache_s;
540extern "C" {
541 pub fn netsnmp_init_handler_conf();
542
543 pub fn netsnmp_register_handler(reginfo:
544 *mut netsnmp_handler_registration)
545 -> raw::c_int;
546
547 pub fn netsnmp_unregister_handler(reginfo:
548 *mut netsnmp_handler_registration)
549 -> raw::c_int;
550
551 pub fn netsnmp_register_handler_nocallback(reginfo:
552 *mut netsnmp_handler_registration)
553 -> raw::c_int;
554
555 pub fn netsnmp_inject_handler(reginfo: *mut netsnmp_handler_registration,
556 handler: *mut netsnmp_mib_handler)
557 -> raw::c_int;
558
559 pub fn netsnmp_inject_handler_before(reginfo:
560 *mut netsnmp_handler_registration,
561 handler: *mut netsnmp_mib_handler,
562 before_what:
563 *const raw::c_char)
564 -> raw::c_int;
565
566 pub fn netsnmp_find_handler_by_name(reginfo:
567 *mut netsnmp_handler_registration,
568 name: *const raw::c_char)
569 -> *mut netsnmp_mib_handler;
570
571 pub fn netsnmp_find_handler_data_by_name(reginfo:
572 *mut netsnmp_handler_registration,
573 name:
574 *const raw::c_char)
575 -> *mut raw::c_void;
576
577 pub fn netsnmp_call_handlers(reginfo: *mut netsnmp_handler_registration,
578 reqinfo: *mut netsnmp_agent_request_info,
579 requests: *mut netsnmp_request_info)
580 -> raw::c_int;
581
582 pub fn netsnmp_call_handler(next_handler: *mut netsnmp_mib_handler,
583 reginfo: *mut netsnmp_handler_registration,
584 reqinfo: *mut netsnmp_agent_request_info,
585 requests: *mut netsnmp_request_info)
586 -> raw::c_int;
587
588 pub fn netsnmp_call_next_handler(current: *mut netsnmp_mib_handler,
589 reginfo:
590 *mut netsnmp_handler_registration,
591 reqinfo: *mut netsnmp_agent_request_info,
592 requests: *mut netsnmp_request_info)
593 -> raw::c_int;
594
595 pub fn netsnmp_call_next_handler_one_request(current:
596 *mut netsnmp_mib_handler,
597 reginfo:
598 *mut netsnmp_handler_registration,
599 reqinfo:
600 *mut netsnmp_agent_request_info,
601 requests:
602 *mut netsnmp_request_info)
603 -> raw::c_int;
604
605 pub fn netsnmp_create_handler(name: *const raw::c_char,
606 handler_access_method: Netsnmp_Node_Handler)
607 -> *mut netsnmp_mib_handler;
608
609 pub fn netsnmp_handler_registration_create(name:
610 *const raw::c_char,
611 handler:
612 *mut netsnmp_mib_handler,
613 reg_oid: *const oid,
614 reg_oid_len: usize,
615 modes: raw::c_int)
616 -> *mut netsnmp_handler_registration;
617
618 pub fn netsnmp_create_handler_registration(name:
619 *const raw::c_char,
620 handler_access_method:
621 Netsnmp_Node_Handler,
622 reg_oid: *const oid,
623 reg_oid_len: usize,
624 modes: raw::c_int)
625 -> *mut netsnmp_handler_registration;
626
627 pub fn netsnmp_create_delegated_cache(arg1: *mut netsnmp_mib_handler,
628 arg2:
629 *mut netsnmp_handler_registration,
630 arg3:
631 *mut netsnmp_agent_request_info,
632 arg4: *mut netsnmp_request_info,
633 arg5: *mut raw::c_void)
634 -> *mut netsnmp_delegated_cache;
635
636 pub fn netsnmp_free_delegated_cache(dcache: *mut netsnmp_delegated_cache);
637
638 pub fn netsnmp_handler_check_cache(dcache: *mut netsnmp_delegated_cache)
639 -> *mut netsnmp_delegated_cache;
640
641 pub fn netsnmp_register_handler_by_name(arg1:
642 *const raw::c_char,
643 arg2: *mut netsnmp_mib_handler);
644
645 pub fn netsnmp_clear_handler_list();
646
647 pub fn netsnmp_request_add_list_data(request: *mut netsnmp_request_info,
648 node: *mut netsnmp_data_list);
649
650 pub fn netsnmp_request_remove_list_data(request:
651 *mut netsnmp_request_info,
652 name:
653 *const raw::c_char)
654 -> raw::c_int;
655
656 pub fn netsnmp_request_get_list_data(request: *mut netsnmp_request_info,
657 name: *const raw::c_char)
658 -> *mut raw::c_void;
659
660 pub fn netsnmp_free_request_data_set(request: *mut netsnmp_request_info);
661
662 pub fn netsnmp_free_request_data_sets(request: *mut netsnmp_request_info);
663
664 pub fn netsnmp_handler_free(arg1: *mut netsnmp_mib_handler);
665
666 pub fn netsnmp_handler_dup(arg1: *mut netsnmp_mib_handler)
667 -> *mut netsnmp_mib_handler;
668
669 pub fn netsnmp_handler_registration_dup(arg1:
670 *mut netsnmp_handler_registration)
671 -> *mut netsnmp_handler_registration;
672
673 pub fn netsnmp_handler_registration_free(arg1:
674 *mut netsnmp_handler_registration);
675
676 pub fn netsnmp_handler_mark_requests_as_delegated(arg1:
677 *mut netsnmp_request_info,
678 arg2:
679 raw::c_int);
680
681 pub fn netsnmp_handler_get_parent_data(arg1: *mut netsnmp_request_info,
682 arg2:
683 *const raw::c_char)
684 -> *mut raw::c_void;
685}
686#[repr(C)]
687#[derive(Copy)]
688pub struct netsnmp_subtree_s {
689 pub name_a: *mut oid,
690 pub namelen: raw::c_uchar,
691 pub start_a: *mut oid,
692 pub start_len: raw::c_uchar,
693 pub end_a: *mut oid,
694 pub end_len: raw::c_uchar,
695 pub variables: *mut variable,
696 pub variables_len: raw::c_int,
697 pub variables_width: raw::c_int,
698 pub label_a: *mut raw::c_char,
699 pub session: *mut netsnmp_session,
700 pub flags: raw::c_uchar,
701 pub priority: raw::c_uchar,
702 pub timeout: raw::c_int,
703 pub next: *mut netsnmp_subtree_s,
704 pub prev: *mut netsnmp_subtree_s,
705 pub children: *mut netsnmp_subtree_s,
706 pub range_subid: raw::c_int,
707 pub range_ubound: oid,
708 pub reginfo: *mut netsnmp_handler_registration,
709 pub cacheid: raw::c_int,
710 pub global_cacheid: raw::c_int,
711 pub oid_off: usize,
712}
713
714impl Clone for netsnmp_subtree_s {
715 fn clone(&self) -> Self { *self }
716}
717pub type netsnmp_subtree = netsnmp_subtree_s;
718#[repr(C)]
719#[derive(Copy)]
720pub struct variable1 {
721 pub magic: raw::c_uchar,
722 pub type_: raw::c_uchar,
723 pub acl: raw::c_ushort,
724 pub findVar: FindVarMethod,
725 pub namelen: raw::c_uchar,
726 pub name: [oid; 1usize],
727}
728
729impl Clone for variable1 {
730 fn clone(&self) -> Self { *self }
731}
732#[repr(C)]
733#[derive(Copy)]
734pub struct variable2 {
735 pub magic: raw::c_uchar,
736 pub type_: raw::c_uchar,
737 pub acl: raw::c_ushort,
738 pub findVar: FindVarMethod,
739 pub namelen: raw::c_uchar,
740 pub name: [oid; 2usize],
741}
742
743impl Clone for variable2 {
744 fn clone(&self) -> Self { *self }
745}
746#[repr(C)]
747#[derive(Copy)]
748pub struct variable3 {
749 pub magic: raw::c_uchar,
750 pub type_: raw::c_uchar,
751 pub acl: raw::c_ushort,
752 pub findVar: FindVarMethod,
753 pub namelen: raw::c_uchar,
754 pub name: [oid; 3usize],
755}
756
757impl Clone for variable3 {
758 fn clone(&self) -> Self { *self }
759}
760#[repr(C)]
761#[derive(Copy)]
762pub struct variable4 {
763 pub magic: raw::c_uchar,
764 pub type_: raw::c_uchar,
765 pub acl: raw::c_ushort,
766 pub findVar: FindVarMethod,
767 pub namelen: raw::c_uchar,
768 pub name: [oid; 4usize],
769}
770
771impl Clone for variable4 {
772 fn clone(&self) -> Self { *self }
773}
774#[repr(C)]
775#[derive(Copy)]
776pub struct variable7 {
777 pub magic: raw::c_uchar,
778 pub type_: raw::c_uchar,
779 pub acl: raw::c_ushort,
780 pub findVar: FindVarMethod,
781 pub namelen: raw::c_uchar,
782 pub name: [oid; 7usize],
783}
784
785impl Clone for variable7 {
786 fn clone(&self) -> Self { *self }
787}
788#[repr(C)]
789#[derive(Copy)]
790pub struct variable8 {
791 pub magic: raw::c_uchar,
792 pub type_: raw::c_uchar,
793 pub acl: raw::c_ushort,
794 pub findVar: FindVarMethod,
795 pub namelen: raw::c_uchar,
796 pub name: [oid; 8usize],
797}
798
799impl Clone for variable8 {
800 fn clone(&self) -> Self { *self }
801}
802#[repr(C)]
803#[derive(Copy)]
804pub struct variable13 {
805 pub magic: raw::c_uchar,
806 pub type_: raw::c_uchar,
807 pub acl: raw::c_ushort,
808 pub findVar: FindVarMethod,
809 pub namelen: raw::c_uchar,
810 pub name: [oid; 13usize],
811}
812
813impl Clone for variable13 {
814 fn clone(&self) -> Self { *self }
815}
816extern "C" {
817 #[link_name = "external_readfd"]
818 pub static mut external_readfd: [ raw::c_int; 32usize];
819
820 #[link_name = "external_readfdlen"]
821 pub static mut external_readfdlen: raw::c_int;
822
823 #[link_name = "external_writefd"]
824 pub static mut external_writefd: [ raw::c_int; 32usize];
825
826 #[link_name = "external_writefdlen"]
827 pub static mut external_writefdlen: raw::c_int;
828
829 #[link_name = "external_exceptfd"]
830 pub static mut external_exceptfd: [ raw::c_int; 32usize];
831
832 #[link_name = "external_exceptfdlen"]
833 pub static mut external_exceptfdlen: raw::c_int;
834
835 #[link_name = "external_readfdfunc"]
836 pub static mut external_readfdfunc:
837 [::std::option::Option<unsafe extern "C" fn(arg1:
838 raw::c_int,
839 arg2:
840 *mut raw::c_void)>; 32usize];
841
842 #[link_name = "external_writefdfunc"]
843 pub static mut external_writefdfunc:
844 [::std::option::Option<unsafe extern "C" fn(arg1:
845 raw::c_int,
846 arg2:
847 *mut raw::c_void)>; 32usize];
848
849 #[link_name = "external_exceptfdfunc"]
850 pub static mut external_exceptfdfunc:
851 [::std::option::Option<unsafe extern "C" fn(arg1:
852 raw::c_int,
853 arg2:
854 *mut raw::c_void)>; 32usize];
855
856 #[link_name = "external_readfd_data"]
857 pub static mut external_readfd_data:
858 [*mut raw::c_void; 32usize];
859
860 #[link_name = "external_writefd_data"]
861 pub static mut external_writefd_data:
862 [*mut raw::c_void; 32usize];
863
864 #[link_name = "external_exceptfd_data"]
865 pub static mut external_exceptfd_data:
866 [*mut raw::c_void; 32usize];
867
868 pub fn register_readfd(arg1: raw::c_int,
869 func:
870 ::std::option::Option<unsafe extern "C" fn(arg1:
871 raw::c_int,
872 arg2:
873 *mut raw::c_void)>,
874 arg2: *mut raw::c_void)
875 -> raw::c_int;
876
877 pub fn register_writefd(arg1: raw::c_int,
878 func:
879 ::std::option::Option<unsafe extern "C" fn(arg1:
880 raw::c_int,
881 arg2:
882 *mut raw::c_void)>,
883 arg2: *mut raw::c_void)
884 -> raw::c_int;
885
886 pub fn register_exceptfd(arg1: raw::c_int,
887 func:
888 ::std::option::Option<unsafe extern "C" fn(arg1:
889 raw::c_int,
890 arg2:
891 *mut raw::c_void)>,
892 arg2: *mut raw::c_void)
893 -> raw::c_int;
894
895 pub fn unregister_readfd(arg1: raw::c_int)
896 -> raw::c_int;
897
898 pub fn unregister_writefd(arg1: raw::c_int)
899 -> raw::c_int;
900
901 pub fn unregister_exceptfd(arg1: raw::c_int)
902 -> raw::c_int;
903
904 pub fn netsnmp_external_event_info(numfds: *mut raw::c_int,
905 readfds: *mut libc::fd_set,
906 writefds: *mut libc::fd_set,
907 exceptfds: *mut libc::fd_set);
908
909 pub fn netsnmp_external_event_info2(numfds: *mut raw::c_int,
910 readfds: *mut netsnmp_large_fd_set,
911 writefds: *mut netsnmp_large_fd_set,
912 exceptfds: *mut netsnmp_large_fd_set);
913
914 pub fn netsnmp_dispatch_external_events(count: *mut raw::c_int,
915 readfds: *mut libc::fd_set,
916 writefds: *mut libc::fd_set,
917 exceptfds: *mut libc::fd_set);
918
919 pub fn netsnmp_dispatch_external_events2(count:
920 *mut raw::c_int,
921 readfds:
922 *mut netsnmp_large_fd_set,
923 writefds:
924 *mut netsnmp_large_fd_set,
925 exceptfds:
926 *mut netsnmp_large_fd_set);
927}
928#[repr(C)]
929#[derive(Copy)]
930pub struct view_parameters {
931 pub pdu: *mut netsnmp_pdu,
932 pub name: *mut oid,
933 pub namelen: usize,
934 pub test: raw::c_int,
935 pub errorcode: raw::c_int,
936 pub check_subtree: raw::c_int,
937}
938
939impl Clone for view_parameters {
940 fn clone(&self) -> Self { *self }
941}
942#[repr(C)]
943#[derive(Copy)]
944pub struct register_parameters {
945 pub name: *mut oid,
946 pub namelen: usize,
947 pub priority: raw::c_int,
948 pub range_subid: raw::c_int,
949 pub range_ubound: oid,
950 pub timeout: raw::c_int,
951 pub flags: raw::c_uchar,
952 pub contextName: *const raw::c_char,
953 pub session: *mut netsnmp_session,
954 pub reginfo: *mut netsnmp_handler_registration,
955}
956
957impl Clone for register_parameters {
958 fn clone(&self) -> Self { *self }
959}
960#[repr(C)]
961#[derive(Copy)]
962pub struct subtree_context_cache_s {
963 pub context_name: *const raw::c_char,
964 pub first_subtree: *mut netsnmp_subtree_s,
965 pub next: *mut subtree_context_cache_s,
966}
967
968impl Clone for subtree_context_cache_s {
969 fn clone(&self) -> Self { *self }
970}
971pub type subtree_context_cache = subtree_context_cache_s;
972extern "C" {
973 pub fn setup_tree();
974
975 pub fn shutdown_tree();
976
977 pub fn netsnmp_subtree_find(arg1: *const oid, arg2: usize,
978 arg3: *mut netsnmp_subtree,
979 context_name: *const raw::c_char)
980 -> *mut netsnmp_subtree;
981
982 pub fn netsnmp_subtree_find_next(arg1: *const oid, arg2: usize,
983 arg3: *mut netsnmp_subtree,
984 context_name:
985 *const raw::c_char)
986 -> *mut netsnmp_subtree;
987
988 pub fn netsnmp_subtree_find_prev(arg1: *const oid, arg2: usize,
989 arg3: *mut netsnmp_subtree,
990 context_name:
991 *const raw::c_char)
992 -> *mut netsnmp_subtree;
993
994 pub fn netsnmp_subtree_find_first(context_name:
995 *const raw::c_char)
996 -> *mut netsnmp_subtree;
997
998 pub fn get_session_for_oid(arg1: *const oid, arg2: usize,
999 context_name: *const raw::c_char)
1000 -> *mut netsnmp_session;
1001
1002 pub fn get_top_context_cache() -> *mut subtree_context_cache;
1003
1004 pub fn netsnmp_set_lookup_cache_size(newsize: raw::c_int);
1005
1006 pub fn netsnmp_get_lookup_cache_size() -> raw::c_int;
1007
1008 pub fn register_mib(arg1: *const raw::c_char,
1009 arg2: *const variable, arg3: usize, arg4: usize,
1010 arg5: *const oid, arg6: usize)
1011 -> raw::c_int;
1012
1013 pub fn register_mib_priority(arg1: *const raw::c_char,
1014 arg2: *const variable, arg3: usize,
1015 arg4: usize, arg5: *const oid, arg6: usize,
1016 arg7: raw::c_int)
1017 -> raw::c_int;
1018
1019 pub fn register_mib_range(arg1: *const raw::c_char,
1020 arg2: *const variable, arg3: usize, arg4: usize,
1021 arg5: *const oid, arg6: usize,
1022 arg7: raw::c_int,
1023 arg8: raw::c_int, arg9: oid,
1024 arg10: *mut netsnmp_session)
1025 -> raw::c_int;
1026
1027 pub fn register_mib_context(arg1: *const raw::c_char,
1028 arg2: *const variable, arg3: usize,
1029 arg4: usize, arg5: *const oid, arg6: usize,
1030 arg7: raw::c_int,
1031 arg8: raw::c_int, arg9: oid,
1032 arg10: *mut netsnmp_session,
1033 arg11: *const raw::c_char,
1034 arg12: raw::c_int,
1035 arg13: raw::c_int)
1036 -> raw::c_int;
1037
1038 pub fn netsnmp_register_mib_table_row(arg1: *const raw::c_char,
1039 arg2: *const variable, arg3: usize,
1040 arg4: usize, arg5: *mut oid,
1041 arg6: usize,
1042 arg7: raw::c_int,
1043 arg8: raw::c_int,
1044 arg9: *mut netsnmp_session,
1045 arg10:
1046 *const raw::c_char,
1047 arg11: raw::c_int,
1048 arg12: raw::c_int)
1049 -> raw::c_int;
1050
1051 pub fn unregister_mib(arg1: *mut oid, arg2: usize)
1052 -> raw::c_int;
1053
1054 pub fn unregister_mib_priority(arg1: *mut oid, arg2: usize,
1055 arg3: raw::c_int)
1056 -> raw::c_int;
1057
1058 pub fn unregister_mib_range(arg1: *mut oid, arg2: usize,
1059 arg3: raw::c_int,
1060 arg4: raw::c_int, arg5: oid)
1061 -> raw::c_int;
1062
1063 pub fn unregister_mib_context(arg1: *mut oid, arg2: usize,
1064 arg3: raw::c_int,
1065 arg4: raw::c_int, arg5: oid,
1066 arg6: *const raw::c_char)
1067 -> raw::c_int;
1068
1069 pub fn clear_context();
1070
1071 pub fn unregister_mibs_by_session(arg1: *mut netsnmp_session);
1072
1073 pub fn netsnmp_unregister_mib_table_row(mibloc: *mut oid,
1074 mibloclen: usize,
1075 priority: raw::c_int,
1076 var_subid: raw::c_int,
1077 range_ubound: oid,
1078 context:
1079 *const raw::c_char)
1080 -> raw::c_int;
1081
1082 pub fn compare_tree(arg1: *const oid, arg2: usize, arg3: *const oid,
1083 arg4: usize) -> raw::c_int;
1084
1085 pub fn in_a_view(arg1: *mut oid, arg2: *mut usize, arg3: *mut netsnmp_pdu,
1086 arg4: raw::c_int) -> raw::c_int;
1087
1088 pub fn check_access(pdu: *mut netsnmp_pdu) -> raw::c_int;
1089
1090 pub fn netsnmp_acm_check_subtree(arg1: *mut netsnmp_pdu, arg2: *mut oid,
1091 arg3: usize) -> raw::c_int;
1092
1093 pub fn register_mib_reattach();
1094
1095 pub fn register_mib_detach();
1096
1097 #[link_name = "external_signal_scheduled"]
1098 pub static mut external_signal_scheduled:
1099 [ raw::c_int; 32usize];
1100
1101 #[link_name = "external_signal_handler"]
1102 pub static mut external_signal_handler:
1103 [::std::option::Option<unsafe extern "C" fn(arg1:
1104 raw::c_int)>; 32usize];
1105
1106 pub fn register_signal(arg1: raw::c_int,
1107 func:
1108 ::std::option::Option<unsafe extern "C" fn(arg1:
1109 raw::c_int)>)
1110 -> raw::c_int;
1111
1112 pub fn unregister_signal(arg1: raw::c_int)
1113 -> raw::c_int;
1114
1115 pub fn netsnmp_register_mib(arg1: *const raw::c_char,
1116 arg2: *mut variable, arg3: usize, arg4: usize,
1117 arg5: *mut oid, arg6: usize,
1118 arg7: raw::c_int,
1119 arg8: raw::c_int, arg9: oid,
1120 arg10: *mut netsnmp_session,
1121 arg11: *const raw::c_char,
1122 arg12: raw::c_int,
1123 arg13: raw::c_int,
1124 arg14: *mut netsnmp_handler_registration_s,
1125 arg15: raw::c_int)
1126 -> raw::c_int;
1127
1128 pub fn init_agent_read_config(arg1: *const raw::c_char);
1129
1130 pub fn update_config();
1131
1132 pub fn snmpd_register_config_handler(token: *const raw::c_char,
1133 parser:
1134 ::std::option::Option<unsafe extern "C" fn(arg1:
1135 *const raw::c_char,
1136 arg2:
1137 *mut raw::c_char)>,
1138 releaser:
1139 ::std::option::Option<unsafe extern "C" fn()>,
1140 help: *const raw::c_char);
1141
1142 pub fn snmpd_register_const_config_handler(arg1:
1143 *const raw::c_char,
1144 parser:
1145 ::std::option::Option<unsafe extern "C" fn(arg1:
1146 *const raw::c_char,
1147 arg2:
1148 *const raw::c_char)>,
1149 releaser:
1150 ::std::option::Option<unsafe extern "C" fn()>,
1151 arg2:
1152 *const raw::c_char);
1153
1154 pub fn snmpd_unregister_config_handler(arg1:
1155 *const raw::c_char);
1156
1157 pub fn snmpd_store_config(arg1: *const raw::c_char);
1158}
1159#[repr(C)]
1160#[derive(Copy)]
1161pub struct agent_add_trap_args {
1162 pub ss: *mut netsnmp_session,
1163 pub confirm: raw::c_int,
1164}
1165
1166impl Clone for agent_add_trap_args {
1167 fn clone(&self) -> Self { *self }
1168}
1169extern "C" {
1170 pub fn init_traps();
1171
1172 pub fn send_easy_trap(arg1: raw::c_int,
1173 arg2: raw::c_int);
1174
1175 pub fn send_trap_pdu(arg1: *mut netsnmp_pdu);
1176
1177 pub fn send_v2trap(arg1: *mut netsnmp_variable_list);
1178
1179 pub fn send_v3trap(vars: *mut netsnmp_variable_list,
1180 context: *const raw::c_char);
1181
1182 pub fn send_trap_vars(arg1: raw::c_int,
1183 arg2: raw::c_int,
1184 arg3: *mut netsnmp_variable_list);
1185
1186 pub fn send_trap_vars_with_context(trap: raw::c_int,
1187 specific: raw::c_int,
1188 vars: *mut netsnmp_variable_list,
1189 context:
1190 *const raw::c_char);
1191
1192 pub fn send_enterprise_trap_vars(trap: raw::c_int,
1193 specific: raw::c_int,
1194 enterprise: *const oid,
1195 enterprise_length: raw::c_int,
1196 vars: *mut netsnmp_variable_list);
1197
1198 pub fn netsnmp_send_traps(trap: raw::c_int,
1199 specific: raw::c_int,
1200 enterprise: *const oid,
1201 enterprise_length: raw::c_int,
1202 vars: *mut netsnmp_variable_list,
1203 context: *const raw::c_char,
1204 flags: raw::c_int)
1205 -> raw::c_int;
1206
1207 pub fn snmpd_parse_config_authtrap(arg1: *const raw::c_char,
1208 arg2: *mut raw::c_char);
1209
1210 pub fn snmpd_parse_config_trapsink(arg1: *const raw::c_char,
1211 arg2: *mut raw::c_char);
1212
1213 pub fn snmpd_parse_config_trap2sink(arg1: *const raw::c_char,
1214 arg2: *mut raw::c_char);
1215
1216 pub fn snmpd_parse_config_informsink(arg1: *const raw::c_char,
1217 arg2: *mut raw::c_char);
1218
1219 pub fn snmpd_parse_config_trapsess(arg1: *const raw::c_char,
1220 arg2: *mut raw::c_char);
1221
1222 pub fn snmpd_free_trapsinks();
1223
1224 pub fn snmpd_parse_config_trapcommunity(arg1:
1225 *const raw::c_char,
1226 arg2:
1227 *mut raw::c_char);
1228
1229 pub fn snmpd_free_trapcommunity();
1230
1231 pub fn send_trap_to_sess(sess: *mut netsnmp_session,
1232 template_pdu: *mut netsnmp_pdu);
1233
1234 pub fn create_trap_session(arg1: *mut raw::c_char,
1235 arg2: raw::c_ushort,
1236 arg3: *mut raw::c_char,
1237 arg4: raw::c_int,
1238 arg5: raw::c_int)
1239 -> raw::c_int;
1240
1241 pub fn add_trap_session(arg1: *mut netsnmp_session,
1242 arg2: raw::c_int,
1243 arg3: raw::c_int,
1244 arg4: raw::c_int)
1245 -> raw::c_int;
1246
1247 pub fn remove_trap_session(arg1: *mut netsnmp_session)
1248 -> raw::c_int;
1249
1250 pub fn convert_v2_to_v1(arg1: *mut netsnmp_variable_list,
1251 arg2: *mut netsnmp_pdu);
1252
1253 pub fn convert_v1_to_v2(arg1: *mut netsnmp_pdu)
1254 -> *mut netsnmp_variable_list;
1255
1256 pub fn convert_v2pdu_to_v1(arg1: *mut netsnmp_pdu) -> *mut netsnmp_pdu;
1257
1258 pub fn convert_v1pdu_to_v2(arg1: *mut netsnmp_pdu) -> *mut netsnmp_pdu;
1259
1260 pub fn netsnmp_register_instance(reginfo:
1261 *mut netsnmp_handler_registration)
1262 -> raw::c_int;
1263
1264 pub fn netsnmp_register_read_only_instance(reginfo:
1265 *mut netsnmp_handler_registration)
1266 -> raw::c_int;
1267
1268 pub fn netsnmp_get_instance_handler() -> *mut netsnmp_mib_handler;
1269
1270 pub fn netsnmp_register_read_only_ulong_instance(name:
1271 *const raw::c_char,
1272 reg_oid: *const oid,
1273 reg_oid_len: usize,
1274 it: *mut raw::c_ulong,
1275 subhandler:
1276 Netsnmp_Node_Handler)
1277 -> raw::c_int;
1278
1279 pub fn netsnmp_register_ulong_instance(name:
1280 *const raw::c_char,
1281 reg_oid: *const oid,
1282 reg_oid_len: usize,
1283 it: *mut raw::c_ulong,
1284 subhandler: Netsnmp_Node_Handler)
1285 -> raw::c_int;
1286
1287 pub fn netsnmp_register_read_only_counter32_instance(name:
1288 *const raw::c_char,
1289 reg_oid: *const oid,
1290 reg_oid_len: usize,
1291 it: *mut raw::c_ulong,
1292 subhandler:
1293 Netsnmp_Node_Handler)
1294 -> raw::c_int;
1295
1296 pub fn netsnmp_register_read_only_long_instance(name:
1297 *const raw::c_char,
1298 reg_oid: *const oid,
1299 reg_oid_len: usize,
1300 it:
1301 *mut raw::c_long,
1302 subhandler:
1303 Netsnmp_Node_Handler)
1304 -> raw::c_int;
1305
1306 pub fn netsnmp_register_long_instance(name: *const raw::c_char,
1307 reg_oid: *const oid,
1308 reg_oid_len: usize,
1309 it: *mut raw::c_long,
1310 subhandler: Netsnmp_Node_Handler)
1311 -> raw::c_int;
1312
1313 pub fn netsnmp_register_read_only_int_instance(name:
1314 *const raw::c_char,
1315 reg_oid: *const oid,
1316 reg_oid_len: usize,
1317 it:
1318 *mut raw::c_int,
1319 subhandler:
1320 Netsnmp_Node_Handler)
1321 -> raw::c_int;
1322
1323 pub fn netsnmp_register_int_instance(name: *const raw::c_char,
1324 reg_oid: *const oid,
1325 reg_oid_len: usize,
1326 it: *mut raw::c_int,
1327 subhandler: Netsnmp_Node_Handler)
1328 -> raw::c_int;
1329
1330 pub fn netsnmp_register_read_only_ulong_instance_context(name:
1331 *const raw::c_char,
1332 reg_oid:
1333 *const oid,
1334 reg_oid_len:
1335 usize,
1336 it: *mut raw::c_ulong,
1337 subhandler:
1338 Netsnmp_Node_Handler,
1339 contextName:
1340 *const raw::c_char)
1341 -> raw::c_int;
1342
1343 pub fn netsnmp_register_ulong_instance_context(name:
1344 *const raw::c_char,
1345 reg_oid: *const oid,
1346 reg_oid_len: usize,
1347 it: *mut raw::c_ulong,
1348 subhandler:
1349 Netsnmp_Node_Handler,
1350 contextName:
1351 *const raw::c_char)
1352 -> raw::c_int;
1353
1354 pub fn netsnmp_register_read_only_counter32_instance_context(name:
1355 *const raw::c_char,
1356 reg_oid:
1357 *const oid,
1358 reg_oid_len:
1359 usize,
1360 it:
1361 *mut raw::c_ulong,
1362 subhandler:
1363 Netsnmp_Node_Handler,
1364 contextName:
1365 *const raw::c_char)
1366 -> raw::c_int;
1367
1368 pub fn netsnmp_register_read_only_long_instance_context(name:
1369 *const raw::c_char,
1370 reg_oid:
1371 *const oid,
1372 reg_oid_len:
1373 usize,
1374 it:
1375 *mut raw::c_long,
1376 subhandler:
1377 Netsnmp_Node_Handler,
1378 contextName:
1379 *const raw::c_char)
1380 -> raw::c_int;
1381
1382 pub fn netsnmp_register_long_instance_context(name:
1383 *const raw::c_char,
1384 reg_oid: *const oid,
1385 reg_oid_len: usize,
1386 it:
1387 *mut raw::c_long,
1388 subhandler:
1389 Netsnmp_Node_Handler,
1390 contextName:
1391 *const raw::c_char)
1392 -> raw::c_int;
1393
1394 pub fn netsnmp_register_read_only_int_instance_context(name:
1395 *const raw::c_char,
1396 reg_oid:
1397 *const oid,
1398 reg_oid_len: usize,
1399 it:
1400 *mut raw::c_int,
1401 subhandler:
1402 Netsnmp_Node_Handler,
1403 contextName:
1404 *const raw::c_char)
1405 -> raw::c_int;
1406
1407 pub fn netsnmp_register_int_instance_context(name:
1408 *const raw::c_char,
1409 reg_oid: *const oid,
1410 reg_oid_len: usize,
1411 it:
1412 *mut raw::c_int,
1413 subhandler:
1414 Netsnmp_Node_Handler,
1415 contextName:
1416 *const raw::c_char)
1417 -> raw::c_int;
1418
1419 pub fn netsnmp_register_num_file_instance(name:
1420 *const raw::c_char,
1421 reg_oid: *const oid,
1422 reg_oid_len: usize,
1423 file_name:
1424 *const raw::c_char,
1425 asn_type: raw::c_int,
1426 mode: raw::c_int,
1427 subhandler:
1428 Netsnmp_Node_Handler,
1429 contextName:
1430 *const raw::c_char)
1431 -> raw::c_int;
1432
1433 pub fn netsnmp_instance_helper_handler(handler: *mut netsnmp_mib_handler,
1434 reginfo:
1435 *mut netsnmp_handler_registration,
1436 reqinfo:
1437 *mut netsnmp_agent_request_info,
1438 requests:
1439 *mut netsnmp_request_info)
1440 -> raw::c_int;
1441
1442 pub fn netsnmp_instance_num_file_handler(handler:
1443 *mut netsnmp_mib_handler,
1444 reginfo:
1445 *mut netsnmp_handler_registration,
1446 reqinfo:
1447 *mut netsnmp_agent_request_info,
1448 requests:
1449 *mut netsnmp_request_info)
1450 -> raw::c_int;
1451}
1452#[repr(C)]
1453#[derive(Copy)]
1454pub struct netsnmp_baby_steps_modes_s {
1455 pub refcnt: raw::c_int,
1456 pub registered: raw::c_uint,
1457 pub completed: raw::c_uint,
1458}
1459
1460impl Clone for netsnmp_baby_steps_modes_s {
1461 fn clone(&self) -> Self { *self }
1462}
1463pub type netsnmp_baby_steps_modes = netsnmp_baby_steps_modes_s;
1464extern "C" {
1465 pub fn netsnmp_baby_steps_init();
1466
1467 pub fn netsnmp_baby_steps_handler_get(modes: raw::c_ulong)
1468 -> *mut netsnmp_mib_handler;
1469}
1470#[repr(C)]
1471#[derive(Copy)]
1472pub struct netsnmp_baby_steps_access_methods_s {
1473 pub pre_request: Netsnmp_Node_Handler,
1474 pub object_lookup: Netsnmp_Node_Handler,
1475 pub get_values: Netsnmp_Node_Handler,
1476 pub object_syntax_checks: Netsnmp_Node_Handler,
1477 pub row_creation: Netsnmp_Node_Handler,
1478 pub undo_setup: Netsnmp_Node_Handler,
1479 pub set_values: Netsnmp_Node_Handler,
1480 pub consistency_checks: Netsnmp_Node_Handler,
1481 pub commit: Netsnmp_Node_Handler,
1482 pub undo_sets: Netsnmp_Node_Handler,
1483 pub undo_cleanup: Netsnmp_Node_Handler,
1484 pub undo_commit: Netsnmp_Node_Handler,
1485 pub irreversible_commit: Netsnmp_Node_Handler,
1486 pub post_request: Netsnmp_Node_Handler,
1487 pub my_access_void: *mut raw::c_void,
1488}
1489
1490impl Clone for netsnmp_baby_steps_access_methods_s {
1491 fn clone(&self) -> Self { *self }
1492}
1493pub type netsnmp_baby_steps_access_methods =
1494 netsnmp_baby_steps_access_methods_s;
1495extern "C" {
1496 pub fn netsnmp_baby_steps_access_multiplexer_get(arg1:
1497 *mut netsnmp_baby_steps_access_methods)
1498 -> *mut netsnmp_mib_handler;
1499
1500 pub fn netsnmp_baby_step_mode2flag(mode: raw::c_uint) -> raw::c_int;
1501
1502 pub fn netsnmp_register_scalar(reginfo: *mut netsnmp_handler_registration)
1503 -> raw::c_int;
1504
1505 pub fn netsnmp_register_read_only_scalar(reginfo:
1506 *mut netsnmp_handler_registration)
1507 -> raw::c_int;
1508
1509 pub fn netsnmp_get_scalar_handler() -> *mut netsnmp_mib_handler;
1510
1511 pub fn netsnmp_scalar_helper_handler(handler: *mut netsnmp_mib_handler,
1512 reginfo:
1513 *mut netsnmp_handler_registration,
1514 reqinfo:
1515 *mut netsnmp_agent_request_info,
1516 requests: *mut netsnmp_request_info)
1517 -> raw::c_int;
1518}
1519#[repr(C)]
1520#[derive(Copy)]
1521pub struct netsnmp_scalar_group_s {
1522 pub lbound: oid,
1523 pub ubound: oid,
1524}
1525
1526impl Clone for netsnmp_scalar_group_s {
1527 fn clone(&self) -> Self { *self }
1528}
1529pub type netsnmp_scalar_group = netsnmp_scalar_group_s;
1530extern "C" {
1531 pub fn netsnmp_register_scalar_group(reginfo:
1532 *mut netsnmp_handler_registration,
1533 first: oid, last: oid)
1534 -> raw::c_int;
1535
1536 pub fn netsnmp_get_scalar_group_handler(first: oid, last: oid)
1537 -> *mut netsnmp_mib_handler;
1538
1539 pub fn netsnmp_scalar_group_helper_handler(handler:
1540 *mut netsnmp_mib_handler,
1541 reginfo:
1542 *mut netsnmp_handler_registration,
1543 reqinfo:
1544 *mut netsnmp_agent_request_info,
1545 requests:
1546 *mut netsnmp_request_info)
1547 -> raw::c_int;
1548}
1549#[repr(C)]
1550#[derive(Copy)]
1551pub struct netsnmp_watcher_info_s {
1552 pub data: *mut raw::c_void,
1553 pub data_size: usize,
1554 pub max_size: usize,
1555 pub type_: raw::c_uchar,
1556 pub flags: raw::c_int,
1557 pub data_size_p: *mut usize,
1558}
1559
1560impl Clone for netsnmp_watcher_info_s {
1561 fn clone(&self) -> Self { *self }
1562}
1563pub type netsnmp_watcher_info = netsnmp_watcher_info_s;
1564extern "C" {
1565 pub fn netsnmp_register_watched_instance(reginfo:
1566 *mut netsnmp_handler_registration,
1567 winfo: *mut netsnmp_watcher_info)
1568 -> raw::c_int;
1569
1570 pub fn netsnmp_register_watched_instance2(reginfo:
1571 *mut netsnmp_handler_registration,
1572 winfo:
1573 *mut netsnmp_watcher_info)
1574 -> raw::c_int;
1575
1576 pub fn netsnmp_register_watched_scalar(reginfo:
1577 *mut netsnmp_handler_registration,
1578 winfo: *mut netsnmp_watcher_info)
1579 -> raw::c_int;
1580
1581 pub fn netsnmp_register_watched_scalar2(reginfo:
1582 *mut netsnmp_handler_registration,
1583 winfo: *mut netsnmp_watcher_info)
1584 -> raw::c_int;
1585
1586 pub fn netsnmp_register_watched_timestamp(reginfo:
1587 *mut netsnmp_handler_registration,
1588 timestamp: marker_t)
1589 -> raw::c_int;
1590
1591 pub fn netsnmp_watched_timestamp_register(whandler:
1592 *mut netsnmp_mib_handler,
1593 reginfo:
1594 *mut netsnmp_handler_registration,
1595 timestamp: marker_t)
1596 -> raw::c_int;
1597
1598 pub fn netsnmp_register_watched_spinlock(reginfo:
1599 *mut netsnmp_handler_registration,
1600 spinlock:
1601 *mut raw::c_int)
1602 -> raw::c_int;
1603
1604 pub fn netsnmp_register_ulong_scalar(name: *const raw::c_char,
1605 reg_oid: *const oid,
1606 reg_oid_len: usize, it: *mut raw::c_ulong,
1607 subhandler: Netsnmp_Node_Handler)
1608 -> raw::c_int;
1609
1610 pub fn netsnmp_register_read_only_ulong_scalar(name:
1611 *const raw::c_char,
1612 reg_oid: *const oid,
1613 reg_oid_len: usize,
1614 it: *mut raw::c_ulong,
1615 subhandler:
1616 Netsnmp_Node_Handler)
1617 -> raw::c_int;
1618
1619 pub fn netsnmp_register_long_scalar(name: *const raw::c_char,
1620 reg_oid: *const oid,
1621 reg_oid_len: usize,
1622 it: *mut raw::c_long,
1623 subhandler: Netsnmp_Node_Handler)
1624 -> raw::c_int;
1625
1626 pub fn netsnmp_register_read_only_long_scalar(name:
1627 *const raw::c_char,
1628 reg_oid: *const oid,
1629 reg_oid_len: usize,
1630 it:
1631 *mut raw::c_long,
1632 subhandler:
1633 Netsnmp_Node_Handler)
1634 -> raw::c_int;
1635
1636 pub fn netsnmp_register_int_scalar(name: *const raw::c_char,
1637 reg_oid: *const oid,
1638 reg_oid_len: usize,
1639 it: *mut raw::c_int,
1640 subhandler: Netsnmp_Node_Handler)
1641 -> raw::c_int;
1642
1643 pub fn netsnmp_register_read_only_int_scalar(name:
1644 *const raw::c_char,
1645 reg_oid: *const oid,
1646 reg_oid_len: usize,
1647 it:
1648 *mut raw::c_int,
1649 subhandler:
1650 Netsnmp_Node_Handler)
1651 -> raw::c_int;
1652
1653 pub fn netsnmp_register_read_only_counter32_scalar(name:
1654 *const raw::c_char,
1655 reg_oid: *const oid,
1656 reg_oid_len: usize,
1657 it: *mut raw::c_ulong,
1658 subhandler:
1659 Netsnmp_Node_Handler)
1660 -> raw::c_int;
1661
1662 pub fn netsnmp_get_watcher_handler() -> *mut netsnmp_mib_handler;
1663
1664 pub fn netsnmp_init_watcher_info(arg1: *mut netsnmp_watcher_info,
1665 arg2: *mut raw::c_void,
1666 arg3: usize, arg4: raw::c_uchar,
1667 arg5: raw::c_int)
1668 -> *mut netsnmp_watcher_info;
1669
1670 pub fn netsnmp_init_watcher_info6(arg1: *mut netsnmp_watcher_info,
1671 arg2: *mut raw::c_void,
1672 arg3: usize, arg4: raw::c_uchar,
1673 arg5: raw::c_int,
1674 arg6: usize, arg7: *mut usize)
1675 -> *mut netsnmp_watcher_info;
1676
1677 pub fn netsnmp_create_watcher_info(arg1: *mut raw::c_void,
1678 arg2: usize, arg3: raw::c_uchar,
1679 arg4: raw::c_int)
1680 -> *mut netsnmp_watcher_info;
1681
1682 pub fn netsnmp_create_watcher_info6(arg1: *mut raw::c_void,
1683 arg2: usize, arg3: raw::c_uchar,
1684 arg4: raw::c_int,
1685 arg5: usize, arg6: *mut usize)
1686 -> *mut netsnmp_watcher_info;
1687
1688 pub fn netsnmp_clone_watcher_info(winfo: *mut netsnmp_watcher_info)
1689 -> *mut netsnmp_watcher_info;
1690
1691 pub fn netsnmp_owns_watcher_info(handler: *mut netsnmp_mib_handler);
1692
1693 pub fn netsnmp_watcher_helper_handler(handler: *mut netsnmp_mib_handler,
1694 reginfo:
1695 *mut netsnmp_handler_registration,
1696 reqinfo:
1697 *mut netsnmp_agent_request_info,
1698 requests: *mut netsnmp_request_info)
1699 -> raw::c_int;
1700
1701 pub fn netsnmp_get_watched_timestamp_handler()
1702 -> *mut netsnmp_mib_handler;
1703
1704 pub fn netsnmp_watched_timestamp_handler(handler:
1705 *mut netsnmp_mib_handler,
1706 reginfo:
1707 *mut netsnmp_handler_registration,
1708 reqinfo:
1709 *mut netsnmp_agent_request_info,
1710 requests:
1711 *mut netsnmp_request_info)
1712 -> raw::c_int;
1713
1714 pub fn netsnmp_get_watched_spinlock_handler() -> *mut netsnmp_mib_handler;
1715
1716 pub fn netsnmp_watched_spinlock_handler(handler: *mut netsnmp_mib_handler,
1717 reginfo:
1718 *mut netsnmp_handler_registration,
1719 reqinfo:
1720 *mut netsnmp_agent_request_info,
1721 requests:
1722 *mut netsnmp_request_info)
1723 -> raw::c_int;
1724}
1725#[repr(C)]
1726#[derive(Copy)]
1727pub struct netsnmp_mib_handler_methods_s {
1728 pub get_handler: *mut netsnmp_mib_handler,
1729 pub getnext_handler: *mut netsnmp_mib_handler,
1730 pub getbulk_handler: *mut netsnmp_mib_handler,
1731 pub set_handler: *mut netsnmp_mib_handler,
1732}
1733
1734impl Clone for netsnmp_mib_handler_methods_s {
1735 fn clone(&self) -> Self { *self }
1736}
1737pub type netsnmp_mib_handler_methods = netsnmp_mib_handler_methods_s;
1738extern "C" {
1739 pub fn netsnmp_get_multiplexer_handler(arg1:
1740 *mut netsnmp_mib_handler_methods)
1741 -> *mut netsnmp_mib_handler;
1742
1743 pub fn netsnmp_multiplexer_helper_handler(handler:
1744 *mut netsnmp_mib_handler,
1745 reginfo:
1746 *mut netsnmp_handler_registration,
1747 reqinfo:
1748 *mut netsnmp_agent_request_info,
1749 requests:
1750 *mut netsnmp_request_info)
1751 -> raw::c_int;
1752
1753 pub fn netsnmp_register_null(arg1: *mut oid, arg2: usize)
1754 -> raw::c_int;
1755
1756 pub fn netsnmp_register_null_context(arg1: *mut oid, arg2: usize,
1757 contextName:
1758 *const raw::c_char)
1759 -> raw::c_int;
1760
1761 pub fn netsnmp_null_handler(handler: *mut netsnmp_mib_handler,
1762 reginfo: *mut netsnmp_handler_registration,
1763 reqinfo: *mut netsnmp_agent_request_info,
1764 requests: *mut netsnmp_request_info)
1765 -> raw::c_int;
1766
1767 pub fn netsnmp_get_debug_handler() -> *mut netsnmp_mib_handler;
1768
1769 pub fn netsnmp_init_debug_helper();
1770
1771 pub fn netsnmp_debug_helper(handler: *mut netsnmp_mib_handler,
1772 reginfo: *mut netsnmp_handler_registration,
1773 reqinfo: *mut netsnmp_agent_request_info,
1774 requests: *mut netsnmp_request_info)
1775 -> raw::c_int;
1776}
1777#[repr(C)]
1778#[derive(Copy)]
1779pub struct netsnmp_cache_s {
1780 pub refcnt: raw::c_int,
1781 pub flags: raw::c_int,
1782 pub enabled: raw::c_int,
1783 pub valid: raw::c_int,
1784 pub expired: raw::c_char,
1785 pub timeout: raw::c_int,
1786 pub timestampM: marker_t,
1787 pub timer_id: raw::c_ulong,
1788 pub load_cache: NetsnmpCacheLoad,
1789 pub free_cache: NetsnmpCacheFree,
1790 pub magic: *mut raw::c_void,
1791 pub cache_hint: *mut netsnmp_handler_args,
1792 pub next: *mut netsnmp_cache,
1793 pub prev: *mut netsnmp_cache,
1794 pub rootoid: *mut oid,
1795 pub rootoid_len: raw::c_int,
1796}
1797
1798impl Clone for netsnmp_cache_s {
1799 fn clone(&self) -> Self { *self }
1800}
1801pub type netsnmp_cache = netsnmp_cache_s;
1802pub type NetsnmpCacheLoad =
1803 ::std::option::Option<unsafe extern "C" fn(arg1: *mut netsnmp_cache,
1804 arg2:
1805 *mut raw::c_void)
1806 -> raw::c_int>;
1807pub type NetsnmpCacheFree =
1808 ::std::option::Option<unsafe extern "C" fn(arg1: *mut netsnmp_cache,
1809 arg2:
1810 *mut raw::c_void)>;
1811extern "C" {
1812 pub fn netsnmp_cache_reqinfo_insert(cache: *mut netsnmp_cache,
1813 reqinfo:
1814 *mut netsnmp_agent_request_info,
1815 name: *const raw::c_char);
1816
1817 pub fn netsnmp_cache_reqinfo_extract(reqinfo:
1818 *mut netsnmp_agent_request_info,
1819 name: *const raw::c_char)
1820 -> *mut netsnmp_cache;
1821
1822 pub fn netsnmp_extract_cache_info(arg1: *mut netsnmp_agent_request_info)
1823 -> *mut netsnmp_cache;
1824
1825 pub fn netsnmp_cache_check_and_reload(cache: *mut netsnmp_cache)
1826 -> raw::c_int;
1827
1828 pub fn netsnmp_cache_check_expired(cache: *mut netsnmp_cache)
1829 -> raw::c_int;
1830
1831 pub fn netsnmp_cache_is_valid(arg1: *mut netsnmp_agent_request_info,
1832 name: *const raw::c_char)
1833 -> raw::c_int;
1834
1835 pub fn netsnmp_is_cache_valid(arg1: *mut netsnmp_agent_request_info)
1836 -> raw::c_int;
1837
1838 pub fn netsnmp_get_cache_handler(arg1: raw::c_int,
1839 arg2: NetsnmpCacheLoad,
1840 arg3: NetsnmpCacheFree, arg4: *const oid,
1841 arg5: raw::c_int)
1842 -> *mut netsnmp_mib_handler;
1843
1844 pub fn netsnmp_register_cache_handler(reginfo:
1845 *mut netsnmp_handler_registration,
1846 arg1: raw::c_int,
1847 arg2: NetsnmpCacheLoad,
1848 arg3: NetsnmpCacheFree)
1849 -> raw::c_int;
1850
1851 pub fn netsnmp_cache_helper_handler(handler: *mut netsnmp_mib_handler,
1852 reginfo:
1853 *mut netsnmp_handler_registration,
1854 reqinfo:
1855 *mut netsnmp_agent_request_info,
1856 requests: *mut netsnmp_request_info)
1857 -> raw::c_int;
1858
1859 pub fn netsnmp_cache_create(timeout: raw::c_int,
1860 load_hook: NetsnmpCacheLoad,
1861 free_hook: NetsnmpCacheFree,
1862 rootoid: *const oid,
1863 rootoid_len: raw::c_int)
1864 -> *mut netsnmp_cache;
1865
1866 pub fn netsnmp_cache_remove(cache: *mut netsnmp_cache)
1867 -> raw::c_int;
1868
1869 pub fn netsnmp_cache_free(cache: *mut netsnmp_cache)
1870 -> raw::c_int;
1871
1872 pub fn netsnmp_cache_handler_get(cache: *mut netsnmp_cache)
1873 -> *mut netsnmp_mib_handler;
1874
1875 pub fn netsnmp_cache_handler_owns_cache(handler:
1876 *mut netsnmp_mib_handler);
1877
1878 pub fn netsnmp_cache_find_by_oid(rootoid: *const oid,
1879 rootoid_len: raw::c_int)
1880 -> *mut netsnmp_cache;
1881
1882 pub fn netsnmp_cache_timer_start(cache: *mut netsnmp_cache)
1883 -> raw::c_uint;
1884
1885 pub fn netsnmp_cache_timer_stop(cache: *mut netsnmp_cache);
1886}
1887#[repr(C)]
1888#[derive(Copy)]
1889pub struct netsnmp_old_api_info_s {
1890 pub var: *mut variable,
1891 pub varsize: usize,
1892 pub numvars: usize,
1893 pub ss: *mut netsnmp_session,
1894 pub flags: raw::c_int,
1895}
1896
1897impl Clone for netsnmp_old_api_info_s {
1898 fn clone(&self) -> Self { *self }
1899}
1900pub type netsnmp_old_api_info = netsnmp_old_api_info_s;
1901#[repr(C)]
1902#[derive(Copy)]
1903pub struct old_opi_cache_s {
1904 pub data: *mut raw::c_uchar,
1905 pub write_method: WriteMethod,
1906}
1907
1908impl Clone for old_opi_cache_s {
1909 fn clone(&self) -> Self { *self }
1910}
1911pub type netsnmp_old_api_cache = old_opi_cache_s;
1912extern "C" {
1913 pub fn netsnmp_register_old_api(moduleName: *const raw::c_char,
1914 var: *const variable, varsize: usize,
1915 numvars: usize, mibloc: *const oid,
1916 mibloclen: usize,
1917 priority: raw::c_int,
1918 range_subid: raw::c_int,
1919 range_ubound: oid,
1920 ss: *mut netsnmp_session,
1921 context: *const raw::c_char,
1922 timeout: raw::c_int,
1923 flags: raw::c_int)
1924 -> raw::c_int;
1925
1926 pub fn netsnmp_old_api_helper(handler: *mut netsnmp_mib_handler,
1927 reginfo: *mut netsnmp_handler_registration,
1928 reqinfo: *mut netsnmp_agent_request_info,
1929 requests: *mut netsnmp_request_info)
1930 -> raw::c_int;
1931
1932 pub fn netsnmp_get_current_agent_session() -> *mut netsnmp_agent_session;
1933
1934 pub fn netsnmp_get_read_only_handler() -> *mut netsnmp_mib_handler;
1935
1936 pub fn netsnmp_init_read_only_helper();
1937
1938 pub fn netsnmp_read_only_helper(handler: *mut netsnmp_mib_handler,
1939 reginfo:
1940 *mut netsnmp_handler_registration,
1941 reqinfo: *mut netsnmp_agent_request_info,
1942 requests: *mut netsnmp_request_info)
1943 -> raw::c_int;
1944}
1945#[repr(C)]
1946#[derive(Copy)]
1947pub struct netsnmp_row_merge_status_x {
1948 pub count: raw::c_char,
1949 pub rows: raw::c_char,
1950 pub current: raw::c_char,
1951 pub reserved: raw::c_char,
1952 pub saved_requests: *mut *mut netsnmp_request_info,
1953 pub saved_status: *mut raw::c_char,
1954}
1955
1956impl Clone for netsnmp_row_merge_status_x {
1957 fn clone(&self) -> Self { *self }
1958}
1959pub type netsnmp_row_merge_status = netsnmp_row_merge_status_x;
1960extern "C" {
1961 pub fn netsnmp_get_row_merge_handler(arg1: raw::c_int)
1962 -> *mut netsnmp_mib_handler;
1963
1964 pub fn netsnmp_register_row_merge(reginfo:
1965 *mut netsnmp_handler_registration)
1966 -> raw::c_int;
1967
1968 pub fn netsnmp_init_row_merge();
1969
1970 pub fn netsnmp_row_merge_status_first(reginfo:
1971 *mut netsnmp_handler_registration,
1972 reqinfo:
1973 *mut netsnmp_agent_request_info)
1974 -> raw::c_int;
1975
1976 pub fn netsnmp_row_merge_status_last(reginfo:
1977 *mut netsnmp_handler_registration,
1978 reqinfo:
1979 *mut netsnmp_agent_request_info)
1980 -> raw::c_int;
1981
1982 pub fn netsnmp_row_merge_helper_handler(handler: *mut netsnmp_mib_handler,
1983 reginfo:
1984 *mut netsnmp_handler_registration,
1985 reqinfo:
1986 *mut netsnmp_agent_request_info,
1987 requests:
1988 *mut netsnmp_request_info)
1989 -> raw::c_int;
1990
1991 pub fn netsnmp_get_serialize_handler() -> *mut netsnmp_mib_handler;
1992
1993 pub fn netsnmp_register_serialize(reginfo:
1994 *mut netsnmp_handler_registration)
1995 -> raw::c_int;
1996
1997 pub fn netsnmp_init_serialize();
1998
1999 pub fn netsnmp_serialize_helper_handler(handler: *mut netsnmp_mib_handler,
2000 reginfo:
2001 *mut netsnmp_handler_registration,
2002 reqinfo:
2003 *mut netsnmp_agent_request_info,
2004 requests:
2005 *mut netsnmp_request_info)
2006 -> raw::c_int;
2007
2008 pub fn netsnmp_get_bulk_to_next_handler() -> *mut netsnmp_mib_handler;
2009
2010 pub fn netsnmp_init_bulk_to_next_helper();
2011
2012 pub fn netsnmp_bulk_to_next_fix_requests(requests:
2013 *mut netsnmp_request_info);
2014
2015 pub fn netsnmp_bulk_to_next_helper(handler: *mut netsnmp_mib_handler,
2016 reginfo:
2017 *mut netsnmp_handler_registration,
2018 reqinfo:
2019 *mut netsnmp_agent_request_info,
2020 requests: *mut netsnmp_request_info)
2021 -> raw::c_int;
2022}
2023#[repr(C)]
2024#[derive(Copy)]
2025pub struct netsnmp_mode_handler_list_s {
2026 pub next: *mut netsnmp_mode_handler_list_s,
2027 pub mode: raw::c_int,
2028 pub callback_handler: *mut netsnmp_mib_handler,
2029}
2030
2031impl Clone for netsnmp_mode_handler_list_s {
2032 fn clone(&self) -> Self { *self }
2033}
2034pub type netsnmp_mode_handler_list = netsnmp_mode_handler_list_s;
2035extern "C" {
2036 pub fn netsnmp_get_mode_end_call_handler(endlist:
2037 *mut netsnmp_mode_handler_list)
2038 -> *mut netsnmp_mib_handler;
2039
2040 pub fn netsnmp_mode_end_call_add_mode_callback(endlist:
2041 *mut netsnmp_mode_handler_list,
2042 mode:
2043 raw::c_int,
2044 callbackh:
2045 *mut netsnmp_mib_handler)
2046 -> *mut netsnmp_mode_handler_list;
2047
2048 pub fn netsnmp_mode_end_call_helper(handler: *mut netsnmp_mib_handler,
2049 reginfo:
2050 *mut netsnmp_handler_registration,
2051 reqinfo:
2052 *mut netsnmp_agent_request_info,
2053 requests: *mut netsnmp_request_info)
2054 -> raw::c_int;
2055}
2056#[repr(C)]
2057#[derive(Copy)]
2058pub struct netsnmp_column_info_t {
2059 pub isRange: raw::c_char,
2060 pub list_count: raw::c_char,
2061 pub details: netsnmp_column_info_t__bindgen_ty_1,
2062 pub next: *mut netsnmp_column_info_t,
2063}
2064#[repr(C)]
2065#[derive(Copy)]
2066pub struct netsnmp_column_info_t__bindgen_ty_1 {
2067 pub range: __BindgenUnionField<[ raw::c_uint; 2usize]>,
2068 pub list: __BindgenUnionField<*mut raw::c_uint>,
2069 pub bindgen_union_field: u64,
2070}
2071
2072impl Clone for netsnmp_column_info_t__bindgen_ty_1 {
2073 fn clone(&self) -> Self { *self }
2074}
2075
2076impl Clone for netsnmp_column_info_t {
2077 fn clone(&self) -> Self { *self }
2078}
2079pub type netsnmp_column_info = netsnmp_column_info_t;
2080#[repr(C)]
2081#[derive(Copy)]
2082pub struct netsnmp_table_registration_info_s {
2083 pub indexes: *mut netsnmp_variable_list,
2084 pub number_indexes: raw::c_uint,
2085 pub min_column: raw::c_uint,
2086 pub max_column: raw::c_uint,
2087 pub valid_columns: *mut netsnmp_column_info,
2088}
2089impl Clone for netsnmp_table_registration_info_s {
2090 fn clone(&self) -> Self { *self }
2091}
2092pub type netsnmp_table_registration_info = netsnmp_table_registration_info_s;
2093#[repr(C)]
2094pub struct netsnmp_table_request_info_s {
2095 pub colnum: raw::c_uint,
2096 pub number_indexes: raw::c_uint,
2097 pub indexes: *mut netsnmp_variable_list,
2098 pub index_oid: [oid; 128usize],
2099 pub index_oid_len: usize,
2100 pub reg_info: *mut netsnmp_table_registration_info,
2101}
2102
2103pub type netsnmp_table_request_info = netsnmp_table_request_info_s;
2104extern "C" {
2105 pub fn netsnmp_get_table_handler(tabreq:
2106 *mut netsnmp_table_registration_info)
2107 -> *mut netsnmp_mib_handler;
2108
2109 pub fn netsnmp_handler_owns_table_info(handler: *mut netsnmp_mib_handler);
2110
2111 pub fn netsnmp_registration_owns_table_info(reg:
2112 *mut netsnmp_handler_registration);
2113
2114 pub fn netsnmp_register_table(reginfo: *mut netsnmp_handler_registration,
2115 tabreq:
2116 *mut netsnmp_table_registration_info)
2117 -> raw::c_int;
2118
2119 pub fn netsnmp_unregister_table(reginfo:
2120 *mut netsnmp_handler_registration)
2121 -> raw::c_int;
2122
2123 pub fn netsnmp_table_build_oid(reginfo: *mut netsnmp_handler_registration,
2124 reqinfo: *mut netsnmp_request_info,
2125 table_info:
2126 *mut netsnmp_table_request_info)
2127 -> raw::c_int;
2128
2129 pub fn netsnmp_table_build_oid_from_index(reginfo:
2130 *mut netsnmp_handler_registration,
2131 reqinfo:
2132 *mut netsnmp_request_info,
2133 table_info:
2134 *mut netsnmp_table_request_info)
2135 -> raw::c_int;
2136
2137 pub fn netsnmp_table_build_result(reginfo:
2138 *mut netsnmp_handler_registration,
2139 reqinfo: *mut netsnmp_request_info,
2140 table_info:
2141 *mut netsnmp_table_request_info,
2142 type_: raw::c_uchar, result: *mut raw::c_uchar,
2143 result_len: usize)
2144 -> raw::c_int;
2145
2146 pub fn netsnmp_update_variable_list_from_index(arg1:
2147 *mut netsnmp_table_request_info)
2148 -> raw::c_int;
2149
2150 pub fn netsnmp_update_indexes_from_variable_list(tri:
2151 *mut netsnmp_table_request_info)
2152 -> raw::c_int;
2153
2154 pub fn netsnmp_find_table_registration_info(reginfo:
2155 *mut netsnmp_handler_registration)
2156 -> *mut netsnmp_table_registration_info;
2157
2158 pub fn netsnmp_table_registration_info_clone(tri:
2159 *mut netsnmp_table_registration_info)
2160 -> *mut netsnmp_table_registration_info;
2161
2162 pub fn netsnmp_table_registration_info_free(arg1:
2163 *mut netsnmp_table_registration_info);
2164
2165 pub fn netsnmp_table_index_find_next_row(c: *mut netsnmp_container,
2166 tblreq:
2167 *mut netsnmp_table_request_info)
2168 -> *mut netsnmp_index;
2169
2170 pub fn netsnmp_closest_column(current: raw::c_uint,
2171 valid_columns: *mut netsnmp_column_info)
2172 -> raw::c_uint;
2173
2174 pub fn table_helper_handler(handler: *mut netsnmp_mib_handler,
2175 reginfo: *mut netsnmp_handler_registration,
2176 reqinfo: *mut netsnmp_agent_request_info,
2177 requests: *mut netsnmp_request_info)
2178 -> raw::c_int;
2179
2180 pub fn netsnmp_table_helper_add_indexes(tinfo:
2181 *mut netsnmp_table_registration_info, ...);
2182
2183 pub fn netsnmp_check_getnext_reply(request: *mut netsnmp_request_info,
2184 prefix: *mut oid, prefix_len: usize,
2185 newvar: *mut netsnmp_variable_list,
2186 outvar:
2187 *mut *mut netsnmp_variable_list)
2188 -> raw::c_int;
2189
2190 pub fn netsnmp_extract_table_info(arg1: *mut netsnmp_request_info)
2191 -> *mut netsnmp_table_request_info;
2192
2193 pub fn netsnmp_table_get_or_create_row_stash(reqinfo:
2194 *mut netsnmp_agent_request_info,
2195 storage_name: *const raw::c_uchar)
2196 -> *mut *mut netsnmp_oid_stash_node;
2197
2198 pub fn netsnmp_table_next_column(table_info:
2199 *mut netsnmp_table_request_info)
2200 -> raw::c_uint;
2201
2202 pub fn netsnmp_sparse_table_register(reginfo:
2203 *mut netsnmp_handler_registration,
2204 tabreq:
2205 *mut netsnmp_table_registration_info)
2206 -> raw::c_int;
2207
2208 pub fn netsnmp_sparse_table_handler_get() -> *mut netsnmp_mib_handler;
2209}
2210#[repr(C)]
2211#[derive(Copy)]
2212pub struct netsnmp_table_row_s {
2213 pub indexes: *mut netsnmp_variable_list,
2214 pub index_oid: *mut oid,
2215 pub index_oid_len: usize,
2216 pub data: *mut raw::c_void,
2217 pub next: *mut netsnmp_table_row_s,
2218 pub prev: *mut netsnmp_table_row_s,
2219}
2220
2221impl Clone for netsnmp_table_row_s {
2222 fn clone(&self) -> Self { *self }
2223}
2224pub type netsnmp_table_row = netsnmp_table_row_s;
2225#[repr(C)]
2226#[derive(Copy)]
2227pub struct netsnmp_table_data_s {
2228 pub indexes_template: *mut netsnmp_variable_list,
2229 pub name: *mut raw::c_char,
2230 pub flags: raw::c_int,
2231 pub store_indexes: raw::c_int,
2232 pub first_row: *mut netsnmp_table_row,
2233 pub last_row: *mut netsnmp_table_row,
2234}
2235
2236impl Clone for netsnmp_table_data_s {
2237 fn clone(&self) -> Self { *self }
2238}
2239pub type netsnmp_table_data = netsnmp_table_data_s;
2240extern "C" {
2241 pub fn netsnmp_table_data_generate_index_oid(row: *mut netsnmp_table_row);
2242
2243 pub fn netsnmp_create_table_data(name: *const raw::c_char)
2244 -> *mut netsnmp_table_data;
2245
2246 pub fn netsnmp_create_table_data_row() -> *mut netsnmp_table_row;
2247
2248 pub fn netsnmp_table_data_clone_row(row: *mut netsnmp_table_row)
2249 -> *mut netsnmp_table_row;
2250
2251 pub fn netsnmp_table_data_delete_row(row: *mut netsnmp_table_row)
2252 -> *mut raw::c_void;
2253
2254 pub fn netsnmp_table_data_add_row(table: *mut netsnmp_table_data,
2255 row: *mut netsnmp_table_row)
2256 -> raw::c_int;
2257
2258 pub fn netsnmp_table_data_replace_row(table: *mut netsnmp_table_data,
2259 origrow: *mut netsnmp_table_row,
2260 newrow: *mut netsnmp_table_row);
2261
2262 pub fn netsnmp_table_data_remove_row(table: *mut netsnmp_table_data,
2263 row: *mut netsnmp_table_row)
2264 -> *mut netsnmp_table_row;
2265
2266 pub fn netsnmp_table_data_remove_and_delete_row(table:
2267 *mut netsnmp_table_data,
2268 row:
2269 *mut netsnmp_table_row)
2270 -> *mut raw::c_void;
2271
2272 pub fn netsnmp_table_data_delete_table(table: *mut netsnmp_table_data);
2273
2274 pub fn netsnmp_get_table_data_handler(table: *mut netsnmp_table_data)
2275 -> *mut netsnmp_mib_handler;
2276
2277 pub fn netsnmp_register_table_data(reginfo:
2278 *mut netsnmp_handler_registration,
2279 table: *mut netsnmp_table_data,
2280 table_info:
2281 *mut netsnmp_table_registration_info)
2282 -> raw::c_int;
2283
2284 pub fn netsnmp_register_read_only_table_data(reginfo:
2285 *mut netsnmp_handler_registration,
2286 table:
2287 *mut netsnmp_table_data,
2288 table_info:
2289 *mut netsnmp_table_registration_info)
2290 -> raw::c_int;
2291
2292 pub fn netsnmp_table_data_helper_handler(handler:
2293 *mut netsnmp_mib_handler,
2294 reginfo:
2295 *mut netsnmp_handler_registration,
2296 reqinfo:
2297 *mut netsnmp_agent_request_info,
2298 requests:
2299 *mut netsnmp_request_info)
2300 -> raw::c_int;
2301
2302 pub fn netsnmp_extract_table(arg1: *mut netsnmp_request_info)
2303 -> *mut netsnmp_table_data;
2304
2305 pub fn netsnmp_extract_table_row(arg1: *mut netsnmp_request_info)
2306 -> *mut netsnmp_table_row;
2307
2308 pub fn netsnmp_extract_table_row_data(arg1: *mut netsnmp_request_info)
2309 -> *mut raw::c_void;
2310
2311 pub fn netsnmp_insert_table_row(arg1: *mut netsnmp_request_info,
2312 arg2: *mut netsnmp_table_row);
2313
2314 pub fn netsnmp_table_data_build_result(reginfo:
2315 *mut netsnmp_handler_registration,
2316 reqinfo:
2317 *mut netsnmp_agent_request_info,
2318 request: *mut netsnmp_request_info,
2319 row: *mut netsnmp_table_row,
2320 column: raw::c_int,
2321 type_: raw::c_uchar,
2322 result_data: *mut raw::c_uchar,
2323 result_data_len: usize)
2324 -> raw::c_int;
2325
2326 pub fn netsnmp_table_data_get_first_row(table: *mut netsnmp_table_data)
2327 -> *mut netsnmp_table_row;
2328
2329 pub fn netsnmp_table_data_get_next_row(table: *mut netsnmp_table_data,
2330 row: *mut netsnmp_table_row)
2331 -> *mut netsnmp_table_row;
2332
2333 pub fn netsnmp_table_data_get(table: *mut netsnmp_table_data,
2334 indexes: *mut netsnmp_variable_list)
2335 -> *mut netsnmp_table_row;
2336
2337 pub fn netsnmp_table_data_get_from_oid(table: *mut netsnmp_table_data,
2338 searchfor: *mut oid,
2339 searchfor_len: usize)
2340 -> *mut netsnmp_table_row;
2341
2342 pub fn netsnmp_table_data_num_rows(table: *mut netsnmp_table_data)
2343 -> raw::c_int;
2344
2345 pub fn netsnmp_init_table_dataset();
2346}
2347pub type Netsnmp_Value_Change_Ok =
2348 ::std::option::Option<unsafe extern "C" fn(old_value:
2349 *mut raw::c_char,
2350 old_value_len: usize,
2351 new_value:
2352 *mut raw::c_char,
2353 new_value_len: usize,
2354 mydata:
2355 *mut raw::c_void)
2356 -> raw::c_int>;
2357#[repr(C)]
2358#[derive(Copy)]
2359pub struct netsnmp_table_data_set_storage_s {
2360 pub column: raw::c_uint,
2361 pub writable: raw::c_char,
2362 pub change_ok_fn: Netsnmp_Value_Change_Ok,
2363 pub my_change_data: *mut raw::c_void,
2364 pub type_: raw::c_uchar,
2365 pub data: netsnmp_table_data_set_storage_s__bindgen_ty_1,
2366 pub data_len: raw::c_ulong,
2367 pub next: *mut netsnmp_table_data_set_storage_s,
2368}
2369#[repr(C)]
2370#[derive(Copy)]
2371pub struct netsnmp_table_data_set_storage_s__bindgen_ty_1 {
2372 pub voidp: __BindgenUnionField<*mut raw::c_void>,
2373 pub integer: __BindgenUnionField<*mut raw::c_long>,
2374 pub string: __BindgenUnionField<*mut raw::c_uchar>,
2375 pub objid: __BindgenUnionField<*mut oid>,
2376 pub bitstring: __BindgenUnionField<*mut raw::c_uchar>,
2377 pub counter64: __BindgenUnionField<Struct_counter64>,
2378 pub floatVal: __BindgenUnionField<*mut f32>,
2379 pub doubleVal: __BindgenUnionField<*mut f64>,
2380 pub bindgen_union_field: u64,
2381}
2382
2383impl Clone for netsnmp_table_data_set_storage_s__bindgen_ty_1 {
2384 fn clone(&self) -> Self { *self }
2385}
2386
2387impl Clone for netsnmp_table_data_set_storage_s {
2388 fn clone(&self) -> Self { *self }
2389}
2390pub type netsnmp_table_data_set_storage = netsnmp_table_data_set_storage_s;
2391#[repr(C)]
2392#[derive(Copy)]
2393pub struct netsnmp_table_data_set_s {
2394 pub table: *mut netsnmp_table_data,
2395 pub default_row: *mut netsnmp_table_data_set_storage,
2396 pub allow_creation: raw::c_int,
2397 pub rowstatus_column: raw::c_uint,
2398}
2399
2400impl Clone for netsnmp_table_data_set_s {
2401 fn clone(&self) -> Self { *self }
2402}
2403pub type netsnmp_table_data_set = netsnmp_table_data_set_s;
2404extern "C" {
2405 pub fn netsnmp_create_table_data_set(arg1: *const raw::c_char)
2406 -> *mut netsnmp_table_data_set;
2407
2408 pub fn netsnmp_table_data_set_clone_row(row: *mut netsnmp_table_row)
2409 -> *mut netsnmp_table_row;
2410
2411 pub fn netsnmp_table_dataset_delete_all_data(data:
2412 *mut netsnmp_table_data_set_storage);
2413
2414 pub fn netsnmp_table_dataset_delete_row(row: *mut netsnmp_table_row);
2415
2416 pub fn netsnmp_table_dataset_add_row(table: *mut netsnmp_table_data_set,
2417 row: *mut netsnmp_table_row);
2418
2419 pub fn netsnmp_table_dataset_replace_row(table:
2420 *mut netsnmp_table_data_set,
2421 origrow: *mut netsnmp_table_row,
2422 newrow: *mut netsnmp_table_row);
2423
2424 pub fn netsnmp_table_dataset_remove_row(table:
2425 *mut netsnmp_table_data_set,
2426 row: *mut netsnmp_table_row);
2427
2428 pub fn netsnmp_table_dataset_remove_and_delete_row(table:
2429 *mut netsnmp_table_data_set,
2430 row:
2431 *mut netsnmp_table_row);
2432
2433 pub fn netsnmp_delete_table_data_set(table_set:
2434 *mut netsnmp_table_data_set);
2435
2436 pub fn netsnmp_table_set_add_default_row(arg1:
2437 *mut netsnmp_table_data_set,
2438 arg2: raw::c_uint,
2439 arg3: raw::c_int,
2440 arg4: raw::c_int,
2441 default_value:
2442 *mut raw::c_void,
2443 default_value_len: usize)
2444 -> raw::c_int;
2445
2446 pub fn netsnmp_table_set_multi_add_default_row(arg1:
2447 *mut netsnmp_table_data_set, ...);
2448
2449 pub fn netsnmp_get_table_data_set_handler(arg1:
2450 *mut netsnmp_table_data_set)
2451 -> *mut netsnmp_mib_handler;
2452
2453 pub fn netsnmp_table_data_set_helper_handler(handler:
2454 *mut netsnmp_mib_handler,
2455 reginfo:
2456 *mut netsnmp_handler_registration,
2457 reqinfo:
2458 *mut netsnmp_agent_request_info,
2459 requests:
2460 *mut netsnmp_request_info)
2461 -> raw::c_int;
2462
2463 pub fn netsnmp_register_table_data_set(arg1:
2464 *mut netsnmp_handler_registration,
2465 arg2: *mut netsnmp_table_data_set,
2466 arg3:
2467 *mut netsnmp_table_registration_info)
2468 -> raw::c_int;
2469
2470 pub fn netsnmp_extract_table_data_set(request: *mut netsnmp_request_info)
2471 -> *mut netsnmp_table_data_set;
2472
2473 pub fn netsnmp_extract_table_data_set_column(arg1:
2474 *mut netsnmp_request_info,
2475 arg2: raw::c_uint)
2476 -> *mut netsnmp_table_data_set_storage;
2477
2478 pub fn netsnmp_table_dataset_get_or_create_stash(ari:
2479 *mut netsnmp_agent_request_info,
2480 tds:
2481 *mut netsnmp_table_data_set,
2482 tri:
2483 *mut netsnmp_table_request_info)
2484 -> *mut *mut netsnmp_oid_stash_node;
2485
2486 pub fn netsnmp_table_dataset_get_newrow(request:
2487 *mut netsnmp_request_info,
2488 reqinfo:
2489 *mut netsnmp_agent_request_info,
2490 rootoid_len:
2491 raw::c_int,
2492 datatable:
2493 *mut netsnmp_table_data_set,
2494 table_info:
2495 *mut netsnmp_table_request_info)
2496 -> *mut netsnmp_table_row;
2497
2498 pub fn netsnmp_register_auto_data_table(table_set:
2499 *mut netsnmp_table_data_set,
2500 registration_name:
2501 *mut raw::c_char);
2502
2503 pub fn netsnmp_unregister_auto_data_table(table_set:
2504 *mut netsnmp_table_data_set,
2505 registration_name:
2506 *mut raw::c_char);
2507
2508 pub fn netsnmp_config_parse_table_set(token:
2509 *const raw::c_char,
2510 line: *mut raw::c_char);
2511
2512 pub fn netsnmp_config_parse_add_row(token: *const raw::c_char,
2513 line: *mut raw::c_char);
2514
2515 pub fn netsnmp_table_data_set_get_first_row(table:
2516 *mut netsnmp_table_data_set)
2517 -> *mut netsnmp_table_row;
2518
2519 pub fn netsnmp_table_data_set_get_next_row(table:
2520 *mut netsnmp_table_data_set,
2521 row: *mut netsnmp_table_row)
2522 -> *mut netsnmp_table_row;
2523
2524 pub fn netsnmp_table_set_num_rows(table: *mut netsnmp_table_data_set)
2525 -> raw::c_int;
2526
2527 pub fn netsnmp_table_data_set_find_column(arg1:
2528 *mut netsnmp_table_data_set_storage,
2529 arg2: raw::c_uint)
2530 -> *mut netsnmp_table_data_set_storage;
2531
2532 pub fn netsnmp_mark_row_column_writable(row: *mut netsnmp_table_row,
2533 column: raw::c_int,
2534 writable: raw::c_int)
2535 -> raw::c_int;
2536
2537 pub fn netsnmp_set_row_column(arg1: *mut netsnmp_table_row,
2538 arg2: raw::c_uint,
2539 arg3: raw::c_int,
2540 arg4: *const raw::c_void,
2541 arg5: usize) -> raw::c_int;
2542
2543 pub fn netsnmp_table_dataset_add_index(table: *mut netsnmp_table_data_set,
2544 type_: raw::c_uchar);
2545
2546 pub fn netsnmp_table_set_add_indexes(tset:
2547 *mut netsnmp_table_data_set, ...);
2548}
2549#[repr(C)]
2550#[derive(Copy)]
2551pub struct netsnmp_tdata_row_s {
2552 pub oid_index: netsnmp_index,
2553 pub indexes: *mut netsnmp_variable_list,
2554 pub data: *mut raw::c_void,
2555}
2556
2557impl Clone for netsnmp_tdata_row_s {
2558 fn clone(&self) -> Self { *self }
2559}
2560pub type netsnmp_tdata_row = netsnmp_tdata_row_s;
2561#[repr(C)]
2562#[derive(Copy)]
2563pub struct netsnmp_tdata_s {
2564 pub indexes_template: *mut netsnmp_variable_list,
2565 pub name: *mut raw::c_char,
2566 pub flags: raw::c_int,
2567 pub container: *mut netsnmp_container,
2568}
2569
2570impl Clone for netsnmp_tdata_s {
2571 fn clone(&self) -> Self { *self }
2572}
2573pub type netsnmp_tdata = netsnmp_tdata_s;
2574pub type netsnmp_table_data2row = netsnmp_tdata_row_s;
2575pub type netsnmp_table_data2 = netsnmp_tdata_s;
2576extern "C" {
2577 pub fn netsnmp_tdata_create_table(name: *const raw::c_char,
2578 flags: raw::c_long)
2579 -> *mut netsnmp_tdata;
2580
2581 pub fn netsnmp_tdata_delete_table(table: *mut netsnmp_tdata);
2582
2583 pub fn netsnmp_tdata_create_row() -> *mut netsnmp_tdata_row;
2584
2585 pub fn netsnmp_tdata_clone_row(row: *mut netsnmp_tdata_row)
2586 -> *mut netsnmp_tdata_row;
2587
2588 pub fn netsnmp_tdata_copy_row(dst_row: *mut netsnmp_tdata_row,
2589 src_row: *mut netsnmp_tdata_row)
2590 -> raw::c_int;
2591
2592 pub fn netsnmp_tdata_delete_row(row: *mut netsnmp_tdata_row)
2593 -> *mut raw::c_void;
2594
2595 pub fn netsnmp_tdata_add_row(table: *mut netsnmp_tdata,
2596 row: *mut netsnmp_tdata_row)
2597 -> raw::c_int;
2598
2599 pub fn netsnmp_tdata_replace_row(table: *mut netsnmp_tdata,
2600 origrow: *mut netsnmp_tdata_row,
2601 newrow: *mut netsnmp_tdata_row);
2602
2603 pub fn netsnmp_tdata_remove_row(table: *mut netsnmp_tdata,
2604 row: *mut netsnmp_tdata_row)
2605 -> *mut netsnmp_tdata_row;
2606
2607 pub fn netsnmp_tdata_remove_and_delete_row(table: *mut netsnmp_tdata,
2608 row: *mut netsnmp_tdata_row)
2609 -> *mut raw::c_void;
2610
2611 pub fn netsnmp_get_tdata_handler(table: *mut netsnmp_tdata)
2612 -> *mut netsnmp_mib_handler;
2613
2614 pub fn netsnmp_tdata_register(reginfo: *mut netsnmp_handler_registration,
2615 table: *mut netsnmp_tdata,
2616 table_info:
2617 *mut netsnmp_table_registration_info)
2618 -> raw::c_int;
2619
2620 pub fn netsnmp_tdata_unregister(reginfo:
2621 *mut netsnmp_handler_registration)
2622 -> raw::c_int;
2623
2624 pub fn netsnmp_tdata_extract_table(arg1: *mut netsnmp_request_info)
2625 -> *mut netsnmp_tdata;
2626
2627 pub fn netsnmp_tdata_extract_container(arg1: *mut netsnmp_request_info)
2628 -> *mut netsnmp_container;
2629
2630 pub fn netsnmp_tdata_extract_row(arg1: *mut netsnmp_request_info)
2631 -> *mut netsnmp_tdata_row;
2632
2633 pub fn netsnmp_tdata_extract_entry(arg1: *mut netsnmp_request_info)
2634 -> *mut raw::c_void;
2635
2636 pub fn netsnmp_insert_tdata_row(arg1: *mut netsnmp_request_info,
2637 arg2: *mut netsnmp_tdata_row);
2638
2639 pub fn netsnmp_remove_tdata_row(arg1: *mut netsnmp_request_info,
2640 arg2: *mut netsnmp_tdata_row);
2641
2642 pub fn netsnmp_tdata_row_entry(row: *mut netsnmp_tdata_row)
2643 -> *mut raw::c_void;
2644
2645 pub fn netsnmp_tdata_row_first(table: *mut netsnmp_tdata)
2646 -> *mut netsnmp_tdata_row;
2647
2648 pub fn netsnmp_tdata_row_get(table: *mut netsnmp_tdata,
2649 row: *mut netsnmp_tdata_row)
2650 -> *mut netsnmp_tdata_row;
2651
2652 pub fn netsnmp_tdata_row_next(table: *mut netsnmp_tdata,
2653 row: *mut netsnmp_tdata_row)
2654 -> *mut netsnmp_tdata_row;
2655
2656 pub fn netsnmp_tdata_row_get_byidx(table: *mut netsnmp_tdata,
2657 indexes: *mut netsnmp_variable_list)
2658 -> *mut netsnmp_tdata_row;
2659
2660 pub fn netsnmp_tdata_row_get_byoid(table: *mut netsnmp_tdata,
2661 searchfor: *mut oid,
2662 searchfor_len: usize)
2663 -> *mut netsnmp_tdata_row;
2664
2665 pub fn netsnmp_tdata_row_next_byidx(table: *mut netsnmp_tdata,
2666 indexes: *mut netsnmp_variable_list)
2667 -> *mut netsnmp_tdata_row;
2668
2669 pub fn netsnmp_tdata_row_next_byoid(table: *mut netsnmp_tdata,
2670 searchfor: *mut oid,
2671 searchfor_len: usize)
2672 -> *mut netsnmp_tdata_row;
2673
2674 pub fn netsnmp_tdata_row_count(table: *mut netsnmp_tdata)
2675 -> raw::c_int;
2676
2677 pub fn netsnmp_tdata_compare_idx(row: *mut netsnmp_tdata_row,
2678 indexes: *mut netsnmp_variable_list)
2679 -> raw::c_int;
2680
2681 pub fn netsnmp_tdata_compare_oid(row: *mut netsnmp_tdata_row,
2682 compareto: *mut oid,
2683 compareto_len: usize)
2684 -> raw::c_int;
2685
2686 pub fn netsnmp_tdata_compare_subtree_idx(row: *mut netsnmp_tdata_row,
2687 indexes:
2688 *mut netsnmp_variable_list)
2689 -> raw::c_int;
2690
2691 pub fn netsnmp_tdata_compare_subtree_oid(row: *mut netsnmp_tdata_row,
2692 compareto: *mut oid,
2693 compareto_len: usize)
2694 -> raw::c_int;
2695}
2696#[repr(C)]
2697#[derive(Copy)]
2698pub struct netsnmp_iterator_info_s {
2699 pub refcnt: raw::c_int,
2700 pub get_first_data_point: Netsnmp_First_Data_Point,
2701 pub get_next_data_point: Netsnmp_Next_Data_Point,
2702 pub make_data_context: Netsnmp_Make_Data_Context,
2703 pub free_loop_context: Netsnmp_Free_Loop_Context,
2704 pub free_data_context: Netsnmp_Free_Data_Context,
2705 pub free_loop_context_at_end: Netsnmp_Free_Loop_Context,
2706 pub myvoid: *mut raw::c_void,
2707 pub flags: raw::c_int,
2708 pub table_reginfo: *mut netsnmp_table_registration_info,
2709 pub get_row_indexes: Netsnmp_First_Data_Point,
2710 pub indexes: *mut netsnmp_variable_list,
2711}
2712
2713impl Clone for netsnmp_iterator_info_s {
2714 fn clone(&self) -> Self { *self }
2715}
2716pub type Netsnmp_First_Data_Point =
2717 ::std::option::Option<unsafe extern "C" fn(loop_context:
2718 *mut *mut raw::c_void,
2719 data_context:
2720 *mut *mut raw::c_void,
2721 arg1:
2722 *mut netsnmp_variable_list,
2723 arg2:
2724 *mut netsnmp_iterator_info_s)
2725 -> *mut netsnmp_variable_list>;
2726pub type Netsnmp_Next_Data_Point =
2727 ::std::option::Option<unsafe extern "C" fn(loop_context:
2728 *mut *mut raw::c_void,
2729 data_context:
2730 *mut *mut raw::c_void,
2731 arg1:
2732 *mut netsnmp_variable_list,
2733 arg2:
2734 *mut netsnmp_iterator_info_s)
2735 -> *mut netsnmp_variable_list>;
2736pub type Netsnmp_Make_Data_Context =
2737 ::std::option::Option<unsafe extern "C" fn(loop_context:
2738 *mut raw::c_void,
2739 arg1:
2740 *mut netsnmp_iterator_info_s)
2741 -> *mut raw::c_void>;
2742pub type Netsnmp_Free_Loop_Context =
2743 ::std::option::Option<unsafe extern "C" fn(arg1:
2744 *mut raw::c_void,
2745 arg2:
2746 *mut netsnmp_iterator_info_s)>;
2747pub type Netsnmp_Free_Data_Context =
2748 ::std::option::Option<unsafe extern "C" fn(arg1:
2749 *mut raw::c_void,
2750 arg2:
2751 *mut netsnmp_iterator_info_s)>;
2752pub type netsnmp_iterator_info = netsnmp_iterator_info_s;
2753extern "C" {
2754 pub fn netsnmp_handler_owns_iterator_info(h: *mut netsnmp_mib_handler);
2755
2756 pub fn netsnmp_get_table_iterator_handler(iinfo:
2757 *mut netsnmp_iterator_info)
2758 -> *mut netsnmp_mib_handler;
2759
2760 pub fn netsnmp_register_table_iterator(reginfo:
2761 *mut netsnmp_handler_registration,
2762 iinfo: *mut netsnmp_iterator_info)
2763 -> raw::c_int;
2764
2765 pub fn netsnmp_iterator_delete_table(iinfo: *mut netsnmp_iterator_info);
2766
2767 pub fn netsnmp_extract_iterator_context(arg1: *mut netsnmp_request_info)
2768 -> *mut raw::c_void;
2769
2770 pub fn netsnmp_insert_iterator_context(arg1: *mut netsnmp_request_info,
2771 arg2: *mut raw::c_void);
2772
2773 pub fn netsnmp_table_iterator_helper_handler(handler:
2774 *mut netsnmp_mib_handler,
2775 reginfo:
2776 *mut netsnmp_handler_registration,
2777 reqinfo:
2778 *mut netsnmp_agent_request_info,
2779 requests:
2780 *mut netsnmp_request_info)
2781 -> raw::c_int;
2782
2783 pub fn netsnmp_iterator_row_first(arg1: *mut netsnmp_iterator_info)
2784 -> *mut raw::c_void;
2785
2786 pub fn netsnmp_iterator_row_get(arg1: *mut netsnmp_iterator_info,
2787 arg2: *mut raw::c_void)
2788 -> *mut raw::c_void;
2789
2790 pub fn netsnmp_iterator_row_next(arg1: *mut netsnmp_iterator_info,
2791 arg2: *mut raw::c_void)
2792 -> *mut raw::c_void;
2793
2794 pub fn netsnmp_iterator_row_get_byidx(arg1: *mut netsnmp_iterator_info,
2795 arg2: *mut netsnmp_variable_list)
2796 -> *mut raw::c_void;
2797
2798 pub fn netsnmp_iterator_row_next_byidx(arg1: *mut netsnmp_iterator_info,
2799 arg2: *mut netsnmp_variable_list)
2800 -> *mut raw::c_void;
2801
2802 pub fn netsnmp_iterator_row_get_byoid(arg1: *mut netsnmp_iterator_info,
2803 arg2: *mut oid, arg3: usize)
2804 -> *mut raw::c_void;
2805
2806 pub fn netsnmp_iterator_row_next_byoid(arg1: *mut netsnmp_iterator_info,
2807 arg2: *mut oid, arg3: usize)
2808 -> *mut raw::c_void;
2809
2810 pub fn netsnmp_iterator_row_count(arg1: *mut netsnmp_iterator_info)
2811 -> raw::c_int;
2812
2813 pub fn netsnmp_container_table_handler_get(tabreq:
2814 *mut netsnmp_table_registration_info,
2815 container:
2816 *mut netsnmp_container,
2817 key_type:
2818 raw::c_char)
2819 -> *mut netsnmp_mib_handler;
2820
2821 pub fn netsnmp_container_table_register(reginfo:
2822 *mut netsnmp_handler_registration,
2823 tabreq:
2824 *mut netsnmp_table_registration_info,
2825 container: *mut netsnmp_container,
2826 key_type: raw::c_char)
2827 -> raw::c_int;
2828
2829 pub fn netsnmp_container_table_unregister(reginfo:
2830 *mut netsnmp_handler_registration)
2831 -> raw::c_int;
2832
2833 pub fn netsnmp_container_table_container_extract(request:
2834 *mut netsnmp_request_info)
2835 -> *mut netsnmp_container;
2836
2837 pub fn netsnmp_container_table_row_insert(request:
2838 *mut netsnmp_request_info,
2839 row: *mut netsnmp_index);
2840
2841 pub fn netsnmp_container_table_row_remove(request:
2842 *mut netsnmp_request_info,
2843 row: *mut netsnmp_index);
2844
2845 pub fn netsnmp_container_table_find_next_row(request:
2846 *mut netsnmp_request_info,
2847 tblreq:
2848 *mut netsnmp_table_request_info,
2849 container:
2850 *mut netsnmp_container,
2851 key_type:
2852 raw::c_char)
2853 -> *mut raw::c_void;
2854}
2855#[repr(C)]
2856#[derive(Copy)]
2857pub struct netsnmp_request_group_item_s {
2858 pub ri: *mut netsnmp_request_info,
2859 pub tri: *mut netsnmp_table_request_info,
2860 pub next: *mut netsnmp_request_group_item_s,
2861}
2862
2863impl Clone for netsnmp_request_group_item_s {
2864 fn clone(&self) -> Self { *self }
2865}
2866pub type netsnmp_request_group_item = netsnmp_request_group_item_s;
2867#[repr(C)]
2868#[derive(Copy)]
2869pub struct netsnmp_request_group_s {
2870 pub index: netsnmp_index,
2871 pub table: *mut netsnmp_container,
2872 pub existing_row: *mut netsnmp_index,
2873 pub undo_info: *mut netsnmp_index,
2874 pub row_created: raw::c_char,
2875 pub row_deleted: raw::c_char,
2876 pub fill1: raw::c_char,
2877 pub fill2: raw::c_char,
2878 pub list: *mut netsnmp_request_group_item,
2879 pub status: raw::c_int,
2880 pub rg_void: *mut raw::c_void,
2881}
2882
2883impl Clone for netsnmp_request_group_s {
2884 fn clone(&self) -> Self { *self }
2885}
2886pub type netsnmp_request_group = netsnmp_request_group_s;
2887pub type Netsnmp_User_Row_Operation_c =
2888 ::std::option::Option<unsafe extern "C" fn(lhs:
2889 *const raw::c_void,
2890 rhs:
2891 *const raw::c_void)
2892 -> raw::c_int>;
2893pub type Netsnmp_User_Row_Operation =
2894 ::std::option::Option<unsafe extern "C" fn(lhs:
2895 *mut raw::c_void,
2896 rhs:
2897 *mut raw::c_void)
2898 -> raw::c_int>;
2899pub type Netsnmp_User_Get_Processor =
2900 ::std::option::Option<unsafe extern "C" fn(arg1:
2901 *mut netsnmp_request_info,
2902 arg2: *mut netsnmp_index,
2903 arg3:
2904 *mut netsnmp_table_request_info)
2905 -> raw::c_int>;
2906pub type UserRowMethod =
2907 ::std::option::Option<unsafe extern "C" fn(arg1: *mut netsnmp_index)
2908 -> *mut netsnmp_index>;
2909pub type Netsnmp_User_Row_Action =
2910 ::std::option::Option<unsafe extern "C" fn(arg1: *mut netsnmp_index,
2911 arg2: *mut netsnmp_index,
2912 arg3:
2913 *mut netsnmp_request_group)
2914 -> raw::c_int>;
2915pub type Netsnmp_User_Group_Method =
2916 ::std::option::Option<unsafe extern "C" fn(arg1:
2917 *mut netsnmp_request_group)>;
2918#[repr(C)]
2919#[derive(Copy)]
2920pub struct netsnmp_table_array_callbacks_s {
2921 pub row_copy: Netsnmp_User_Row_Operation,
2922 pub row_compare: Netsnmp_User_Row_Operation_c,
2923 pub get_value: Netsnmp_User_Get_Processor,
2924 pub can_activate: Netsnmp_User_Row_Action,
2925 pub activated: Netsnmp_User_Row_Action,
2926 pub can_deactivate: Netsnmp_User_Row_Action,
2927 pub deactivated: Netsnmp_User_Row_Action,
2928 pub can_delete: Netsnmp_User_Row_Action,
2929 pub create_row: UserRowMethod,
2930 pub duplicate_row: UserRowMethod,
2931 pub delete_row: UserRowMethod,
2932 pub set_reserve1: Netsnmp_User_Group_Method,
2933 pub set_reserve2: Netsnmp_User_Group_Method,
2934 pub set_action: Netsnmp_User_Group_Method,
2935 pub set_commit: Netsnmp_User_Group_Method,
2936 pub set_free: Netsnmp_User_Group_Method,
2937 pub set_undo: Netsnmp_User_Group_Method,
2938 pub container: *mut netsnmp_container,
2939 pub can_set: raw::c_char,
2940}
2941
2942impl Clone for netsnmp_table_array_callbacks_s {
2943 fn clone(&self) -> Self { *self }
2944}
2945pub type netsnmp_table_array_callbacks = netsnmp_table_array_callbacks_s;
2946extern "C" {
2947 pub fn netsnmp_table_container_register(reginfo:
2948 *mut netsnmp_handler_registration,
2949 tabreq:
2950 *mut netsnmp_table_registration_info,
2951 cb:
2952 *mut netsnmp_table_array_callbacks,
2953 container: *mut netsnmp_container,
2954 group_rows: raw::c_int)
2955 -> raw::c_int;
2956
2957 pub fn netsnmp_table_array_register(reginfo:
2958 *mut netsnmp_handler_registration,
2959 tabreq:
2960 *mut netsnmp_table_registration_info,
2961 cb:
2962 *mut netsnmp_table_array_callbacks,
2963 container: *mut netsnmp_container,
2964 group_rows: raw::c_int)
2965 -> raw::c_int;
2966
2967 pub fn netsnmp_extract_array_context(arg1: *mut netsnmp_request_info)
2968 -> *mut netsnmp_container;
2969
2970 pub fn netsnmp_table_array_helper_handler(handler:
2971 *mut netsnmp_mib_handler,
2972 reginfo:
2973 *mut netsnmp_handler_registration,
2974 reqinfo:
2975 *mut netsnmp_agent_request_info,
2976 requests:
2977 *mut netsnmp_request_info)
2978 -> raw::c_int;
2979
2980 pub fn netsnmp_table_array_check_row_status(cb:
2981 *mut netsnmp_table_array_callbacks,
2982 ag:
2983 *mut netsnmp_request_group,
2984 rs_new:
2985 *mut raw::c_long,
2986 rs_old:
2987 *mut raw::c_long)
2988 -> raw::c_int;
2989
2990 pub fn netsnmp_register_statistic_handler(reginfo:
2991 *mut netsnmp_handler_registration,
2992 start: oid,
2993 begin: raw::c_int,
2994 end: raw::c_int)
2995 -> raw::c_int;
2996
2997 pub fn netsnmp_init_helpers();
2998
2999 pub fn init_vacm_vars();
3000 pub fn init_usmUser();
3001}
3002#[repr(C)]
3003#[derive(Copy)]
3004pub struct __locale_data {
3005 pub _address: u8,
3006}
3007impl Clone for __locale_data {
3008 fn clone(&self) -> Self { *self }
3009}
3010#[repr(C)]
3011#[derive(Copy)]
3012pub struct __va_list_tag {
3013 pub gp_offset: raw::c_uint,
3014 pub fp_offset: raw::c_uint,
3015 pub overflow_arg_area: *mut raw::c_void,
3016 pub reg_save_area: *mut raw::c_void,
3017}
3018
3019impl Clone for __va_list_tag {
3020 fn clone(&self) -> Self { *self }
3021}
3022pub type __builtin_va_list = [__va_list_tag; 1usize];
3023#[repr(C)]
3024#[derive(Copy)]
3025pub struct sockaddr_at {
3026 pub _address: u8,
3027}
3028impl Clone for sockaddr_at {
3029 fn clone(&self) -> Self { *self }
3030}
3031#[repr(C)]
3032#[derive(Copy)]
3033pub struct sockaddr_ax25 {
3034 pub _address: u8,
3035}
3036impl Clone for sockaddr_ax25 {
3037 fn clone(&self) -> Self { *self }
3038}
3039#[repr(C)]
3040#[derive(Copy)]
3041pub struct sockaddr_dl {
3042 pub _address: u8,
3043}
3044impl Clone for sockaddr_dl {
3045 fn clone(&self) -> Self { *self }
3046}
3047#[repr(C)]
3048#[derive(Copy)]
3049pub struct sockaddr_eon {
3050 pub _address: u8,
3051}
3052impl Clone for sockaddr_eon {
3053 fn clone(&self) -> Self { *self }
3054}
3055#[repr(C)]
3056#[derive(Copy)]
3057pub struct sockaddr_inarp {
3058 pub _address: u8,
3059}
3060impl Clone for sockaddr_inarp {
3061 fn clone(&self) -> Self { *self }
3062}
3063#[repr(C)]
3064#[derive(Copy)]
3065pub struct sockaddr_ipx {
3066 pub _address: u8,
3067}
3068impl Clone for sockaddr_ipx {
3069 fn clone(&self) -> Self { *self }
3070}
3071#[repr(C)]
3072#[derive(Copy)]
3073pub struct sockaddr_iso {
3074 pub _address: u8,
3075}
3076impl Clone for sockaddr_iso {
3077 fn clone(&self) -> Self { *self }
3078}
3079#[repr(C)]
3080#[derive(Copy)]
3081pub struct sockaddr_ns {
3082 pub _address: u8,
3083}
3084impl Clone for sockaddr_ns {
3085 fn clone(&self) -> Self { *self }
3086}
3087#[repr(C)]
3088#[derive(Copy)]
3089pub struct sockaddr_x25 {
3090 pub _address: u8,
3091}
3092impl Clone for sockaddr_x25 {
3093 fn clone(&self) -> Self { *self }
3094}
3095#[repr(C)]
3096#[derive(Copy)]
3097pub struct snmp_internal_session {
3098 pub _address: u8,
3099}
3100impl Clone for snmp_internal_session {
3101 fn clone(&self) -> Self { *self }
3102}