n_common.c

Go to the documentation of this file.

/*
 * Nilorea Library
 * Copyright (C) 2005-2026 Castagnier Mickael
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include "nilorea/n_common.h"
#include "nilorea/n_log.h"
#include "nilorea/n_str.h"
 
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <libgen.h>
 
#include "nilorea/n_windows.h"
#include <errno.h>
#include <strings.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#ifndef __windows__
#include <sys/wait.h>
#endif
 
void n_abort(char const* format, ...) {
    char str[1024] = "";
    va_list args;
    va_start(args, format);
 
    vsnprintf(str, sizeof str, format, args);
    va_end(args);
    fprintf(stderr, "%s", str);
    exit(1);
}
 
int get_computer_name(char* computer_name, size_t len) {
    if (!computer_name || len == 0) return FALSE;
    memset(computer_name, 0, len);
#ifdef WIN32
    TCHAR infoBuf[len];
    DWORD bufCharCount = (DWORD)len;
    if (GetComputerName(infoBuf, &bufCharCount)) {
        memcpy(computer_name, infoBuf, len);
    } else {
        strncpy(computer_name, "Unknown_Host_Name", len - 1);
        computer_name[len - 1] = '\0';
        return FALSE;
    }
#else
    if (gethostname(computer_name, len) == -1) {
        int error = errno;
        strncpy(computer_name, "Unknown_Host_Name", len - 1);
        computer_name[len - 1] = '\0';
        n_log(LOG_ERR, "%s on gethostname !", strerror(error));
        return FALSE;
    }
#endif
    return TRUE;
} /* get_computer_name */
 
int file_exist(const char* filename) {
    FILE* file = NULL;
    if ((file = fopen(filename, "r")) != NULL) {
        fclose(file);
        return 1;
    }
    return 0;
} /* file_exist */
 
char* get_prog_dir(void) {
    char strbuf[PATH_MAX] = "";
 
    int error = 0;
#ifdef __windows__
    unsigned long int bytes = GetModuleFileName(NULL, strbuf, PATH_MAX);
    error = errno;
    if (bytes != 0) {
        return strdup(dirname(strbuf));
    }
#else
    char procbuf[PATH_MAX] = "";
#ifdef __linux__
    snprintf(procbuf, PATH_MAX, "/proc/%d/exe", (int)getpid());
#elif defined __sun
    snprintf(procbuf, PATH_MAX, "/proc/%d/path/a.out", (int)getpid());
#endif
    ssize_t bytes = MIN(readlink(procbuf, strbuf, PATH_MAX), PATH_MAX - 1);
    error = errno;
    if (bytes >= 0) {
        strbuf[bytes] = '\0';
        return strdup(dirname(strbuf));
    }
#endif
    fprintf(stderr, "%s", strerror(error));
    return NULL;
} /* get_prog_dir */
 
char* get_prog_name(void) {
    char strbuf[PATH_MAX] = "";
    int error = 0;
#ifdef __windows__
    unsigned long int bytes = GetModuleFileName(NULL, strbuf, PATH_MAX);
    error = errno;
    if (bytes != 0) {
        return strdup(basename(strbuf));
    }
#else
    char procbuf[PATH_MAX] = "";
#ifdef __linux__
    snprintf(procbuf, PATH_MAX, "/proc/%d/exe", (int)getpid());
#elif defined __sun
    snprintf(procbuf, PATH_MAX, "/proc/%d/path/a.out", (int)getpid());
#endif
    ssize_t bytes = MIN(readlink(procbuf, strbuf, PATH_MAX), PATH_MAX - 1);
    error = errno;
    if (bytes >= 0) {
        strbuf[bytes] = '\0';
        return strdup(basename(strbuf));
    }
#endif
    fprintf(stderr, "%s", strerror(error));
    return NULL;
} /* get_prog_name */
 
