unit-1.26.1/src/nxt_process_title.c

/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) NGINX, Inc.
 */

#include <nxt_main.h>


/* The arguments passed to main(). */
char  **nxt_process_argv;

/*
 * MacOSX environ(7):
 *
 *   Shared libraries and bundles don't have direct access to environ,
 *   which is only available to the loader ld(1) when a complete program
 *   is being linked.
 *
 * So nxt_process_environ contains an address of environ to allow
 * change environ[] placement.
 */
char  ***nxt_process_environ;


#if (NXT_SETPROCTITLE_ARGV)

/*
 * A process title on Linux, Solaris, and MacOSX can be changed by
 * copying a new title to a place where the program argument argv[0]
 * points originally to.  However, the argv[0] may be too small to hold
 * the new title.  Fortunately, these OSes place the program argument
 * argv[] strings and the environment environ[] strings contiguously
 * and their space can be used for the long new process title.
 *
 * Solaris "ps" command shows the new title only if it is run in
 * UCB mode: either "/usr/ucb/ps -axwww" or "/usr/bin/ps axwww".
 */


static u_char  *nxt_process_title_start;
static u_char  *nxt_process_title_end;


void
nxt_process_arguments(nxt_task_t *task, char **orig_argv, char ***orig_envp)
{
    u_char      *p, *end, *argv_end, **argv, **env;
    size_t      size, argv_size, environ_size, strings_size;
    nxt_uint_t  i;

    nxt_process_argv = orig_argv;
    nxt_process_environ = orig_envp;

    if (orig_envp == NULL) {
        return;
    }

    /*
     * Set a conservative title space for a case if program argument
     * strings and environment strings are not contiguous.
     */
    argv = (u_char **) orig_argv;
    nxt_process_title_start = argv[0];
    nxt_process_title_end = argv[0] + nxt_strlen(argv[0]);

    end = argv[0];
    strings_size = 0;
    argv_size = sizeof(void *);

    for (i = 0; argv[i] != NULL; i++) {
        argv_size += sizeof(void *);

        if (argv[i] == end) {
            /* Argument strings are contiguous. */
            size = nxt_strlen(argv[i]) + 1;
            strings_size += size;
            end = argv[i] + size;
        }
    }

    argv = nxt_malloc(argv_size);
    if (argv == NULL) {
        return;
    }

    /*
     * Copy the entire original argv[] array.  The elements of this array
     * can point to copied strings or if original argument strings are not
     * contiguous, to the original argument strings.
     */
    nxt_memcpy(argv, orig_argv, argv_size);

    /*
     * The argv[1] must be set to NULL on Solaris otherwise the "ps"
     * command outputs strings pointed by original argv[] elements.
     * The original argv[] array has always at least two elements so
     * it is safe to set argv[1].
     */
    orig_argv[1] = NULL;

    nxt_process_argv = (char **) argv;

    argv_end = end;
    env = (u_char **) *orig_envp;
    environ_size = sizeof(void *);

    for (i = 0; env[i] != NULL; i++) {
        environ_size += sizeof(void *);

        if (env[i] == end) {
            /* Environment strings are contiguous. */
            size = nxt_strlen(env[i]) + 1;
            strings_size += size;
            end = env[i] + size;
        }
    }

    p = nxt_malloc(strings_size);
    if (p == NULL) {
        return;
    }

    if (argv_end == end) {
        /*
         * There is no reason to modify environ if arguments
         * and environment are not contiguous.
         */
        nxt_debug(task, "arguments and environment are not contiguous");
        goto done;
    }

    end = argv[0];

    for (i = 0; argv[i] != NULL; i++) {

        if (argv[i] != end) {
            /* Argument strings are not contiguous. */
            goto done;
        }

        size = nxt_strlen(argv[i]) + 1;
        nxt_memcpy(p, argv[i], size);

        end = argv[i] + size;
        argv[i] = p;
        p += size;
    }

    env = nxt_malloc(environ_size);
    if (env == NULL) {
        return;
    }

    /*
     * Copy the entire original environ[] array.  The elements of
     * this array can point to copied strings or if original environ
     * strings are not contiguous, to the original environ strings.
     */
    nxt_memcpy(env, *orig_envp, environ_size);

    /* Set the global environ variable to the new array. */
    *orig_envp = (char **) env;

    for (i = 0; env[i] != NULL; i++) {

        if (env[i] != end) {
            /* Environment strings are not contiguous. */
            goto done;
        }

        size = nxt_strlen(env[i]) + 1;
        nxt_memcpy(p, env[i], size);

        end = env[i] + size;
        env[i] = p;
        p += size;
    }

done:

    /* Preserve space for the trailing zero. */
    end--;

    nxt_process_title_end = end;
}


void
nxt_process_title(nxt_task_t *task, const char *fmt, ...)
{
    u_char   *p, *start, *end;
    va_list  args;

    start = nxt_process_title_start;

    if (start == NULL) {
        return;
    }

    end = nxt_process_title_end;

    va_start(args, fmt);
    p = nxt_vsprintf(start, end, fmt, args);
    va_end(args);

#if (NXT_SOLARIS)
    /*
     * Solaris "ps" command shows a new process title only if it is
     * longer than original command line.  A simple workaround is just
     * to append the original command line in parenthesis to the title.
     */
    {
        size_t      size;
        nxt_uint_t  i;

        size = 0;

        for (i = 0; nxt_process_argv[i] != NULL; i++) {
            size += nxt_strlen(nxt_process_argv[i]);
        }

        if (size > (size_t) (p - start)) {

            p = nxt_sprintf(p, end, " (");

            for (i = 0; nxt_process_argv[i] != NULL; i++) {
                p = nxt_sprintf(p, end, "%s ", nxt_process_argv[i]);
            }

            if (*(p - 1) == ' ') {
                *(p - 1) = ')';
            }
        }
    }
#endif

    /*
     * A process title must be padded with zeros on MacOSX.  Otherwise
     * the "ps" command may output parts of environment strings.
     */
    nxt_memset(p, '\0', end - p);

    nxt_debug(task, "setproctitle: \"%s\"", start);
}

#else /* !(NXT_SETPROCTITLE_ARGV) */

void
nxt_process_arguments(nxt_task_t *task, char **orig_argv, char ***orig_envp)
{
    nxt_process_argv = orig_argv;
    nxt_process_environ = orig_envp;
}

#endif