int get_value_simple(DC_ITEM *item, AGENT_RESULT *result)
{
const char *__function_name = "get_value_simple";
AGENT_REQUEST request;
vmfunc_t vmfunc;
int ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s' addr:'%s'",
__function_name, item->key_orig, item->interface.addr);
init_request(&request);
parse_item_key(item->key, &request);
request.lastlogsize = item->lastlogsize;
if (0 == strcmp(request.key, "net.tcp.service"))
{
if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 0))
ret = SUCCEED;
}
else if (0 == strcmp(request.key, "net.tcp.service.perf"))
{
if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 1))
ret = SUCCEED;
}
else if (SUCCEED == get_vmware_function(request.key, &vmfunc))
{
if (NULL != vmfunc)
{
if (SYSINFO_RET_OK == vmfunc(&request, item->username, item->password, result))
ret = SUCCEED;
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for VMware checks was not compiled in."));
}
else
{
/* it will execute item from a loadable module if any */
if (SUCCEED == process(item->key, PROCESS_MODULE_COMMAND, result))
ret = SUCCEED;
}
if (NOTSUPPORTED == ret && !ISSET_MSG(result))
SET_MSG_RESULT(result, zbx_strdup(NULL, "Simple check is not supported."));
free_request(&request);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
void
hc_monitor_services(hc_list_opaque_t *errors)
{
hc_tree_opaque_t *services = NULL;
services = hc_scheduler_get_services();
check_service(services, errors);
}
int main(int argc, char* argv[])
{
// 初始化 acl 库
acl::acl_cpp_init();
bool tcp_mode = check_service(argc, argv);
if (tcp_mode)
run_tcp_service(argc, argv);
else
run_udp_service(argc, argv);
return 0;
}
/**
* Handle the action for all processes in service list
* @param action A string describing the action to execute
*/
void control(const char *action) {
Service_T s;
ASSERT(action);
for(s= servicelist; s; s= s->next) {
if(s->visited)
continue;
if(exist_daemon()) {
d_check_service(s->name, action);
} else {
check_service(s->name, action);
}
}
reset_depend();
}
/*
* Handle the action for a specified process
* @param P process name
* @param action A string describing the action to execute
*/
void control_process(const char *P, const char *action) {
Service_T s;
ASSERT(P);
ASSERT(action);
if(NULL==(s= get_service(P))) {
log("%s: Cannot %s program '%s' -- not found in %s\n",
prog, action, P, Run.controlfile);
return;
}
if(exist_daemon()) {
d_check_service(P, action);
} else {
check_service(P, action);
}
}
int CHECK_SERVICE_PERF(AGENT_REQUEST *request, AGENT_RESULT *result)
{
return check_service(request, "127.0.0.1", result, 1);
}
/* Registers the call-back and configures the actions in case of a failure
* with the Windows services manager. */
void
service_start(int *argcp, char **argvp[])
{
int argc = *argcp;
char **argv = *argvp;
int i;
SERVICE_TABLE_ENTRY service_table[] = {
{(LPTSTR)program_name, (LPSERVICE_MAIN_FUNCTION)main},
{NULL, NULL}
};
/* 'detached' is 'false' when service_start() is called the first time.
* It is 'true', when it is called the second time by the Windows services
* manager. */
if (detached) {
init_service_status();
wevent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!wevent) {
char *msg_buf = ovs_lasterror_to_string();
VLOG_FATAL("Failed to create a event (%s).", msg_buf);
}
poll_fd_wait_event(0, wevent, POLLIN);
/* Register the control handler. This function is called by the service
* manager to stop the service. */
hstatus = RegisterServiceCtrlHandler(program_name,
(LPHANDLER_FUNCTION)control_handler);
if (!hstatus) {
char *msg_buf = ovs_lasterror_to_string();
VLOG_FATAL("Failed to register the service control handler (%s).",
msg_buf);
}
if (monitor) {
set_config_failure_actions();
}
/* When the service control manager does the call back, it does not
* send the same arguments as sent to the main function during the
* service start. So, use the arguments passed over during the first
* time. */
*argcp = sargc;
*argvp = *sargvp;
/* XXX: Windows implementation cannot have a unixctl commands in the
* traditional sense of unix domain sockets. If an implementation is
* done that involves 'unixctl' vlog commands the following call is
* needed to make sure that the unixctl commands for vlog get
* registered in a daemon, even before the first log message. */
vlog_init();
return;
}
assert_single_threaded();
/* A reference to arguments passed to the main function the first time.
* We need it after the call-back from service control manager. */
sargc = argc;
sargvp = argvp;
/* We are only interested in the '--service' and '--service-monitor'
* options before the call-back from the service control manager. */
for (i = 0; i < argc; i ++) {
if (!strcmp(argv[i], "--service")) {
detach = true;
} else if (!strcmp(argv[i], "--service-monitor")) {
monitor = true;
}
}
/* If '--service' is not a command line option, run in foreground. */
if (!detach) {
return;
}
/* If we have been configured to run as a service, then that service
* should already have been created either manually or through a start up
* script. */
check_service();
detached = true;
/* StartServiceCtrlDispatcher blocks and returns after the service is
* stopped. */
if (!StartServiceCtrlDispatcher(service_table)) {
char *msg_buf = ovs_lasterror_to_string();
VLOG_FATAL("Failed at StartServiceCtrlDispatcher (%s)", msg_buf);
}
exit(0);
}
static void
check_service(hc_tree_opaque_t *service_node,
hc_list_opaque_t *errors)
{
hc_service_t *service = NULL;
mb_state_t state, expected_state;
hc_tree_opaque_t *node = NULL;
int error = 0;
hc_error_t *error_report = NULL;
struct timeval now, last_heartbeat;
service = (hc_service_t*)hc_tree_get_datas(service_node);
if (!error) {
if (service->mailbox_id == MB_INVALID_ID) {
error = 1;
}
}
/* Get the current state of the service */
if (!error) {
if (mb_getstate(service->mailbox_id, &state) != MB_OK) {
cm_trace(CM_TRACE_LEVEL_ERROR,
"Couldn't get the state of service %s",
service->start_cmd);
error = 1;
}
}
/* Check the heartbeat value and put the service DISABLED if needed */
if (!error) {
if ((state != SRV_READY)
&& (state != SRV_RUNNING)) {
/* The service is not in a state to check its heartbeat */
error = 1;
}
if (!error) {
if (mb_gettimestamp(service->mailbox_id,
&last_heartbeat) != MB_OK) {
cm_trace(CM_TRACE_LEVEL_ERROR,
"mb_gettimestamp failed. Cannot check the last heartbeat for %s",
service->start_cmd);
error = 1;
}
}
if (!error) {
if (gettimeofday(&now, NULL)) {
cm_trace(CM_TRACE_LEVEL_ERROR,
"gettimeofday failed. Cannot check the last heartbeat for %s",
service->start_cmd);
error = 1;
}
}
if (!error) {
if (now.tv_sec - last_heartbeat.tv_sec > service->heartbeat) {
cm_trace(CM_TRACE_LEVEL_NOTICE,
"***** The service %s missed its heartbeat !!! Moving to the disable state *****",
service->start_cmd);
hc_sequence_disable_service(service);
}
}
error = 0;
}
/* Get the expected state */
if (!error) {
if (mb_getexpectedstate(service->mailbox_id, &expected_state) != MB_OK) {
cm_trace(CM_TRACE_LEVEL_ERROR,
"Failed to retrieve the states of %s",
service->start_cmd);
error = 1;
}
}
/* Check that the component is not DISABLED */
if ((!error)
&& (service->locked == 0)) {
if (state == SRV_DISABLED) {
/* cm_trace(CM_TRACE_LEVEL_NOTICE, */
/* "The service %s is in the DISABLED state", */
/* service->start_cmd); */
error_report = (hc_error_t*)malloc(sizeof(hc_error_t));
if (!error_report) {
cm_trace(CM_TRACE_LEVEL_ERROR,
"Cannot allocate memory to report the error");
error = 1;
}
if (!error) {
error_report->type = HC_ERROR_DISABLED_SERVICE;
error_report->service_node = service_node;
if (hc_list_add_element(errors,
error_report)) {
cm_trace(CM_TRACE_LEVEL_ERROR,
"Failed to add the error in the error queue");
hc_error_free(error_report);
error_report = NULL;
error = 1;
}
}
error = 1;
}
}
/* If the state change occured, release the waiting action */
if (!error) {
if (expected_state != SRV_INVALID) {
if ((state == expected_state)
&& (service->waiting_action_node)) {
/* The state transition occured */
hc_sequence_stop_waiting(NULL,
service->waiting_action_node,
1);
service->waiting_action_node = NULL;
}
}
}
/* Scan the children and brothers */
node = hc_tree_get_first_child(service_node);
if (node) {
check_service(node, errors);
}
node = hc_tree_get_next_brother(service_node);
if (node) {
check_service(node, errors);
}
}
int CHECK_SERVICE_PERF(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result)
{
return check_service(param, "127.0.0.1", result, 1);
}
int get_value_simple(DC_ITEM *item, AGENT_RESULT *result, zbx_vector_ptr_t *add_results)
{
AGENT_REQUEST request;
vmfunc_t vmfunc;
int ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s' addr:'%s'", __func__, item->key_orig, item->interface.addr);
init_request(&request);
if (SUCCEED != parse_item_key(item->key, &request))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid item key format."));
goto out;
}
request.lastlogsize = item->lastlogsize;
if (0 == strcmp(request.key, "net.tcp.service") || 0 == strcmp(request.key, "net.udp.service"))
{
if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 0))
ret = SUCCEED;
}
else if (0 == strcmp(request.key, "net.tcp.service.perf") || 0 == strcmp(request.key, "net.udp.service.perf"))
{
if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 1))
ret = SUCCEED;
}
else if (SUCCEED == get_vmware_function(request.key, &vmfunc))
{
if (NULL != vmfunc)
{
if (0 == get_process_type_forks(ZBX_PROCESS_TYPE_VMWARE))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "No \"vmware collector\" processes started."));
goto out;
}
if (SYSINFO_RET_OK == vmfunc(&request, item->username, item->password, result))
ret = SUCCEED;
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for VMware checks was not compiled in."));
}
else if (0 == strcmp(request.key, ZBX_VMWARE_PREFIX "eventlog"))
{
#if defined(HAVE_LIBXML2) && defined(HAVE_LIBCURL)
if (SYSINFO_RET_OK == check_vcenter_eventlog(&request, item, result, add_results))
ret = SUCCEED;
#else
ZBX_UNUSED(add_results);
SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for VMware checks was not compiled in."));
#endif
}
else
{
/* it will execute item from a loadable module if any */
if (SUCCEED == process(item->key, PROCESS_MODULE_COMMAND, result))
ret = SUCCEED;
}
if (NOTSUPPORTED == ret && !ISSET_MSG(result))
SET_MSG_RESULT(result, zbx_strdup(NULL, "Simple check is not supported."));
out:
free_request(&request);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __func__, zbx_result_string(ret));
return ret;
}
PAM_EXTERN int
pam_sm_acct_mgmt(pam_handle_t *pamh,
int flags,
int argc,
const char **argv)
{
struct options *opts;
FILE *fh;
char *username; /* username requesting access */
char *rhost; /* remote host */
char *srv; /* PAM service we're running as */
char buf[LINE_LENGTH];
int retval, action;
int is_v6 = 0;
struct locations *geo;
unsigned char gi_type;
GeoIP *gi = NULL;
#ifdef HAVE_GEOIP_010408
GeoIP *gi6 = NULL;
int is_city6_db = 0;
#endif
GeoIPRecord *rec = NULL;
opts = malloc(sizeof(struct options));
if (opts == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'opts': %m");
return PAM_SERVICE_ERR;
}
opts->charset = GEOIP_CHARSET_UTF8;
opts->debug = 0;
opts->action = PAM_PERM_DENIED;
opts->system_file = NULL;
opts->service_file = NULL;
opts->by_service = 0;
opts->geoip_db = NULL;
#ifdef HAVE_GEOIP_010408
opts->use_v6 = 0;
opts->v6_first = 0;
opts->geoip6_db = NULL;
#endif
opts->is_city_db = 0;
geo = malloc(sizeof(struct locations));
if (geo == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'geo': %m");
free_opts(opts);
return PAM_SERVICE_ERR;
}
geo->country = NULL;
geo->city = NULL;
geo->next = NULL;
_parse_args(pamh, argc, argv, opts);
if (opts->system_file == NULL)
opts->system_file = strdup(SYSTEM_FILE);
if (opts->system_file == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->system_file': %m");
free_opts(opts);
return PAM_SERVICE_ERR;
}
if (opts->geoip_db == NULL)
opts->geoip_db = strdup(GEOIPDB_FILE);
if (opts->geoip_db == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->geoip_db': %m");
free_opts(opts);
return PAM_SERVICE_ERR;
}
#ifdef HAVE_GEOIP_010408
if (opts->geoip6_db == NULL)
opts->geoip6_db = strdup(GEOIP6DB_FILE);
if (opts->geoip6_db == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'opts->geoip6_db': %m");
free_opts(opts);
return PAM_SERVICE_ERR;
}
#endif
retval = pam_get_item(pamh, PAM_USER, (void*) &username);
if (username == NULL || retval != PAM_SUCCESS) {
pam_syslog(pamh, LOG_CRIT, "error recovering username");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
retval = pam_get_item(pamh, PAM_RHOST, (void*) &rhost);
if (retval != PAM_SUCCESS) {
pam_syslog(pamh, LOG_CRIT, "error fetching rhost");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (rhost == NULL) {
pam_syslog(pamh, LOG_INFO, "rhost is NULL, allowing");
free_opts(opts);
free_locations(geo);
return PAM_SUCCESS;
}
retval = pam_get_item(pamh, PAM_SERVICE, (void*) &srv);
if (srv == NULL || retval != PAM_SUCCESS ) {
pam_syslog(pamh, LOG_CRIT, "error requesting service name");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
opts->service_file = malloc(PATH_MAX);
if (opts->service_file == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'service_file': %m");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (snprintf(opts->service_file, PATH_MAX-1, SERVICE_FILE, srv) < 0) {
pam_syslog(pamh, LOG_CRIT, "snprintf error 'service_file'");
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
gi = GeoIP_open(opts->geoip_db, GEOIP_INDEX_CACHE);
if (gi == NULL) {
pam_syslog(pamh, LOG_CRIT,
"failed to open geoip db (%s): %m", opts->geoip_db);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
gi_type = GeoIP_database_edition(gi);
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP edition: %d", gi_type);
switch (gi_type) {
case GEOIP_COUNTRY_EDITION:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: country");
opts->is_city_db = 0;
break;
case GEOIP_CITY_EDITION_REV0:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: city rev0");
opts->is_city_db = 1;
break;
case GEOIP_CITY_EDITION_REV1:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v4 edition: city rev1");
opts->is_city_db = 1;
break;
default:
pam_syslog(pamh, LOG_CRIT, "invalid GeoIP DB type `%d' found", gi_type);
GeoIP_delete(gi);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
GeoIP_set_charset(gi, opts->charset);
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP DB is City: %s",
opts->is_city_db ? "yes" : "no");
#ifdef HAVE_GEOIP_010408
if (opts->use_v6 != 0) {
gi6 = GeoIP_open(opts->geoip6_db, GEOIP_INDEX_CACHE);
if (gi6 == NULL) {
pam_syslog(pamh, LOG_CRIT,
"failed to open geoip6 db (%s): %m", opts->geoip6_db);
GeoIP_delete(gi);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
gi_type = GeoIP_database_edition(gi6);
switch (gi_type) {
case GEOIP_COUNTRY_EDITION_V6:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: country");
is_city6_db = 0;
break;
case GEOIP_CITY_EDITION_REV0_V6:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: city rev0");
is_city6_db = 1;
break;
case GEOIP_CITY_EDITION_REV1_V6:
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP v6 edition: city rev1");
is_city6_db = 1;
break;
default:
pam_syslog(pamh, LOG_CRIT, "invalid GeoIP DB type `%d' found", gi_type);
GeoIP_delete(gi);
GeoIP_delete(gi6);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP DB is City v6: %s",
is_city6_db ? "yes" : "no");
GeoIP_set_charset(gi6, opts->charset);
if (opts->is_city_db != is_city6_db) {
pam_syslog(pamh, LOG_CRIT, "IPv4 DB type is not the same as IPv6 (not both Country edition or both City edition)");
GeoIP_delete(gi);
GeoIP_delete(gi6);
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (opts->v6_first != 0) {
rec = GeoIP_record_by_name_v6(gi6, rhost);
if (rec == NULL) {
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "no IPv6 record for %s, trying IPv4", rhost);
rec = GeoIP_record_by_name(gi, rhost);
}
else
is_v6 = 1;
}
else {
rec = GeoIP_record_by_name(gi, rhost);
if (rec == NULL) {
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "no IPv4 record for %s, trying IPv6", rhost);
rec = GeoIP_record_by_name_v6(gi6, rhost);
if (rec != NULL)
is_v6 = 1;
}
}
}
else
#endif /* HAVE_GEOIP_010408 */
rec = GeoIP_record_by_name(gi, rhost);
if (rec == NULL) {
pam_syslog(pamh, LOG_INFO, "no record for %s, setting GeoIP to 'UNKNOWN,*'", rhost);
geo->city = strdup("*");
geo->country = strdup("UNKNOWN");
if (geo->city == NULL || geo->country == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'geo->{city,country}': %m");
GeoIP_delete(gi);
#ifdef HAVE_GEOIP_010408
GeoIP_delete(gi6);
#endif
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
}
else {
if (rec->city == NULL || opts->is_city_db == 0)
geo->city = strdup("*");
else
geo->city = strdup(rec->city);
if (rec->country_code == NULL)
geo->country = strdup("UNKNOWN");
else
geo->country = strdup(rec->country_code);
if (geo->city == NULL || geo->country == NULL) {
pam_syslog(pamh, LOG_CRIT, "malloc error 'geo->{city,country}': %m");
GeoIP_delete(gi);
#ifdef HAVE_GEOIP_010408
GeoIP_delete(gi6);
#endif
free_opts(opts);
free_locations(geo);
return PAM_SERVICE_ERR;
}
if (opts->is_city_db) {
geo->latitude = rec->latitude;
geo->longitude = rec->longitude;
}
}
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "GeoIP record for %s: %s,%s",
rhost, geo->country, geo->city);
if (opts->debug && strcmp(geo->country, "UNKNOWN") != 0 && opts->is_city_db)
pam_syslog(pamh, LOG_DEBUG, "GeoIP coordinates for %s: %f,%f",
rhost, geo->latitude, geo->longitude);
if ((fh = fopen(opts->service_file, "r")) != NULL) {
opts->by_service = 1;
if (opts->debug)
pam_syslog(pamh, LOG_DEBUG, "using services file %s",
opts->service_file);
}
else {
if ((fh = fopen(opts->system_file, "r")) == NULL) {
pam_syslog(pamh, LOG_CRIT, "error opening %s: %m", opts->system_file);
#ifdef HAVE_GEOIP_010408
if (gi6) GeoIP_delete(gi6);
#endif
if (gi) GeoIP_delete(gi);
if (rec) GeoIPRecord_delete(rec);
free_opts(opts);
return PAM_SERVICE_ERR;
}
}
action = opts->action;
char location[LINE_LENGTH];
while (fgets(buf, LINE_LENGTH, fh) != NULL) {
char *line, *ptr;
char domain[LINE_LENGTH],
service[LINE_LENGTH];
action = opts->action;
line = buf;
/* skip the leading white space */
while (*line && isspace(*line))
line++;
/* Rip off the comments */
ptr = strchr(line,'#');
if (ptr)
*ptr = '\0';
/* Rip off the newline char */
ptr = strchr(line,'\n');
if (ptr)
*ptr = '\0';
/* Anything left ? */
if (!strlen(line))
continue;
if (opts->by_service)
action = parse_line_srv(pamh, line, domain, location);
else
action = parse_line_sys(pamh, line, domain, service, location);
if (action < 0) { /* parsing failed */
action = opts->action;
continue;
}
if (!opts->by_service) {
if (!check_service(pamh, service, srv))
continue;
}
if ((strcmp(domain, "*") == 0) || (strcmp(username, domain) == 0)) {
if (check_location(pamh, opts, location, geo))
break;
}
else if (domain[0] == '@') {
if (pam_modutil_user_in_group_nam_nam(pamh, username, domain+1)) {
if (check_location(pamh, opts, location, geo))
break;
}
}
}
fclose(fh);
if (gi) GeoIP_delete(gi);
#ifdef HAVE_GEOIP_010408
if (gi6) GeoIP_delete(gi6);
#endif
if (rec) GeoIPRecord_delete(rec);
free_locations(geo);
switch (action) {
case PAM_SUCCESS:
pam_syslog(pamh, LOG_DEBUG, "location %s allowed for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4);
break;
case PAM_PERM_DENIED:
pam_syslog(pamh, LOG_DEBUG, "location %s denied for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4);
break;
case PAM_IGNORE:
pam_syslog(pamh, LOG_DEBUG, "location %s ignored for user %s from %s (IPv%d)", location, username, rhost, is_v6 ? 6 : 4);
break;
default: /* should not happen */
pam_syslog(pamh, LOG_DEBUG, "location status: %d, IPv%d", action, is_v6 ? 6 : 4);
break;
};
free_opts(opts);
return action;
}
