hookinfo.h

   1 /**
   2  * Conversion table to encode and decode data-structs sent from
   3  * Nagios to event broker modules.
   4  *
   5  * To add more checks here, first go check in nagios/include/nebcallbacks.h
   6  * to figure out the thing you want to add stuff to. Then find the
   7  * corresponding data struct in nagios/include/nebstructs.h and add the
   8  * necessary info.
   9  *
  10  * 'strings' is the number of dynamic strings (char *)
  11  * 'offset' is 'sizeof(nebstruct_something_data)'
  12  * 'ptrs[]' are the offsets of each char *. use the offsetof() macro
  13  */
  14 #ifndef INCLUDE_hookinfo_h__
  15 #define INCLUDE_hookinfo_h__
  16
  17 #include "shared.h"
  18
  19 static struct hook_info_struct {
  20         int cb_type;
  21         int strings;
  22         off_t offset, ptrs[7];
  23 } hook_info[NEBCALLBACK_NUMITEMS] = {
  24         { NEBCALLBACK_PROCESS_DATA, 0, sizeof(nebstruct_process_data),
  25                 { 0, 0, 0, 0, 0 },
  26         },
  27         { NEBCALLBACK_TIMED_EVENT_DATA, 0, sizeof(nebstruct_timed_event_data),
  28                 { 0, 0, 0, 0, 0 },
  29         },
  30         { NEBCALLBACK_LOG_DATA, 1, sizeof(nebstruct_log_data),
  31                 {
  32                         offsetof(nebstruct_log_data, data),
  33                         0, 0, 0, 0
  34                 },
  35         },
  36         { NEBCALLBACK_SYSTEM_COMMAND_DATA, 2, sizeof(nebstruct_system_command_data),
  37                 {
  38                         offsetof(nebstruct_system_command_data, command_line),
  39                         offsetof(nebstruct_system_command_data, output),
  40                         0, 0, 0
  41                 },
  42         },
  43         { NEBCALLBACK_EVENT_HANDLER_DATA, 4, sizeof(nebstruct_event_handler_data),
  44                 {
  45                         offsetof(nebstruct_event_handler_data, host_name),
  46                         offsetof(nebstruct_event_handler_data, service_description),
  47                         offsetof(nebstruct_event_handler_data, command_line),
  48                         offsetof(nebstruct_event_handler_data, output),
  49                         0
  50                 },
  51         },
  52         { NEBCALLBACK_NOTIFICATION_DATA, 5, sizeof(nebstruct_notification_data),
  53                 {
  54                         offsetof(nebstruct_notification_data, host_name),
  55                         offsetof(nebstruct_notification_data, service_description),
  56                         offsetof(nebstruct_notification_data, output),
  57                         offsetof(nebstruct_notification_data, ack_author),
  58                         offsetof(nebstruct_notification_data, ack_data),
  59                 },
  60         },
  61         { NEBCALLBACK_SERVICE_CHECK_DATA, 5, sizeof(merlin_service_status),
  62                 {
  63                         offsetof(merlin_service_status, host_name),
  64                         offsetof(merlin_service_status, service_description),
  65                         offsetof(merlin_service_status, state.plugin_output),
  66                         offsetof(merlin_service_status, state.long_plugin_output),
  67                         offsetof(merlin_service_status, state.perf_data),
  68                 }
  69         },
  70         { NEBCALLBACK_HOST_CHECK_DATA, 4, sizeof(merlin_host_status),
  71                 {
  72                         offsetof(merlin_host_status, name),
  73                         offsetof(merlin_host_status, state.plugin_output),
  74                         offsetof(merlin_host_status, state.long_plugin_output),
  75                         offsetof(merlin_host_status, state.perf_data),
  76                         0
  77                 },
  78         },
  79         { NEBCALLBACK_COMMENT_DATA, 4, sizeof(nebstruct_comment_data),
  80                 {
  81                         offsetof(nebstruct_comment_data, host_name),
  82                         offsetof(nebstruct_comment_data, service_description),
  83                         offsetof(nebstruct_comment_data, author_name),
  84                         offsetof(nebstruct_comment_data, comment_data),
  85                         0,
  86                 },
  87         },
  88         { NEBCALLBACK_DOWNTIME_DATA, 4, sizeof(nebstruct_downtime_data),
  89                 {
  90                         offsetof(nebstruct_downtime_data, host_name),
  91                         offsetof(nebstruct_downtime_data, service_description),
  92                         offsetof(nebstruct_downtime_data, author_name),
  93                         offsetof(nebstruct_downtime_data, comment_data),
  94                         0,
  95                 },
  96         },
  97         { NEBCALLBACK_FLAPPING_DATA, 2, sizeof(nebstruct_flapping_data),
  98                 {
  99                         offsetof(nebstruct_flapping_data, host_name),
 100                         offsetof(nebstruct_flapping_data, service_description),
 101                         0, 0, 0
 102                 },
 103         },
 104         { NEBCALLBACK_PROGRAM_STATUS_DATA, 2, sizeof(nebstruct_program_status_data),
 105                 {
 106                         offsetof(nebstruct_program_status_data, global_host_event_handler),
 107                         offsetof(nebstruct_program_status_data, global_service_event_handler),
 108                         0, 0, 0
 109                 },
 110         },
 111         { NEBCALLBACK_HOST_STATUS_DATA, 4, sizeof(merlin_host_status),
 112                 {
 113                         offsetof(merlin_host_status, name),
 114                         offsetof(merlin_host_status, state.plugin_output),
 115                         offsetof(merlin_host_status, state.long_plugin_output),
 116                         offsetof(merlin_host_status, state.perf_data),
 117                         0
 118                 },
 119         },
 120         { NEBCALLBACK_SERVICE_STATUS_DATA, 5, sizeof(merlin_service_status),
 121                 {
 122                         offsetof(merlin_service_status, host_name),
 123                         offsetof(merlin_service_status, service_description),
 124                         offsetof(merlin_service_status, state.plugin_output),
 125                         offsetof(merlin_service_status, state.long_plugin_output),
 126                         offsetof(merlin_service_status, state.perf_data),
 127                 }
 128         },
 129         { NEBCALLBACK_ADAPTIVE_PROGRAM_DATA, 0, 0, { 0, 0, 0, 0, 0 }, },
 130         { NEBCALLBACK_ADAPTIVE_HOST_DATA, 0, 0, { 0, 0, 0, 0, 0 }, },
 131         { NEBCALLBACK_ADAPTIVE_SERVICE_DATA, 0, 0, { 0, 0, 0, 0, 0 }, },
 132         { NEBCALLBACK_EXTERNAL_COMMAND_DATA, 2, sizeof(nebstruct_external_command_data),
 133                 {
 134                         offsetof(nebstruct_external_command_data, command_string),
 135                         offsetof(nebstruct_external_command_data, command_args),
 136                         0, 0, 0
 137                 },
 138         },
 139         { NEBCALLBACK_AGGREGATED_STATUS_DATA, 0, 0, { 0, 0, 0, 0, 0 }, },
 140         { NEBCALLBACK_RETENTION_DATA, 0, 0, { 0, 0, 0, 0, 0 }, },
 141         { NEBCALLBACK_CONTACT_NOTIFICATION_DATA, 6, sizeof(nebstruct_contact_notification_data),
 142                 {
 143                         offsetof(nebstruct_contact_notification_data, host_name),
 144                         offsetof(nebstruct_contact_notification_data, service_description),
 145                         offsetof(nebstruct_contact_notification_data, contact_name),
 146                         offsetof(nebstruct_contact_notification_data, output),
 147                         offsetof(nebstruct_contact_notification_data, ack_author),
 148                         offsetof(nebstruct_contact_notification_data, ack_data),
 149                 },
 150         },
 151         { NEBCALLBACK_CONTACT_NOTIFICATION_METHOD_DATA, 7, sizeof(nebstruct_contact_notification_method_data),
 152                 {
 153                         offsetof(nebstruct_contact_notification_method_data, host_name),
 154                         offsetof(nebstruct_contact_notification_method_data, service_description),
 155                         offsetof(nebstruct_contact_notification_method_data, contact_name),
 156                         offsetof(nebstruct_contact_notification_method_data, command_name),
 157                         offsetof(nebstruct_contact_notification_method_data, output),
 158                         offsetof(nebstruct_contact_notification_method_data, ack_author),
 159                         offsetof(nebstruct_contact_notification_method_data, ack_data),
 160                 },
 161         },
 162         { NEBCALLBACK_ACKNOWLEDGEMENT_DATA, 4, sizeof(nebstruct_acknowledgement_data),
 163                 {
 164                         offsetof(nebstruct_acknowledgement_data, host_name),
 165                         offsetof(nebstruct_acknowledgement_data, service_description),
 166                         offsetof(nebstruct_acknowledgement_data, author_name),
 167                         offsetof(nebstruct_acknowledgement_data, comment_data),
 168                         0
 169                 },
 170         },
 171         { NEBCALLBACK_STATE_CHANGE_DATA, 3, sizeof(nebstruct_statechange_data),
 172                 {
 173                         offsetof(nebstruct_statechange_data, host_name),
 174                         offsetof(nebstruct_statechange_data, service_description),
 175                         offsetof(nebstruct_statechange_data, output),
 176                         0, 0
 177                 },
 178         },
 179         { NEBCALLBACK_CONTACT_STATUS_DATA, 0, 0, { 0, 0, 0, 0, 0 }, },
 180         { NEBCALLBACK_ADAPTIVE_CONTACT_DATA, 0, 0, { 0, 0, 0, 0, 0 }, },
 181 };
 182
 183 #endif /* INCLUDE_hookinfo_h__ */