int n_popen(char* cmd, size_t read_buf_size, void** nstr_output, int* ret) {
    __n_assert(cmd, return FALSE);
 
    if (read_buf_size > INT_MAX) {
        n_log(LOG_ERR, "read_buf_size buffer size is too large for fgets (%zu>%d)", read_buf_size, INT_MAX);
        return FALSE;
    }
    if (read_buf_size > 65536) {
        n_log(LOG_ERR, "read_buf_size %zu exceeds safe stack limit", read_buf_size);
        return FALSE;
    }
 
    N_STR* output_pointer = new_nstr(read_buf_size + 1);
 
    FILE* fp = NULL;
    int status = 0;
    char read_buf[read_buf_size];
 
    fp = popen(cmd, "r");
    int err = errno;
    if (fp == NULL) {
        n_log(LOG_ERR, "popen( %s ) returned NULL , %s (%d)", cmd, strerror(err), err);
        free_nstr(&output_pointer);
        return FALSE;
    }
    while (fgets(read_buf, (int)read_buf_size, fp) != NULL) {
        size_t length = strlen(read_buf);
        if (length > 0 && read_buf[length - 1] == '\n') {
            read_buf[length - 1] = '\0';
        }
        nstrprintf_cat(output_pointer, "%s", read_buf);
    }
    status = pclose(fp);
    err = errno;
    if (status == -1) {
        n_log(LOG_ERR, "pclose( %s ) returned -1 , %s (%d)", cmd, strerror(err), err);
        free_nstr(&output_pointer);
        return FALSE;
    }
    if (ret) (*ret) = WEXITSTATUS(status);
    if (nstr_output) {
        (*nstr_output) = output_pointer;
    } else {
        free_nstr(&output_pointer);
    }
    return TRUE;
} /* n_popen( ... ) */
 
void log_environment(int loglevel) {
#if defined(_WIN32) || defined(__MINGW32__) || defined(__windows__)
    LPCH env_block = GetEnvironmentStrings();
    if (!env_block) return;
    for (LPCH var = env_block; *var != '\0'; var += strlen(var) + 1) {
        n_log(loglevel, "env: %s", var);
    }
    FreeEnvironmentStrings(env_block);
#else
    extern char** environ;
    for (char** env = environ; *env != NULL; env++) {
        n_log(loglevel, "env: %s", *env);
    }
#endif
}
 
#ifndef __windows__
void sigchld_handler(int sig) {
    // waitpid() might overwrite errno, so we save and restore it:
    int saved_errno = errno;
 
    while (waitpid(-1, NULL, WNOHANG) > 0);
 
    errno = saved_errno;
    n_log(LOG_DEBUG, "Signal %d", sig);
}
 
int sigchld_handler_installer() {
    struct sigaction sa;
    sa.sa_handler = sigchld_handler;  // reap all dead processes
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        int error = errno;
        n_log(LOG_ERR, "sigaction error: %s", strerror(error));
        return FALSE;
    }
    return TRUE;
}
 
int n_daemonize(void) {
    return n_daemonize_ex(N_DAEMON_NO_SIGCHLD_IGN | N_DAEMON_NO_SIGCHLD_HANDLER);
}
 
