Sigar

/* sysconf(_SC_GET{PW,GR}_R_SIZE_MAX) */
#define R_SIZE_MAX 1024

int sigar_user_name_get(sigar_t *sigar, int uid, char *buf, int buflen)
{
    struct passwd *pw = NULL;
    /* XXX cache lookup */

# ifdef HAVE_GETPWUID_R
    struct passwd pwbuf;
    char buffer[R_SIZE_MAX];

    if (getpwuid_r(uid, &pwbuf, buffer, sizeof(buffer), &pw) != 0) {
        return errno;
    }
    if (!pw) {
        return ENOENT;
    }
# else
    if ((pw = getpwuid(uid)) == NULL) {
        return errno;
    }
# endif

    strncpy(buf, pw->pw_name, buflen);
    buf[buflen-1] = '\0';

    return SIGAR_OK;
}

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <pwd.h>
#include <grp.h>

#define R_SIZE_MAX 1024

int main(void) {

    struct passwd *pw = NULL;
    struct passwd pwbuf;
    char buffer[R_SIZE_MAX];

    // 600 is a userid
    if (getpwuid_r(600, &pwbuf, buffer, sizeof(buffer), &pw) != 0) {
        return errno;
    }
    if (!pw) {
        return ENOENT;
    }

    puts (pw->pw_name);

    return EXIT_SUCCESS;
}

          struct hostent *
          gethostname (char *host)
          {
            struct hostent hostbuf, *hp;
            size_t hstbuflen;
            char *tmphstbuf;
            int res;
            int herr;
          
            hstbuflen = 1024;
            /* Allocate buffer, remember to free it to avoid memory leakage.  */
            tmphstbuf = malloc (hstbuflen);
          
            while ((res = gethostbyname_r (host, &hostbuf, tmphstbuf, hstbuflen,
                                           &hp, &herr)) == ERANGE)
              {
                /* Enlarge the buffer.  */
                hstbuflen *= 2;
                tmphstbuf = realloc (tmphstbuf, hstbuflen);
              }
            /*  Check for errors.  */
            if (res || hp == NULL)
              return NULL;
            return hp;
          }

// Copyright 2013 Free Software Foundation, Inc.
// Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.

SigarAccess

SigarAccess is an RHQ utility class. It creates:

• a unique instance of Sigar

• a proxy to this instance, implementing the SigarProxy interface

• an invocation handler which serializes calls to the shared Sigar instance

Any RHQ plugin class which needs system or process information should get the SigarProxy from SigarAccess (SigarAccess.getSigar method). This guarantees that RHQ agent will not waste/leak resources and that two threads will not concurrently call the same Sigar instance.

The invocation handler uses a lock to serialize calls. If a thread waits more than sharedSigarLockMaxWait seconds, it will be given a new Sigar instance, which will be destroyed at the end of the call. Every 5 minutes, a background task checks that localSigarInstancesWarningThreshold has not been exceeded. It it has, a warning message will be logged, optionally with a thread dump.

The invocation handler behavior is configurable with System properties:

• sharedSigarLockMaxWait: maximum time in seconds a thread will wait for the shared Sigar lock acquisition; defaults to 2 seconds

• localSigarInstancesWarningThreshold: threshold of currently living Sigar instances at which the background task will print warning messages; defaults to 50

• maxLocalSigarInstances: maximum number of local Sigar instances which can be created, zero and negative values being interpreted as 'no limit'; defaults to 50

• threadDumpOnlocalSigarInstancesWarningThreshold: if set to true (case insensitive), the background task will also log a thread dump when localSigarInstancesWarningThreshold is met

ProcessInfo

ProcessInfo encapsulates information about a known process and behaves like a cache which can be refreshed.

A few process properties (i.e. PID, command line) will never change during the lifetime of the process and can be read directly with ProcessInfo accessors. Other process properties (i.e. state, CPU usage) will vary and their values are grouped in ProcessInfoSnapshot class instances.

New snapshots of changing data will be taken when calling ProcessInfo.freshSnapshot or ProcessInfo.refresh methods.