httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From wr...@apache.org
Subject cvs commit: httpd-2.0/os/win32 ap_regkey.h ap_regkey.c
Date Mon, 24 Jun 2002 07:50:36 GMT
wrowe       2002/06/24 00:50:36

  Modified:    os/win32 ap_regkey.c
  Added:       os/win32 ap_regkey.h
  Removed:     include  ap_regkey.h
  Log:
    Add in the other complex ap_regkey_value_foo() fns and move ap_regkey.h
    Out Of The Way of exports stumbling onto it!!!
  
  Revision  Changes    Path
  1.2       +295 -2    httpd-2.0/os/win32/ap_regkey.c
  
  Index: ap_regkey.c
  ===================================================================
  RCS file: /home/cvs/httpd-2.0/os/win32/ap_regkey.c,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- ap_regkey.c	24 Jun 2002 04:50:41 -0000	1.1
  +++ ap_regkey.c	24 Jun 2002 07:50:36 -0000	1.2
  @@ -247,7 +247,7 @@
           if (rc != ERROR_SUCCESS) {
               return APR_FROM_OS_ERROR(rc);
           }
  -        if ((size < 4) || (type != REG_SZ && type != REG_EXPAND_SZ)) {
  +        if ((size < 2) || (type != REG_SZ && type != REG_EXPAND_SZ)) {
               return APR_FROM_OS_ERROR(ERROR_INVALID_PARAMETER);
           }
   
  @@ -293,7 +293,7 @@
           if (rc != ERROR_SUCCESS)
               return APR_FROM_OS_ERROR(rc);
   
  -        if ((size < 2) || (type != REG_SZ && type != REG_EXPAND_SZ)) {
  +        if ((size < 1) || (type != REG_SZ && type != REG_EXPAND_SZ)) {
               return APR_FROM_OS_ERROR(ERROR_INVALID_PARAMETER);
           }
   
  @@ -317,6 +317,299 @@
           }
       }
   #endif
  +    return APR_SUCCESS;
  +}
  +
  +
  +AP_DECLARE(apr_status_t) ap_regkey_value_set(ap_regkey_t *key, 
  +                                             const char *valuename, 
  +                                             const char *value, 
  +                                             apr_pool_t *pool)
  +{
  +    /* Retrieve a registry string value, and explode any envvars
  +     * that the system has configured (e.g. %SystemRoot%/someapp.exe)
  +     */
  +    LONG rc;
  +    DWORD size = strlen(value) + 1;
  +    
  +#if APR_HAS_UNICODE_FS
  +    IF_WIN_OS_IS_UNICODE 
  +    {
  +        apr_size_t alloclen;
  +        apr_size_t valuelen = strlen(valuename) + 1;
  +        apr_size_t wvallen = 256;
  +        apr_wchar_t wvalname[256];
  +        apr_wchar_t *wvalue;
  +        apr_status_t rv;
  +        rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
  +        if (rv != APR_SUCCESS)
  +            return rv;
  +        else if (valuelen)
  +            return APR_ENAMETOOLONG;
  +        
  +        wvallen = alloclen = size;
  +        wvalue = apr_palloc(pool, alloclen * 2);
  +        rv = apr_conv_utf8_to_ucs2(value, &size, wvalue, &wvallen);
  +        if (rv != APR_SUCCESS)
  +            return rv;
  +        else if (size)
  +            return APR_ENAMETOOLONG;
  +
  +        /* The size is the number of wchars consumed by apr_conv_utf8_to_ucs2
  +         * converted to bytes; the trailing L'\0' continues to be counted.
  +         */
  +        size = (alloclen - wvallen) * 2;
  +        rc = RegSetValueExW(key->hkey, wvalname, 0, REG_SZ, 
  +                            (LPBYTE)wvalue, size);
  +        if (rc != ERROR_SUCCESS)
  +            return APR_FROM_OS_ERROR(rc);
  +    }
  +#endif /* APR_HAS_UNICODE_FS */
  +#if APR_HAS_ANSI_FS
  +    ELSE_WIN_OS_IS_ANSI
  +    {
  +        rc = RegSetValueEx(key->hkey, valuename, 0, REG_SZ, value, size);
  +        if (rc != ERROR_SUCCESS)
  +            return APR_FROM_OS_ERROR(rc);
  +    }
  +#endif
  +    return APR_SUCCESS;
  +}
  +
  +
  +AP_DECLARE(apr_status_t) ap_regkey_value_array_get(apr_array_header_t **result, 
  +                                                   ap_regkey_t *key,
  +                                                   const char *valuename, 
  +                                                   apr_pool_t *pool)
  +{
  +    /* Retrieve a registry string value, and explode any envvars
  +     * that the system has configured (e.g. %SystemRoot%/someapp.exe)
  +     */
  +    LONG rc;
  +    char *buf;
  +    char *tmp;
  +    DWORD type;
  +    DWORD size = 0;
  +    
  +#if APR_HAS_UNICODE_FS
  +    IF_WIN_OS_IS_UNICODE 
  +    {
  +        apr_size_t alloclen;
  +        apr_size_t valuelen = strlen(valuename) + 1;
  +        apr_size_t wvallen = 256;
  +        apr_wchar_t wvalname[256];
  +        apr_wchar_t *wvalue;
  +        apr_status_t rv;
  +        rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
  +        if (rv != APR_SUCCESS)
  +            return rv;
  +        else if (valuelen)
  +            return APR_ENAMETOOLONG;
  +        /* Read to NULL buffer to determine value size */
  +        rc = RegQueryValueExW(key->hkey, wvalname, 0, &type, NULL, &size);
  +        if (rc != ERROR_SUCCESS) {
  +            return APR_FROM_OS_ERROR(rc);
  +        }
  +        if ((size < 2) || (type != REG_MULTI_SZ)) {
  +            return APR_FROM_OS_ERROR(ERROR_INVALID_PARAMETER);
  +        }
  +        wvalue = apr_palloc(pool, size);
  +
  +        /* Read value based on size query above */
  +        rc = RegQueryValueExW(key->hkey, wvalname, 0, &type, 
  +                              (LPBYTE)wvalue, &size);
  +        if (rc != ERROR_SUCCESS) {
  +            return APR_FROM_OS_ERROR(rc);
  +        }
  +
  +        /* ###: deliberately overallocate plus two extra nulls.
  +         * We could precalculate the exact buffer here instead, the question
  +         * is a matter of storage v.s. cpu cycles.
  +         */
  +        size /= 2;
  +        alloclen = valuelen = size * 3 + 2;
  +        buf = apr_palloc(pool, valuelen);
  +        rv = apr_conv_ucs2_to_utf8(wvalue, &size, buf, &valuelen);
  +        if (rv != APR_SUCCESS)
  +            return rv;
  +        else if (size || (valuelen < 2))
  +            return APR_ENAMETOOLONG;
  +        buf[(alloclen - valuelen)] = '\0';
  +        buf[(alloclen - valuelen) + 1] = '\0';
  +    }
  +#endif /* APR_HAS_UNICODE_FS */
  +#if APR_HAS_ANSI_FS
  +    ELSE_WIN_OS_IS_ANSI
  +    {
  +        /* Read to NULL buffer to determine value size */
  +        rc = RegQueryValueEx(key->hkey, valuename, 0, &type, NULL, &size);
  +        if (rc != ERROR_SUCCESS)
  +            return APR_FROM_OS_ERROR(rc);
  +
  +        if ((size < 1) || (type != REG_MULTI_SZ)) {
  +            return APR_FROM_OS_ERROR(ERROR_INVALID_PARAMETER);
  +        }
  +
  +        /* Small possiblity the array is either unterminated 
  +         * or single NULL terminated.  Avert.
  +         */
  +        buf = apr_palloc(pool, size + 2);
  +        buf[size + 1] = '\0';
  +        buf[size] = '\0';
  +        
  +        /* Read value based on size query above */
  +        rc = RegQueryValueEx(key->hkey, valuename, 0, &type, buf, &size);
  +        if (rc != ERROR_SUCCESS)
  +            return APR_FROM_OS_ERROR(rc);
  +    }
  +#endif
  +
  +    size = 0;    /* Element Count */
  +    for (tmp = buf; *tmp; ++tmp) {
  +        ++size;
  +        while (*tmp) {
  +            ++tmp;
  +        }
  +    }
  +
  +    *result = apr_array_make(pool, size, sizeof(char *));
  +    for (tmp = buf; *tmp; ++tmp) {
  +        char **newelem = (char **) apr_array_push(*result);
  +        *newelem = tmp;
  +        while (*tmp) {
  +            ++tmp;
  +        }
  +    }
  +
  +   return APR_SUCCESS;
  +}
  +
  +
  +AP_DECLARE(apr_status_t) ap_regkey_value_array_set(ap_regkey_t *key, 
  +                                                   const char *valuename, 
  +                                                   int nelts, 
  +                                                   const char * const * elts,
  +                                                   apr_pool_t *pool)
  +{
  +    /* Retrieve a registry string value, and explode any envvars
  +     * that the system has configured (e.g. %SystemRoot%/someapp.exe)
  +     */
  +    LONG rc;
  +    
  +#if APR_HAS_UNICODE_FS
  +    IF_WIN_OS_IS_UNICODE 
  +    {
  +        int i;
  +        DWORD size;
  +        apr_wchar_t *buf;
  +        apr_wchar_t *tmp;
  +        apr_size_t bufrem;
  +        apr_size_t bufsize;
  +        apr_size_t valuelen = strlen(valuename) + 1;
  +        apr_size_t wvallen = 256;
  +        apr_wchar_t wvalname[256];
  +        apr_status_t rv;
  +        rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
  +        if (rv != APR_SUCCESS)
  +            return rv;
  +        else if (valuelen)
  +            return APR_ENAMETOOLONG;
  +
  +        bufsize = 1; /* For trailing second null */
  +        for (i = 0; i < nelts; ++i) {
  +            bufsize += strlen(elts[i]) + 1;
  +        }
  +        if (!nelts) {
  +            ++bufsize;
  +        }
  +
  +        bufrem = bufsize;
  +        buf = apr_palloc(pool, bufsize * 2);
  +        tmp = buf;
  +        for (i = 0; i < nelts; ++i) {
  +            apr_size_t eltsize = strlen(elts[i]) + 1;
  +            size = eltsize;
  +            rv = apr_conv_utf8_to_ucs2(elts[i], &size, tmp, &bufrem);
  +            if (rv != APR_SUCCESS)
  +                return rv;
  +            else if (size)
  +                return APR_ENAMETOOLONG;
  +            tmp += eltsize;
  +        }
  +        if (!nelts) {
  +            (*tmp++) = L'\0';
  +        }
  +        *tmp = L'\0'; /* Trailing second null */
  +
  +        size = (bufsize - bufrem) * 2;
  +        rc = RegSetValueExW(key->hkey, wvalname, 0, REG_MULTI_SZ, 
  +                            (LPBYTE)buf, size);
  +        if (rc != ERROR_SUCCESS)
  +            return APR_FROM_OS_ERROR(rc);
  +    }
  +#endif /* APR_HAS_UNICODE_FS */
  +#if APR_HAS_ANSI_FS
  +    ELSE_WIN_OS_IS_ANSI
  +    {
  +        int  bufsize, i;
  +        char *buf, *tmp;
  +        bufsize = 1; /* For trailing second null */
  +        for (i = 0; i < nelts; ++i) {
  +            bufsize += strlen(elts[i]) + 1;
  +        }
  +        if (!nelts) {
  +            ++bufsize;
  +        }
  +        buf = apr_palloc(pool, bufsize);
  +        tmp = buf;
  +        for (i = 0; i < nelts; ++i) {
  +            strcpy(tmp, elts[i]);
  +            tmp += strlen(elts[i]) + 1;
  +        }
  +        if (!nelts) {
  +            (*tmp++) = '\0';
  +        }
  +        *tmp = '\0'; /* Trailing second null */
  +
  +        rc = RegSetValueEx(key->hkey, valuename, 0, REG_MULTI_SZ, 
  +                           buf, bufsize);
  +        if (rc != ERROR_SUCCESS)
  +            return APR_FROM_OS_ERROR(rc);
  +    }
  +#endif
  +    return APR_SUCCESS;
  +}
  +
  +
  +AP_DECLARE(apr_status_t) ap_regkey_value_remove(const ap_regkey_t *key, 
  +                                                const char *valuename,
  +                                                apr_pool_t *pool)
  +{
  +    LONG rc;
  +
  +#if APR_HAS_UNICODE_FS
  +    IF_WIN_OS_IS_UNICODE 
  +    {
  +        apr_size_t valuelen = strlen(valuename) + 1;
  +        apr_size_t wvallen = 256;
  +        apr_wchar_t wvalname[256];
  +        apr_status_t rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
  +        if (rv != APR_SUCCESS)
  +            return rv;
  +        else if (valuelen)
  +            return APR_ENAMETOOLONG;
  +        rc = RegDeleteValueW(key->hkey, wvalname);
  +    }
  +#endif /* APR_HAS_UNICODE_FS */
  +#if APR_HAS_ANSI_FS
  +    ELSE_WIN_OS_IS_ANSI
  +    {
  +        rc = RegDeleteValue(key->hkey, valuename);
  +    }
  +#endif
  +    if (rc != ERROR_SUCCESS) {
  +        return APR_FROM_OS_ERROR(rc);
  +    }
       return APR_SUCCESS;
   }
   
  
  
  
  1.1                  httpd-2.0/os/win32/ap_regkey.h
  
  Index: ap_regkey.h
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2002 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache",
   *    nor may "Apache" appear in their name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   *
   * Portions of this software are based upon public domain software
   * originally written at the National Center for Supercomputing Applications,
   * University of Illinois, Urbana-Champaign.
   */
  
  #ifndef AP_REGKEY_H
  #define AP_REGKEY_H
  
  #include "apr.h"
  #include "apr_pools.h"
  #include "ap_config.h"      /* Just for AP_DECLARE */
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  typedef struct ap_regkey_t ap_regkey_t;
  
  AP_DECLARE(const ap_regkey_t *) ap_regkey_const(int i);
  
  /**
   * Constants for ap_regkey_open() only;
   */
  #define AP_REGKEY_CLASSES_ROOT         ap_regkey_const(0)
  #define AP_REGKEY_CURRENT_CONFIG       ap_regkey_const(1)
  #define AP_REGKEY_CURRENT_USER         ap_regkey_const(2)
  #define AP_REGKEY_LOCAL_MACHINE        ap_regkey_const(3)
  #define AP_REGKEY_USERS                ap_regkey_const(4)
  #define AP_REGKEY_PERFORMANCE_DATA     ap_regkey_const(5)
  #define AP_REGKEY_DYN_DATA             ap_regkey_const(6)
  
  /**
   * Open the specified win32 registry key.
   * @param newkey The opened registry key
   * @param parentkey The open registry key of the parent, or one of
   * <PRE>
   *           AP_REGKEY_CLASSES_ROOT
   *           AP_REGKEY_CURRENT_CONFIG
   *           AP_REGKEY_CURRENT_USER
   *           AP_REGKEY_LOCAL_MACHINE
   *           AP_REGKEY_USERS
   *           AP_REGKEY_PERFORMANCE_DATA 
   *           AP_REGKEY_DYN_DATA 
   * </PRE>
   * @param keyname The path of the key relative to the parent key
   * @param flags Or'ed value of:
   * <PRE>
   *           APR_READ             open key for reading
   *           APR_WRITE            open key for writing
   *           APR_CREATE           create the key if it doesn't exist
   *           APR_EXCL             return error if APR_CREATE and file exists
   * </PRE>
   * @param pool The pool to alloc newkey and temporary storage within.
   * @ingroup apr_file_open
   * @remark If perm is APR_OS_DEFAULT and the file is being created, appropriate 
   *      default permissions will be used.  *arg1 must point to a valid file_t, 
   *      or NULL (in which case it will be allocated)
   */
  AP_DECLARE(apr_status_t) ap_regkey_open(ap_regkey_t **newkey, 
                                          const ap_regkey_t *parentkey,
                                          const char *keyname,
                                          apr_int32_t flags, 
                                          apr_pool_t *pool);
  
  /**
   * Close the win32 registry key opened or created by ap_regkey_open().
   * @param key The registry key to close
   */
  AP_DECLARE(apr_status_t) ap_regkey_close(ap_regkey_t *key);
  
  /**
   * Remove the given win32 registry key.
   * @param parentkey The open registry key of the parent, or one of
   * <PRE>
   *           AP_REGKEY_CLASSES_ROOT
   *           AP_REGKEY_CURRENT_CONFIG
   *           AP_REGKEY_CURRENT_USER
   *           AP_REGKEY_LOCAL_MACHINE
   *           AP_REGKEY_USERS
   *           AP_REGKEY_PERFORMANCE_DATA 
   *           AP_REGKEY_DYN_DATA 
   * </PRE>
   * @param keyname The path of the key relative to the parent key
   * @param pool The pool to alloc newkey and temporary storage within.
   * @remark ap_regkey_remove() is not recursive, although it removes
   * all values within the given keyname.
   */
  AP_DECLARE(apr_status_t) ap_regkey_remove(const ap_regkey_t *parent, 
                                            const char *keyname,
                                            apr_pool_t *pool);
  
  /**
   * Retrieve a win32 registry value string from an open key.
   * @param result The string value retrieved 
   * @param key The registry key to retrieve the value from
   * @param valuename The named value to retrieve (pass "" for the default)
   * @param pool The pool used to store the result.
   */
  AP_DECLARE(apr_status_t) ap_regkey_value_get(char **result, 
                                               ap_regkey_t *key, 
                                               const char *valuename, 
                                               apr_pool_t *pool);
  
  AP_DECLARE(apr_status_t) ap_regkey_value_set(ap_regkey_t *key, 
                                               const char *valuename, 
                                               const char *value, 
                                               apr_pool_t *pool);
  
  AP_DECLARE(apr_status_t) ap_regkey_value_array_get(apr_array_header_t **result, 
                                                     ap_regkey_t *key,
                                                     const char *valuename, 
                                                     apr_pool_t *pool);
  
  AP_DECLARE(apr_status_t) ap_regkey_value_array_set(ap_regkey_t *key, 
                                                     const char *valuename, 
                                                     int nelts, 
                                                     const char * const * elts,
                                                     apr_pool_t *pool);
  
  AP_DECLARE(apr_status_t) ap_regkey_value_remove(const ap_regkey_t *key, 
                                                  const char *valuename,
                                                  apr_pool_t *pool);
  
  #ifdef __cplusplus
  }
  #endif
  #endif /* AP_REGKEY_H */
  
  
  

Mime
View raw message