summaryrefslogtreecommitdiff
path: root/source4/lib/appweb/ejs-2.0/mpr/WIN
diff options
context:
space:
mode:
Diffstat (limited to 'source4/lib/appweb/ejs-2.0/mpr/WIN')
-rw-r--r--source4/lib/appweb/ejs-2.0/mpr/WIN/Makefile16
-rw-r--r--source4/lib/appweb/ejs-2.0/mpr/WIN/mprFile.c123
-rw-r--r--source4/lib/appweb/ejs-2.0/mpr/WIN/mprPlatform.c378
-rw-r--r--source4/lib/appweb/ejs-2.0/mpr/WIN/mprTime.c192
4 files changed, 709 insertions, 0 deletions
diff --git a/source4/lib/appweb/ejs-2.0/mpr/WIN/Makefile b/source4/lib/appweb/ejs-2.0/mpr/WIN/Makefile
new file mode 100644
index 0000000000..84e30ff8f1
--- /dev/null
+++ b/source4/lib/appweb/ejs-2.0/mpr/WIN/Makefile
@@ -0,0 +1,16 @@
+#
+# Makefile for the Mbedthis Portable Runtime (MPR) library for Windows
+#
+# Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
+#
+
+COMPILE := *.c
+EXPORT_OBJECTS := yes
+MAKE_IFLAGS := -I..
+
+include make.dep
+
+## Local variables:
+## tab-width: 4
+## End:
+## vim: tw=78 sw=4 ts=4
diff --git a/source4/lib/appweb/ejs-2.0/mpr/WIN/mprFile.c b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprFile.c
new file mode 100644
index 0000000000..9ac1669f3d
--- /dev/null
+++ b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprFile.c
@@ -0,0 +1,123 @@
+/**
+ * @file mprWinFile.c
+ * @brief File services for Windows
+ * @overview
+ * @remarks
+ */
+
+/******************************************************************************/
+/*
+ * @copy default
+ *
+ * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
+ *
+ * This software is distributed under commercial and open source licenses.
+ * You may use the GPL open source license described below or you may acquire
+ * a commercial license from Mbedthis Software. You agree to be fully bound
+ * by the terms of either license. Consult the LICENSE.TXT distributed with
+ * this software for full details.
+ *
+ * This software is open source; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version. See the GNU General Public License for more
+ * details at: http://www.mbedthis.com/downloads/gplLicense.html
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * This GPL license does NOT permit incorporating this software into
+ * proprietary programs. If you are unable to comply with the GPL, you must
+ * acquire a commercial license to use this software. Commercial licenses
+ * for this software and support services are available from Mbedthis
+ * Software at http://www.mbedthis.com
+ *
+ * @end
+ */
+
+/********************************** Includes **********************************/
+
+#include "mpr.h"
+
+/************************************ Code ************************************/
+
+int mprGetFileInfo(MprCtx ctx, const char *path, MprFileInfo *info)
+{
+ struct stat s;
+
+ mprAssert(path);
+ mprAssert(info);
+
+ if (stat(path, &s) < 0) {
+ return -1;
+ }
+
+ info->size = s.st_size;
+ /*
+ * MOB -- these are time64_t. Loss of precision
+ */
+ info->ctime = (uint) s.st_ctime;
+ info->mtime = (uint) s.st_mtime;
+ info->inode = s.st_ino;
+ info->isDir = (s.st_mode & S_IFDIR) != 0;
+ info->isReg = (s.st_mode & S_IFREG) != 0;
+
+ /*
+ * Work hard on windows to determine if the file is a regular file.
+ * FUTURE -- OPT. Eliminate this CreateFile.
+ */
+ if (info->isReg) {
+ long fileType, att;
+
+ if ((att = GetFileAttributes(path)) == -1) {
+ return -1;
+ }
+ if (att & (FILE_ATTRIBUTE_REPARSE_POINT |
+ FILE_ATTRIBUTE_DIRECTORY |
+ FILE_ATTRIBUTE_ENCRYPTED |
+ FILE_ATTRIBUTE_SYSTEM |
+ FILE_ATTRIBUTE_OFFLINE)) {
+ /*
+ * Catch accesses to devices like CON, AUX, NUL, LPT etc
+ * att will be set to ENCRYPTED on Win9X and NT.
+ */
+ info->isReg = 0;
+ }
+ if (info->isReg) {
+ HANDLE handle;
+ handle = CreateFile(path, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
+ 0, OPEN_EXISTING, 0, 0);
+ if (handle == INVALID_HANDLE_VALUE) {
+ info->isReg = 0;
+ } else {
+ fileType = GetFileType(handle);
+ if (fileType == FILE_TYPE_CHAR || fileType == FILE_TYPE_PIPE) {
+ info->isReg = 0;
+ }
+ CloseHandle(handle);
+ }
+ }
+ }
+ if (strcmp(path, "nul") == 0) {
+ info->isReg = 0;
+ }
+ return 0;
+}
+
+/******************************************************************************/
+
+int mprMakeDir(MprCtx ctx, const char *path, int perms)
+{
+ return mkdir(path, perms);
+}
+
+/******************************************************************************/
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim:tw=78
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */
diff --git a/source4/lib/appweb/ejs-2.0/mpr/WIN/mprPlatform.c b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprPlatform.c
new file mode 100644
index 0000000000..65718694b1
--- /dev/null
+++ b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprPlatform.c
@@ -0,0 +1,378 @@
+/**
+ * @file mprPlatform.c
+ * @brief Cross platform routines
+ * @overview This module provides low level cross platform routines.
+ * @remarks Most routines in this file are not thread-safe. It is the callers
+ * responsibility to perform all thread synchronization.
+ */
+
+/*
+ * @copy default
+ *
+ * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
+ *
+ * This software is distributed under commercial and open source licenses.
+ * You may use the GPL open source license described below or you may acquire
+ * a commercial license from Mbedthis Software. You agree to be fully bound
+ * by the terms of either license. Consult the LICENSE.TXT distributed with
+ * this software for full details.
+ *
+ * This software is open source; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version. See the GNU General Public License for more
+ * details at: http://www.mbedthis.com/downloads/gplLicense.html
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * This GPL license does NOT permit incorporating this software into
+ * proprietary programs. If you are unable to comply with the GPL, you must
+ * acquire a commercial license to use this software. Commercial licenses
+ * for this software and support services are available from Mbedthis
+ * Software at http://www.mbedthis.com
+ *
+ * @end
+ */
+
+/********************************** Includes **********************************/
+/*
+ * We need to use the underlying str(cpy) routines to implement our safe
+ * alternatives
+ */
+#if !DOXYGEN
+#define UNSAFE_FUNCTIONS_OK 1
+#endif
+
+#include "mpr.h"
+
+/**************************** Forward Declarations ****************************/
+
+static const char *getHive(const char *keyPath, HKEY *hive);
+
+/************************************ Code ************************************/
+
+char *mprInetToStr(char *buffer, int bufsize, const struct in_addr in)
+{
+#if HAVE_NTOA_R
+ inet_ntoa_r(in, buffer, bufsize);
+#else
+ uchar *cp;
+ cp = (uchar*) &in;
+ mprSprintf(buffer, bufsize, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
+#endif
+ return buffer;
+}
+
+/******************************************************************************/
+
+void mprSetShell(MprCtx ctx, void *shell)
+{
+}
+
+/******************************************************************************/
+
+void *mprGetShell(MprCtx ctx)
+{
+ return 0;
+}
+
+/******************************************************************************/
+/*
+ * Sleep. Period given in milliseconds.
+ */
+
+void mprSleep(MprCtx ctx, int milliseconds)
+{
+ Sleep(milliseconds);
+}
+
+/******************************************************************************/
+/*
+ * Make intervening directories
+ */
+
+int mprMakeDirPath(MprCtx ctx, const char *path)
+{
+ char dir[MPR_MAX_PATH], buf[MPR_MAX_PATH];
+ char *dirSep;
+ char *next, *tok;
+
+ dir[0] = '\0';
+ dirSep = "/\\";
+
+ if (path == 0 || *path == '\0') {
+ return MPR_ERR_BAD_ARGS;
+ }
+
+ mprStrcpy(buf, sizeof(buf), path);
+ next = mprStrTok(buf, dirSep, &tok);
+ if (*buf == '/') {
+ dir[0] = '/';
+ }
+ while (next != NULL) {
+ if (strcmp(next, ".") == 0 ) {
+ next = mprStrTok(NULL, dirSep, &tok);
+ continue;
+ }
+ strcat(dir, next);
+ if (access(dir, R_OK) != 0) {
+ if (_mkdir(dir) < 0) {
+ return MPR_ERR_CANT_CREATE;
+ }
+ }
+ strcat(dir, "/");
+ next = mprStrTok(NULL, dirSep, &tok);
+ }
+ return 0;
+}
+
+/******************************************************************************/
+/*
+ * Get a fully qualified file name for the given path. Return with forward
+ * slashes always
+ */
+
+char *mprGetFullPathName(char *buf, int buflen, const char *path)
+{
+#if (WIN || NW || OS2) && !BLD_FEATURE_ROMFS
+ char *junk, *cp;
+ int rc;
+
+ --buflen;
+ rc = GetFullPathName(path, buflen, buf, &junk);
+ for (cp = buf; *cp; cp++) {
+ if (*cp == '\\') {
+ *cp = '/';
+ }
+ }
+ buf[buflen] = '\0';
+#else
+ if (mprStrcpy(buf, buflen, path) < 0) {
+ mprAssert(0);
+ return 0;
+ }
+#endif
+ return buf;
+}
+
+/******************************************************************************/
+/*
+ * Replacement for gethostbyname that is multi-thread safe
+ */
+
+struct hostent *mprGetHostByName(MprCtx ctx, const char *name)
+{
+ MprApp *app;
+ struct hostent *hp;
+ struct hostent *ip;
+ int count, i;
+
+ hp = (struct hostent*) mprAlloc(ctx, sizeof(struct hostent));
+ memset(hp, 0, sizeof(struct hostent));
+
+ app = mprGetApp(ctx);
+
+ #undef gethostbyname
+
+ mprGlobalLock(app);
+ ip = gethostbyname(name);
+ mprGlobalUnlock(app);
+
+ if (ip == 0) {
+ return 0;
+ }
+ hp->h_addrtype = ip->h_addrtype;
+ hp->h_length = ip->h_length;
+ hp->h_name = mprStrdup(hp, ip->h_name);
+ hp->h_addr_list = 0;
+ hp->h_aliases = 0;
+
+ for (count = 0; ip->h_addr_list[count] != 0; ) {
+ count++;
+ }
+ if (count > 0) {
+ count++;
+ hp->h_addr_list = mprAlloc(hp, count * sizeof(char*));
+ for (i = 0; ip->h_addr_list[i] != 0; i++) {
+ memcpy(&hp->h_addr_list[i], &ip->h_addr_list[i], ip->h_length);
+ }
+ hp->h_addr_list[i] = 0;
+ }
+
+ for (count = 0; ip->h_aliases[count] != 0; ) {
+ count++;
+ }
+ if (count > 0) {
+ count++;
+ hp->h_aliases = mprAlloc(hp, count * sizeof(char*));
+ for (i = 0; ip->h_aliases[i] != 0; i++) {
+ hp->h_aliases[i] = mprStrdup(hp, ip->h_aliases[i]);
+ }
+ hp->h_aliases[i] = 0;
+ }
+ return hp;
+}
+
+/******************************************************************************/
+/*
+ * Read a registry value. Returns allocated memory in buf.
+ */
+
+int mprReadRegistry(MprCtx ctx, char **buf, int max, const char *key,
+ const char *name)
+{
+ HKEY top, h;
+ char *value;
+ ulong type, size;
+
+ mprAssert(key && *key);
+ mprAssert(buf);
+
+ /*
+ * Get the registry hive
+ */
+ if ((key = getHive(key, &top)) == 0) {
+ return MPR_ERR_CANT_ACCESS;
+ }
+
+ if (RegOpenKeyEx(top, key, 0, KEY_READ, &h) != ERROR_SUCCESS) {
+ return MPR_ERR_CANT_ACCESS;
+ }
+
+ /*
+ * Get the type
+ */
+ if (RegQueryValueEx(h, name, 0, &type, 0, &size) != ERROR_SUCCESS) {
+ RegCloseKey(h);
+ return MPR_ERR_CANT_READ;
+ }
+ if (type != REG_SZ && type != REG_EXPAND_SZ) {
+ RegCloseKey(h);
+ return MPR_ERR_BAD_TYPE;
+ }
+
+ value = (char*) mprAlloc(ctx, size);
+ if ((int) size > max) {
+ RegCloseKey(h);
+ return MPR_ERR_WONT_FIT;
+ }
+ if (RegQueryValueEx(h, name, 0, &type, (uchar*) value, &size) !=
+ ERROR_SUCCESS) {
+ mprFree(value);
+ RegCloseKey(h);
+ return MPR_ERR_CANT_READ;
+ }
+
+ RegCloseKey(h);
+ *buf = value;
+ return 0;
+}
+
+/******************************************************************************/
+/*
+ * Write a string registry value. Returns allocated memory in buf.
+ */
+
+int mprWriteRegistry(MprCtx ctx, const char *key, const char *name,
+ const char *value)
+{
+ HKEY top, h, subHandle;
+ ulong disposition;
+
+ mprAssert(key && *key);
+ mprAssert(name && *name);
+ mprAssert(value && *value);
+
+ /*
+ * Get the registry hive
+ */
+ if ((key = getHive(key, &top)) == 0) {
+ return MPR_ERR_CANT_ACCESS;
+ }
+
+ if (name) {
+ /*
+ * Write a registry string value
+ */
+ if (RegOpenKeyEx(top, key, 0, KEY_ALL_ACCESS, &h) != ERROR_SUCCESS) {
+ return MPR_ERR_CANT_ACCESS;
+ }
+ if (RegSetValueEx(h, name, 0, REG_SZ, value, strlen(value) + 1)
+ != ERROR_SUCCESS) {
+ RegCloseKey(h);
+ return MPR_ERR_CANT_READ;
+ }
+
+ } else {
+ /*
+ * Create a new sub key
+ */
+ if (RegOpenKeyEx(top, key, 0, KEY_CREATE_SUB_KEY, &h) != ERROR_SUCCESS){
+ return MPR_ERR_CANT_ACCESS;
+ }
+ if (RegCreateKeyEx(h, name, 0, NULL, REG_OPTION_NON_VOLATILE,
+ KEY_ALL_ACCESS, NULL, &subHandle, &disposition) != ERROR_SUCCESS) {
+ return MPR_ERR_CANT_ACCESS;
+ }
+ RegCloseKey(subHandle);
+ }
+ RegCloseKey(h);
+ return 0;
+}
+
+/******************************************************************************/
+/*
+ * Determine the registry hive by the first portion of the path. Return
+ * a pointer to the rest of key path after the hive portion.
+ */
+
+static const char *getHive(const char *keyPath, HKEY *hive)
+{
+ char key[MPR_MAX_STRING], *cp;
+ int len;
+
+ mprAssert(keyPath && *keyPath);
+
+ *hive = 0;
+
+ mprStrcpy(key, sizeof(key), keyPath);
+ key[sizeof(key) - 1] = '\0';
+
+ if (cp = strchr(key, '\\')) {
+ *cp++ = '\0';
+ }
+ if (cp == 0 || *cp == '\0') {
+ return 0;
+ }
+
+ if (!mprStrcmpAnyCase(key, "HKEY_LOCAL_MACHINE")) {
+ *hive = HKEY_LOCAL_MACHINE;
+ } else if (!mprStrcmpAnyCase(key, "HKEY_CURRENT_USER")) {
+ *hive = HKEY_CURRENT_USER;
+ } else if (!mprStrcmpAnyCase(key, "HKEY_USERS")) {
+ *hive = HKEY_USERS;
+ } else if (!mprStrcmpAnyCase(key, "HKEY_CLASSES_ROOT")) {
+ *hive = HKEY_CLASSES_ROOT;
+ } else {
+ return 0;
+ }
+
+ if (*hive == 0) {
+ return 0;
+ }
+ len = strlen(key) + 1;
+ return keyPath + len;
+}
+
+/******************************************************************************/
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim:tw=78
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */
diff --git a/source4/lib/appweb/ejs-2.0/mpr/WIN/mprTime.c b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprTime.c
new file mode 100644
index 0000000000..74e59c9c73
--- /dev/null
+++ b/source4/lib/appweb/ejs-2.0/mpr/WIN/mprTime.c
@@ -0,0 +1,192 @@
+/**
+ * @file mprTime.c
+ * @brief Time handling for Windows
+ * @overview
+ */
+
+/*
+ * @copy default
+ *
+ * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
+ *
+ * This software is distributed under commercial and open source licenses.
+ * You may use the GPL open source license described below or you may acquire
+ * a commercial license from Mbedthis Software. You agree to be fully bound
+ * by the terms of either license. Consult the LICENSE.TXT distributed with
+ * this software for full details.
+ *
+ * This software is open source; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version. See the GNU General Public License for more
+ * details at: http://www.mbedthis.com/downloads/gplLicense.html
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * This GPL license does NOT permit incorporating this software into
+ * proprietary programs. If you are unable to comply with the GPL, you must
+ * acquire a commercial license to use this software. Commercial licenses
+ * for this software and support services are available from Mbedthis
+ * Software at http://www.mbedthis.com
+ *
+ * @end
+ */
+
+/********************************* Includes ***********************************/
+
+#include "mpr.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/************************************ Code ************************************/
+/*
+ * Returns time in seconds and milliseconds. This is NOT time-of-day.
+ */
+
+MprTime *mprGetTime(MprCtx ctx, MprTime *tp)
+{
+ FILETIME fileTime;
+ int64 now, base;
+
+ GetSystemTimeAsFileTime(&fileTime);
+
+ now = ((((int64) fileTime.dwHighDateTime) << BITS(uint)) +
+ ((int64) fileTime.dwLowDateTime));
+
+ /*
+ * Convert from 100-nanosec units to milliseconds
+ */
+ now = (now / 10000);
+
+ /*
+ * Adjust to be seconds since Jan 1 1970. Do this to be consistent with
+ * UNIX but not really required by the API definition.
+ */
+ base = ((UINT64(365) * 86400 * (1970 - 1601)) * 1000);
+ now -= base;
+ tp->sec = (uint) (now / 1000);
+ tp->msec = (uint) (now % 1000);
+
+#if UNUSED
+{
+ static int64 start;
+
+ if (start == 0) {
+ start = now;
+ }
+ if (now < start) {
+ mprLog(ctx, 0, "TIME WENT BACKWARDS");
+ mprLog(ctx, 0, "start %Ld", start);
+ mprLog(ctx, 0, "now %Ld", now);
+ }
+ mprLog(ctx, 0, "getTime %Ld", now);
+ start = now;
+}
+#endif
+
+ return tp;
+}
+
+/******************************************************************************/
+/*
+ * Thread-safe wrapping of localtime
+ */
+
+struct tm *mprLocaltime(MprCtx ctx, struct tm *timep, time_t *now)
+{
+ struct tm *tbuf;
+ mprGlobalLock(ctx);
+ tbuf = localtime(now);
+ *timep = *tbuf;
+ mprGlobalUnlock(ctx);
+
+ return timep;
+}
+
+/******************************************************************************/
+/*
+ * Thread-safe wrapping of gmtime
+ */
+
+struct tm *mprGmtime(MprCtx ctx, time_t *now, struct tm *timep)
+{
+ struct tm *tbuf;
+ tbuf = gmtime(now);
+ *timep = *tbuf;
+
+ return timep;
+}
+
+/******************************************************************************/
+/*
+ * Thread-safe wrapping of ctime
+ */
+
+int mprCtime(MprCtx ctx, char *buf, int bufsize, const time_t *timer)
+{
+ char *cp;
+ int len;
+
+ mprAssert(buf);
+
+ mprGlobalLock(ctx);
+
+ cp = ctime(timer);
+ if ((int) strlen(cp) >= bufsize) {
+ mprStrcpy(buf, bufsize, "WONT FIT");
+ mprAssert(0);
+ mprGlobalUnlock(ctx);
+ return MPR_ERR_WONT_FIT;
+ }
+
+ len = mprStrcpy(buf, bufsize, cp);
+ if (buf[len - 1] == '\n') {
+ buf[len - 1] = '\0';
+ }
+
+ mprGlobalUnlock(ctx);
+
+ return 0;
+}
+
+/******************************************************************************/
+/*
+ * Thread-safe wrapping of asctime
+ */
+
+int mprAsctime(MprCtx ctx, char *buf, int bufsize, const struct tm *timeptr)
+{
+ char *cp;
+
+ mprAssert(buf);
+ mprGlobalLock(ctx);
+ cp = asctime(timeptr);
+ if ((int) strlen(cp) >= bufsize) {
+ mprAssert(0);
+ mprGlobalUnlock(ctx);
+ return MPR_ERR_WONT_FIT;
+ }
+ mprStrcpy(buf, bufsize, cp);
+ mprGlobalUnlock(ctx);
+
+ return strlen(buf);
+}
+
+/******************************************************************************/
+
+#ifdef __cplusplus
+}
+#endif
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim:tw=78
+ * vim600: sw=4 ts=4 fdm=marker
+ * vim<600: sw=4 ts=4
+ */
generated by cgit (git 2.34.1) at 2024-12-31 05:21:18 +0000