int
sg_warn(const char *prefix)
{
sg_error_details err_det;
char *errmsg = NULL;
int rc;
sg_error errc;
if( SG_ERROR_NONE != ( errc = sg_get_error_details(&err_det) ) ) {
fprintf(stderr, "can't get error details (%d, %s)\n", errc, sg_str_error(errc));
return 0;
}
if( NULL == sg_strperror(&errmsg, &err_det) ) {
errc = sg_get_error();
fprintf(stderr, "panic: can't prepare error message (%d, %s)\n", errc, sg_str_error(errc));
return 0;
}
rc = fprintf( stderr, "%s: %s\n", prefix, errmsg );
free( errmsg );
return rc;
}
static int do_init(void) {
#if HAVE_SETLOCALE
if (setlocale(LC_NUMERIC, COLLECTD_LOCALE) == NULL)
WARNING("setlocale (\"%s\") failed.", COLLECTD_LOCALE);
/* Update the environment, so that libraries that are calling
* setlocale(LC_NUMERIC, "") don't accidentally revert these changes. */
unsetenv("LC_ALL");
setenv("LC_NUMERIC", COLLECTD_LOCALE, /* overwrite = */ 1);
#endif
#if HAVE_LIBKSTAT
kc = NULL;
update_kstat();
#endif
#if HAVE_LIBSTATGRAB
if (sg_init(
#if HAVE_LIBSTATGRAB_0_90
0
#endif
)) {
ERROR("sg_init: %s", sg_str_error(sg_get_error()));
return -1;
}
if (sg_drop_privileges()) {
ERROR("sg_drop_privileges: %s", sg_str_error(sg_get_error()));
return -1;
}
#endif
return plugin_init_all();
} /* int do_init () */
static void
sg_die(const char *prefix, int exit_code)
{
sg_error_details err_det;
char *errmsg = NULL;
sg_error errc;
if( SG_ERROR_NONE != ( errc = sg_get_error_details(&err_det) ) ) {
fprintf(stderr, "panic: can't get error details (%d, %s)\n", errc, sg_str_error(errc));
exit(exit_code);
}
if( NULL == sg_strperror(&errmsg, &err_det) ) {
errc = sg_get_error();
fprintf(stderr, "panic: can't prepare error message (%d, %s)\n", errc, sg_str_error(errc));
exit(exit_code);
}
fprintf( stderr, "%s: %s\n", prefix, errmsg );
free( errmsg );
exit(exit_code);
}
bool
DataSourceStatgrab::ShutdownStatgrab()
{
if( SG_ERROR_NONE != sg_shutdown() )
{
LOG_BEGIN(loggerModuleName, ERROR_LOG | 0);
LOG("ShutdownDataSourceStatgrab(): sg_shutdown() failed");
LOG(sg_str_error(sg_get_error()));
LOG(sg_get_error_arg());
LOG_END;
return false;
}
return true;
}
void
DataSourceStatgrab::report_sg_error(string const &who, string const &what)
{
sg_error_details err_det;
char *errmsg = NULL;
sg_error errc;
if( SG_ERROR_NONE != ( errc = sg_get_error_details(&err_det) ) )
{
LOG_BEGIN( loggerModuleName, ERROR_LOG | 1 );
LOG( string( string("report_sg_error(") + who + ", " + what + "): can't get error details - " + sg_str_error(errc) ).c_str() );
LOG_END;
return;
}
if( NULL == sg_strperror(&errmsg, &err_det) )
{
errc = sg_get_error();
LOG_BEGIN( loggerModuleName, ERROR_LOG | 1 );
LOG( string( string("report_sg_error(") + who + ", " + what + "): can't prepare error message - " + sg_str_error(errc) ).c_str() );
LOG_END;
return;
}
LOG_BEGIN( loggerModuleName, ERROR_LOG | 1 );
if( errmsg )
{
LOG( string( who + ": " + what + " - " + errmsg ).c_str() );
}
else
{
LOG( string( who + ": " + what + " - " + sg_str_error( sg_get_error() ) + " - unknown details" ).c_str() );
}
LOG_END;
free( errmsg );
return;
}
int main(int argc, char **argv){
int c;
int colouron = 0;
char *fslist = NULL;
time_t last_update = 0;
extern int errno;
int delay=2;
sg_log_init("saidar", "SAIDAR_LOG_PROPERTIES", argc ? argv[0] : NULL);
sg_init(1);
if(sg_drop_privileges() != 0){
fprintf(stderr, "Failed to drop setuid/setgid privileges\n");
return 1;
}
#ifdef COLOR_SUPPORT
while ((c = getopt(argc, argv, "d:F:cvh")) != -1){
#else
while ((c = getopt(argc, argv, "d:F:vh")) != -1){
#endif
switch (c){
case 'd':
delay = atoi(optarg);
if (delay < 1){
fprintf(stderr, "Time must be 1 second or greater\n");
exit(1);
}
break;
#ifdef COLOR_SUPPORT
case 'c':
colouron = 1;
break;
#endif
case 'v':
version_num(argv[0]);
break;
case 'h':
default:
usage(argv[0]);
return 1;
}
}
if (fslist) {
sg_error rc = set_valid_filesystems(fslist);
if(rc != SG_ERROR_NONE)
die(sg_str_error(rc));
free(fslist);
}
else {
sg_error rc = set_valid_filesystems("!nfs, nfs3, nfs4, cifs, smbfs, samba, autofs");
if(rc != SG_ERROR_NONE)
die(sg_str_error(rc));
}
signal(SIGWINCH, sig_winch_handler);
initscr();
#ifdef COLOR_SUPPORT
/* turn on colour */
if (colouron) {
if (has_colors()) {
start_color();
use_default_colors();
init_pair(1,COLOR_RED,-1);
init_pair(2,COLOR_GREEN,-1);
init_pair(3,COLOR_YELLOW,-1);
init_pair(4,COLOR_BLUE,-1);
init_pair(5,COLOR_MAGENTA,-1);
init_pair(6,COLOR_CYAN,-1);
} else {
fprintf(stderr, "Colour support disabled: your terminal does not support colour.");
colouron = 0;
}
}
#endif
nonl();
curs_set(0);
cbreak();
noecho();
timeout(delay * 1000);
newwin(0, 0, 0, 0);
clear();
if(!get_stats()){
fprintf(stderr, "Failed to get all the stats. Please check correct permissions\n");
endwin();
return 1;
}
display_headings();
for(;;){
time_t now;
int ch = getch();
if (ch == 'q'){
break;
}
/* To keep the numbers slightly accurate we do not want them
* updating more frequently than once a second.
*/
now = time(NULL);
if ((now - last_update) >= 1) {
get_stats();
}
last_update = now;
if(sig_winch_flag) {
clear();
display_headings();
sig_winch_flag = 0;
}
display_data(colouron);
}
endwin();
sg_shutdown();
return 0;
}
/*
* Get the latest error from statgrab and, if there is one,
* raise the corresponding Ruby exception with the error message.
* Only used internally.
*/
static void
statgrab_handle_error(void)
{
sg_error err_num;
err_num = sg_get_error();
switch(err_num) {
case SG_ERROR_NONE:
return;
case SG_ERROR_ASPRINTF:
rb_raise(eStatgrabAsprintfError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_DEVICES:
rb_raise(eStatgrabDevicesError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_DEVSTAT_GETDEVS:
rb_raise(eStatgrabDevstatGetdevsError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_DEVSTAT_SELECTDEVS:
rb_raise(eStatgrabDevstatSelectdevsError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_DISKINFO:
rb_raise(eStatgrabDiskinfoError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_ENOENT:
rb_raise(eStatgrabEnoentError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_GETIFADDRS:
rb_raise(eStatgrabGetifaddrsError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_GETMNTINFO:
rb_raise(eStatgrabGetmntinfoError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_GETPAGESIZE:
rb_raise(eStatgrabGetpagesizeError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_HOST:
rb_raise(eStatgrabHostError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_KSTAT_DATA_LOOKUP:
rb_raise(eStatgrabKstatDataLookupError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_KSTAT_LOOKUP:
rb_raise(eStatgrabKstatLookupError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_KSTAT_OPEN:
rb_raise(eStatgrabKstatOpenError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_KSTAT_READ:
rb_raise(eStatgrabKstatReadError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_KVM_GETSWAPINFO:
rb_raise(eStatgrabKvmGetswapinfoError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_KVM_OPENFILES:
rb_raise(eStatgrabKvmOpenfilesError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_MALLOC:
rb_raise(eStatgrabMallocError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_MEMSTATUS:
rb_raise(eStatgrabMemstatusError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_OPEN:
rb_raise(eStatgrabOpenError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_OPENDIR:
rb_raise(eStatgrabOpendirError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_PARSE:
rb_raise(eStatgrabParseError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_PDHADD:
rb_raise(eStatgrabPdhaddError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_PDHCOLLECT:
rb_raise(eStatgrabPdhcollectError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_PDHOPEN:
rb_raise(eStatgrabPdhopenError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_PDHREAD:
rb_raise(eStatgrabPdhreadError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_PERMISSION:
rb_raise(eStatgrabPermissionError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_PSTAT:
rb_raise(eStatgrabPstatError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_SETEGID:
rb_raise(eStatgrabSetegidError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_SETEUID:
rb_raise(eStatgrabSeteuidError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_SETMNTENT:
rb_raise(eStatgrabSetmntentError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_SOCKET:
rb_raise(eStatgrabSocketError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_SWAPCTL:
rb_raise(eStatgrabSwapctlError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_SYSCONF:
rb_raise(eStatgrabSysconfError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_SYSCTL:
rb_raise(eStatgrabSysctlError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_SYSCTLBYNAME:
rb_raise(eStatgrabSysctlbynameError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_SYSCTLNAMETOMIB:
rb_raise(eStatgrabSysctlnametomibError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_UNAME:
rb_raise(eStatgrabUnameError, "%s", sg_str_error(err_num));
break;
case SG_ERROR_UNSUPPORTED:
rb_raise(eStatgrabUnsupportedError, "%s",
sg_str_error(err_num));
break;
case SG_ERROR_XSW_VER_MISMATCH:
rb_raise(eStatgrabXswVerMismatchError, "%s",
sg_str_error(err_num));
break;
}
}
char *
sg_strperror(char **buf, const sg_error_details * const err_details) {
#ifdef HAVE_STRERROR_R
char errno_buf[128] = { '\0' };
#endif
char *errno_msg = NULL;
sg_error_details err_det;
if((NULL == buf) || (NULL != *buf)) {
sg_set_error_int(SG_ERROR_INVALID_ARGUMENT, 0, "strperror", empty_ap);
return NULL;
}
if(NULL == err_details) {
sg_get_error_details(&err_det);
}
else {
err_det = *err_details;
}
if( NULL != (*buf = malloc(SG_STRPERROR_BUF_SIZE)) ) {
if(err_det.errno_value) {
#ifdef HAVE_STRERROR_R
# ifdef STRERROR_R_RETURN_INT
int rc;
# else
char *rc;
# endif
rc = strerror_r(err_det.errno_value, errno_buf, sizeof(errno_buf));
# ifdef STRERROR_R_RETURN_INT
if(0 != rc)
# else
if(NULL == rc)
# endif
{
sg_set_error_int(SG_ERROR_MALLOC, errno, "strerror_r", empty_ap);
free(*buf);
*buf = NULL;
return NULL;
}
else {
# ifdef STRERROR_R_RETURN_INT
errno_msg = errno_buf;
# else
errno_msg = rc;
# endif
}
#else
errno_msg = strerror(errno);
#endif
}
snprintf( *buf, SG_STRPERROR_BUF_SIZE, "%s (%s%s%s)",
sg_str_error(err_det.error),
err_det.errno_value ? errno_msg : "",
err_det.errno_value ? ": " : "",
err_det.error_arg ? err_det.error_arg : "" );
}
else {
sg_set_error_int(SG_ERROR_MALLOC, 0, "sg_strperror", empty_ap);
}
return *buf;
}
