#include "osls.h" #include #include #include #include #include #include #if defined(_WIN32) # define WIN32_LEAN_AND_MEAN # include # include # include # include #else # include # include # include # if defined(__APPLE__) # include # else # include # endif #endif typedef struct cron_field { uint64_t values; int minimum; int maximum; int wildcard; } cron_field; static int copy_text(char *dst, size_t capacity, const char *src) { size_t length; if (!dst || capacity == 0 || !src) return 0; length = strlen(src); if (length >= capacity) return 0; memcpy(dst, src, length + 1); return 1; } static void copy_env(char *dst, size_t capacity, const char *name) { const char *value = getenv(name); if (value) (void)copy_text(dst, capacity, value); } osls_status osls_get_system_info(osls_system_info *out_info) { if (!out_info) return OSLS_INVALID_ARGUMENT; memset(out_info, 0, sizeof(*out_info)); #if defined(_WIN32) { DWORD host_len = (DWORD)sizeof(out_info->hostname); DWORD user_len = (DWORD)sizeof(out_info->user_name); LARGE_INTEGER counter, frequency; char cwd[sizeof(out_info->working_directory)]; if (!GetComputerNameA(out_info->hostname, &host_len)) return OSLS_SYSTEM_ERROR; if (!GetUserNameA(out_info->user_name, &user_len)) copy_env(out_info->user_name, sizeof(out_info->user_name), "USERNAME"); if (!_getcwd(cwd, (int)sizeof(cwd)) || !copy_text(out_info->working_directory, sizeof(out_info->working_directory), cwd)) return OSLS_SYSTEM_ERROR; out_info->platform = OSLS_PLATFORM_WINDOWS; out_info->process_id = (uint64_t)_getpid(); out_info->unix_time_seconds = (int64_t)time(NULL); if (!QueryPerformanceFrequency(&frequency) || !QueryPerformanceCounter(&counter) || frequency.QuadPart <= 0) return OSLS_SYSTEM_ERROR; out_info->monotonic_time_nanoseconds = (uint64_t)((counter.QuadPart / frequency.QuadPart) * 1000000000ULL + ((counter.QuadPart % frequency.QuadPart) * 1000000000ULL) / frequency.QuadPart); } #elif defined(__APPLE__) || defined(__linux__) { struct timespec ts; char cwd[sizeof(out_info->working_directory)]; if (gethostname(out_info->hostname, sizeof(out_info->hostname) - 1) != 0) return OSLS_SYSTEM_ERROR; out_info->hostname[sizeof(out_info->hostname) - 1] = '\0'; if (!getcwd(cwd, sizeof(cwd)) || !copy_text(out_info->working_directory, sizeof(out_info->working_directory), cwd)) return OSLS_SYSTEM_ERROR; copy_env(out_info->user_name, sizeof(out_info->user_name), "USER"); if (!out_info->user_name[0]) copy_env(out_info->user_name, sizeof(out_info->user_name), "LOGNAME"); out_info->platform = # if defined(__APPLE__) OSLS_PLATFORM_MACOS; # else OSLS_PLATFORM_LINUX; # endif out_info->process_id = (uint64_t)getpid(); out_info->unix_time_seconds = (int64_t)time(NULL); # if defined(__APPLE__) { mach_timebase_info_data_t info; uint64_t ticks = mach_absolute_time(); if (mach_timebase_info(&info) != KERN_SUCCESS || info.denom == 0) return OSLS_SYSTEM_ERROR; out_info->monotonic_time_nanoseconds = (ticks / info.denom) * info.numer + ((ticks % info.denom) * info.numer) / info.denom; } # else if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) return OSLS_SYSTEM_ERROR; out_info->monotonic_time_nanoseconds = (uint64_t)ts.tv_sec * 1000000000ULL + (uint64_t)ts.tv_nsec; # endif } #else return OSLS_NOT_FOUND; #endif return OSLS_OK; } static int parse_uint(const char **cursor, int *out) { const char *p = *cursor; int value = 0; if (!isdigit((unsigned char)*p)) return 0; while (isdigit((unsigned char)*p)) { int digit = *p - '0'; if (value > (INT_MAX - digit) / 10) return 0; value = value * 10 + digit; ++p; } *cursor = p; *out = value; return 1; } static int parse_field(const char *text, int minimum, int maximum, int sunday_alias, cron_field *out) { const char *p = text; int is_wildcard = (text[0] == '*'); uint64_t bits = 0; if (!text || !*text || !out) return 0; while (*p) { int start, end, step = 1, value; if (*p == '*') { start = minimum; end = maximum; ++p; } else { if (!parse_uint(&p, &start)) return 0; end = start; if (*p == '-') { ++p; if (!parse_uint(&p, &end)) return 0; } } if (*p == '/') { ++p; if (!parse_uint(&p, &step) || step <= 0) return 0; } if (start < minimum || end > maximum || start > end) return 0; for (value = start; value <= end; value += step) { int normalized = (sunday_alias && value == 7) ? 0 : value; bits |= (uint64_t)1 << normalized; if (end - value < step) break; } if (!*p) break; if (*p != ',') return 0; ++p; if (!*p) return 0; } if (!bits) return 0; out->values = bits; out->minimum = minimum; out->maximum = maximum; out->wildcard = is_wildcard; return 1; } static int parse_expression(const char *expression, cron_field fields[5]) { char buffer[256]; char *cursor, *token; int index = 0; if (!expression) return 0; if (strlen(expression) >= sizeof(buffer)) return 0; memcpy(buffer, expression, strlen(expression) + 1); cursor = buffer; while ((token = strtok(cursor, " \t\r\n")) != NULL) { static const int mins[5] = {0, 0, 1, 1, 0}; static const int maxs[5] = {59, 23, 31, 12, 7}; cursor = NULL; if (index >= 5 || !parse_field(token, mins[index], maxs[index], index == 4, &fields[index])) return 0; if (index == 3 && fields[index].values & 1u) return 0; ++index; } return index == 5; } osls_status osls_cron_validate(const char *expression) { cron_field fields[5]; return parse_expression(expression, fields) ? OSLS_OK : OSLS_INVALID_ARGUMENT; } static int local_time(time_t value, struct tm *out) { #if defined(_WIN32) return localtime_s(out, &value) == 0; #else return localtime_r(&value, out) != NULL; #endif } static int field_has(const cron_field *field, int value) { return value >= 0 && value < 64 && ((field->values >> value) & 1u) != 0; } osls_status osls_cron_next_after(const char *expression, int64_t after_epoch_seconds, int64_t *out_epoch_seconds) { cron_field fields[5]; int64_t candidate; const int64_t limit = (int64_t)5 * 366 * 24 * 60; int64_t i; if (!out_epoch_seconds || !parse_expression(expression, fields)) return OSLS_INVALID_ARGUMENT; candidate = after_epoch_seconds - (after_epoch_seconds % 60) + 60; if (after_epoch_seconds < 0 && after_epoch_seconds % 60) candidate = after_epoch_seconds - (after_epoch_seconds % 60); for (i = 0; i < limit; ++i, candidate += 60) { struct tm tm_value; int day_match, weekday_match; time_t instant = (time_t)candidate; if ((int64_t)instant != candidate || !local_time(instant, &tm_value)) return OSLS_SYSTEM_ERROR; if (!field_has(&fields[0], tm_value.tm_min) || !field_has(&fields[1], tm_value.tm_hour) || !field_has(&fields[3], tm_value.tm_mon + 1)) continue; day_match = field_has(&fields[2], tm_value.tm_mday); weekday_match = field_has(&fields[4], tm_value.tm_wday); if (fields[2].wildcard || fields[4].wildcard) { if (!day_match || !weekday_match) continue; } else if (!day_match && !weekday_match) continue; *out_epoch_seconds = candidate; return OSLS_OK; } return OSLS_NOT_FOUND; }