int n_daemonize_ex(int mode) {
    int error = 0;
 
    /* Fork off the parent process */
    pid_t pid = fork();
    error = errno;
    if (pid < 0) {
        n_log(LOG_ERR, "Error: unable to fork child: %s", strerror(error));
        exit(1);
    }
    if (pid > 0) {
        n_log(LOG_NOTICE, "Child started successfuly !");
        exit(0);
    }
 
    if (!(mode & N_DAEMON_NO_SETSID)) {
        /* On success: The child process becomes session leader
         * setsid is detaching the process from the terminal */
        if (setsid() < 0) {
            error = errno;
            n_log(LOG_ERR, "Error: unable to set session leader with setsid(): %s", strerror(error));
            exit(1);
        } else {
            n_log(LOG_NOTICE, "Session leader set !");
        }
    }
 
    if (!(mode & N_DAEMON_NO_SIGCHLD_IGN)) {
        /* Ignore signal sent from child to parent process */
        signal(SIGCHLD, SIG_IGN);
    }
 
    if (!(mode & N_DAEMON_NO_SIGCHLD_HANDLER)) {
        /* catching signal */
        sigchld_handler_installer();
    }
 
    if (!(mode & N_DAEMON_NO_DOUBLE_FORK)) {
        /* Double fork to detach from the parent, and be adopted by init process */
        pid = fork();
        error = errno;
        if (pid < 0) {
            n_log(LOG_ERR, "Error: unable to double fork child: %s", strerror(error));
            exit(1);
        }
        if (pid > 0) {
            n_log(LOG_NOTICE, "Double fork child started successfuly !");
            exit(0);
        }
    }
 
    if (!(mode & N_DAEMON_NO_UMASK)) {
        /* reset umask */
        umask(0);
    }
 
    if (!(mode & N_DAEMON_NO_CHDIR)) {
        /* set working directory */
        if (chdir("/") < 0) {
            error = errno;
            n_log(LOG_ERR, "couldn't chdir() to '/': %s", strerror(error));
            return FALSE;
        }
    }
 
    if (!(mode & N_DAEMON_NO_CLOSE)) {
        /* Close all open file descriptors except standard ones (stdin, stdout, stderr) */
        for (int x = 3; x < sysconf(_SC_OPEN_MAX); x++) {
            close(x);
        }
    }
 
    if (!(mode & N_DAEMON_NO_STD_REDIRECT)) {
        /* redirect stdin,stdout,stderr to /dev/null */
        int fd = open("/dev/null", O_RDWR, 0);
        if (fd != -1) {
            dup2(fd, STDIN_FILENO);
            dup2(fd, STDOUT_FILENO);
            dup2(fd, STDERR_FILENO);
            if (fd > 2) {
                close(fd);
            }
        } else {
            n_log(LOG_ERR, "Failed to open /dev/null: %s", strerror(errno));
        }
    }
 
    return TRUE;
} /* n_daemonize(...) */
 
pid_t system_nb(const char* command, int* infp, int* outfp) {
    __n_assert(command, return -1);
 
    int p_stdin[2] = {-1, -1};
    int p_stdout[2] = {-1, -1};
    pid_t pid = -1;
 
    if (outfp != NULL) {
        if (pipe(p_stdin) != 0)
            return -1;
    }
    if (infp != NULL) {
        if (pipe(p_stdout) != 0) {
            if (outfp != NULL) {
                close(p_stdin[0]);
                close(p_stdin[1]);
            }
            return (-1);
        }
    }
 
    pid = fork();
 
    if (pid < 0) {
        n_log(LOG_ERR, "Couldn't fork command %s", command);
        if (outfp != NULL) {
            close(p_stdin[0]);
            close(p_stdin[1]);
        }
        if (infp != NULL) {
            close(p_stdout[0]);
            close(p_stdout[1]);
        }
        return pid;
    }
    if (pid == 0) {
        if (outfp != NULL) {
            close(p_stdin[1]);
            dup2(p_stdin[0], 0);
        }
        if (infp != NULL) {
            close(p_stdout[0]);
            dup2(p_stdout[1], 1);
        }
        execlp("sh", "sh", "-c", command, (char*)NULL);
        // should never get here
        int error = errno;
        n_log(LOG_ERR, "%s:%d: exec failed: %s", __FILE__, __LINE__, strerror(error));
        exit(42);
    }
    if (infp != NULL) {
        close(p_stdout[1]);
        *infp = p_stdout[0];
    }
    if (outfp != NULL) {
        close(p_stdin[0]);
        *outfp = p_stdin[1];
    }
    return pid;
} /* system_nb */
 
#endif /* ifndef __windows__ */
 
void N_HIDE_STR(char* buf, ...) {
    size_t it = 0;
    va_list args;
 
    va_start(args, buf);
 
    int arg = 0;
 
    while ((arg = va_arg(args, int))) {
        buf[it] = (char)arg;
        it++;
    }
    buf[it] = '\0';
    va_end(args);
} /* N_HIDE_STR */
 
char* n_get_file_extension(char path[]) {
    char* result = NULL;
    size_t i = 0, n = 0;
 
    __n_assert(path, return "");
 
    n = strlen(path);
    i = n - 1;
    while ((i > 0) && (path[i] != '.') && (path[i] != '/') && (path[i] != '\\')) {
        i--;
    }
    if ((i > 0) && (i < n - 1) && (path[i] == '.') && (path[i - 1] != '/') && (path[i - 1] != '\\')) {
        result = path + i;
    } else {
        result = path + n;
    }
    return result;
}