3 * @brief Cross platform routines
4 * @overview This module provides low level cross platform routines.
5 * @remarks Most routines in this file are not thread-safe. It is the callers
6 * responsibility to perform all thread synchronization.
12 * Copyright (c) Mbedthis Software LLC, 2003-2006. All Rights Reserved.
14 * This software is distributed under commercial and open source licenses.
15 * You may use the GPL open source license described below or you may acquire
16 * a commercial license from Mbedthis Software. You agree to be fully bound
17 * by the terms of either license. Consult the LICENSE.TXT distributed with
18 * this software for full details.
20 * This software is open source; you can redistribute it and/or modify it
21 * under the terms of the GNU General Public License as published by the
22 * Free Software Foundation; either version 2 of the License, or (at your
23 * option) any later version. See the GNU General Public License for more
24 * details at: http://www.mbedthis.com/downloads/gplLicense.html
26 * This program is distributed WITHOUT ANY WARRANTY; without even the
27 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
29 * This GPL license does NOT permit incorporating this software into
30 * proprietary programs. If you are unable to comply with the GPL, you must
31 * acquire a commercial license to use this software. Commercial licenses
32 * for this software and support services are available from Mbedthis
33 * Software at http://www.mbedthis.com
38 /********************************** Includes **********************************/
40 * We need to use the underlying str(cpy) routines to implement our safe
44 #define UNSAFE_FUNCTIONS_OK 1
49 /**************************** Forward Declarations ****************************/
51 static const char *getHive(const char *keyPath, HKEY *hive);
53 /************************************ Code ************************************/
55 char *mprInetToStr(char *buffer, int bufsize, const struct in_addr in)
58 inet_ntoa_r(in, buffer, bufsize);
62 mprSprintf(buffer, bufsize, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
67 /******************************************************************************/
69 void mprSetShell(MprCtx ctx, void *shell)
73 /******************************************************************************/
75 void *mprGetShell(MprCtx ctx)
80 /******************************************************************************/
82 * Sleep. Period given in milliseconds.
85 void mprSleep(MprCtx ctx, int milliseconds)
90 /******************************************************************************/
92 * Make intervening directories
95 int mprMakeDirPath(MprCtx ctx, const char *path)
97 char dir[MPR_MAX_PATH], buf[MPR_MAX_PATH];
104 if (path == 0 || *path == '\0') {
105 return MPR_ERR_BAD_ARGS;
108 mprStrcpy(buf, sizeof(buf), path);
109 next = mprStrTok(buf, dirSep, &tok);
113 while (next != NULL) {
114 if (strcmp(next, ".") == 0 ) {
115 next = mprStrTok(NULL, dirSep, &tok);
119 if (access(dir, R_OK) != 0) {
120 if (_mkdir(dir) < 0) {
121 return MPR_ERR_CANT_CREATE;
125 next = mprStrTok(NULL, dirSep, &tok);
130 /******************************************************************************/
132 * Get a fully qualified file name for the given path. Return with forward
136 char *mprGetFullPathName(char *buf, int buflen, const char *path)
138 #if (WIN || NW || OS2) && !BLD_FEATURE_ROMFS
143 rc = GetFullPathName(path, buflen, buf, &junk);
144 for (cp = buf; *cp; cp++) {
151 if (mprStrcpy(buf, buflen, path) < 0) {
159 /******************************************************************************/
161 * Replacement for gethostbyname that is multi-thread safe
164 struct hostent *mprGetHostByName(MprCtx ctx, const char *name)
171 hp = (struct hostent*) mprAlloc(ctx, sizeof(struct hostent));
172 memset(hp, 0, sizeof(struct hostent));
174 app = mprGetApp(ctx);
179 ip = gethostbyname(name);
180 mprGlobalUnlock(app);
185 hp->h_addrtype = ip->h_addrtype;
186 hp->h_length = ip->h_length;
187 hp->h_name = mprStrdup(hp, ip->h_name);
191 for (count = 0; ip->h_addr_list[count] != 0; ) {
196 hp->h_addr_list = mprAlloc(hp, count * sizeof(char*));
197 for (i = 0; ip->h_addr_list[i] != 0; i++) {
198 memcpy(&hp->h_addr_list[i], &ip->h_addr_list[i], ip->h_length);
200 hp->h_addr_list[i] = 0;
203 for (count = 0; ip->h_aliases[count] != 0; ) {
208 hp->h_aliases = mprAlloc(hp, count * sizeof(char*));
209 for (i = 0; ip->h_aliases[i] != 0; i++) {
210 hp->h_aliases[i] = mprStrdup(hp, ip->h_aliases[i]);
212 hp->h_aliases[i] = 0;
217 /******************************************************************************/
219 * Read a registry value. Returns allocated memory in buf.
222 int mprReadRegistry(MprCtx ctx, char **buf, int max, const char *key,
229 mprAssert(key && *key);
233 * Get the registry hive
235 if ((key = getHive(key, &top)) == 0) {
236 return MPR_ERR_CANT_ACCESS;
239 if (RegOpenKeyEx(top, key, 0, KEY_READ, &h) != ERROR_SUCCESS) {
240 return MPR_ERR_CANT_ACCESS;
246 if (RegQueryValueEx(h, name, 0, &type, 0, &size) != ERROR_SUCCESS) {
248 return MPR_ERR_CANT_READ;
250 if (type != REG_SZ && type != REG_EXPAND_SZ) {
252 return MPR_ERR_BAD_TYPE;
255 value = (char*) mprAlloc(ctx, size);
256 if ((int) size > max) {
258 return MPR_ERR_WONT_FIT;
260 if (RegQueryValueEx(h, name, 0, &type, (uchar*) value, &size) !=
264 return MPR_ERR_CANT_READ;
272 /******************************************************************************/
274 * Write a string registry value. Returns allocated memory in buf.
277 int mprWriteRegistry(MprCtx ctx, const char *key, const char *name,
280 HKEY top, h, subHandle;
283 mprAssert(key && *key);
284 mprAssert(name && *name);
285 mprAssert(value && *value);
288 * Get the registry hive
290 if ((key = getHive(key, &top)) == 0) {
291 return MPR_ERR_CANT_ACCESS;
296 * Write a registry string value
298 if (RegOpenKeyEx(top, key, 0, KEY_ALL_ACCESS, &h) != ERROR_SUCCESS) {
299 return MPR_ERR_CANT_ACCESS;
301 if (RegSetValueEx(h, name, 0, REG_SZ, value, strlen(value) + 1)
304 return MPR_ERR_CANT_READ;
309 * Create a new sub key
311 if (RegOpenKeyEx(top, key, 0, KEY_CREATE_SUB_KEY, &h) != ERROR_SUCCESS){
312 return MPR_ERR_CANT_ACCESS;
314 if (RegCreateKeyEx(h, name, 0, NULL, REG_OPTION_NON_VOLATILE,
315 KEY_ALL_ACCESS, NULL, &subHandle, &disposition) != ERROR_SUCCESS) {
316 return MPR_ERR_CANT_ACCESS;
318 RegCloseKey(subHandle);
324 /******************************************************************************/
326 * Determine the registry hive by the first portion of the path. Return
327 * a pointer to the rest of key path after the hive portion.
330 static const char *getHive(const char *keyPath, HKEY *hive)
332 char key[MPR_MAX_STRING], *cp;
335 mprAssert(keyPath && *keyPath);
339 mprStrcpy(key, sizeof(key), keyPath);
340 key[sizeof(key) - 1] = '\0';
342 if (cp = strchr(key, '\\')) {
345 if (cp == 0 || *cp == '\0') {
349 if (!mprStrcmpAnyCase(key, "HKEY_LOCAL_MACHINE")) {
350 *hive = HKEY_LOCAL_MACHINE;
351 } else if (!mprStrcmpAnyCase(key, "HKEY_CURRENT_USER")) {
352 *hive = HKEY_CURRENT_USER;
353 } else if (!mprStrcmpAnyCase(key, "HKEY_USERS")) {
355 } else if (!mprStrcmpAnyCase(key, "HKEY_CLASSES_ROOT")) {
356 *hive = HKEY_CLASSES_ROOT;
364 len = strlen(key) + 1;
365 return keyPath + len;
368 /******************************************************************************/
376 * vim600: sw=4 ts=4 fdm=marker