mDNSResponder-878.250.4.tar.gz

[apple/mdnsresponder.git] / mDNSWindows / DLLX / StringServices.cpp

diff --git a/mDNSWindows/DLLX/StringServices.cpp b/mDNSWindows/DLLX/StringServices.cpp
index a9c1d8a01bf47720083659f1f4fd7224e4657236..87f7aa996d04c6cd99b5307776eb32a85ccb6403 100755 (executable)
--- a/mDNSWindows/DLLX/StringServices.cpp
+++ b/mDNSWindows/DLLX/StringServices.cpp
@@ -13,184 +13,332 @@
  * 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.
  * 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.

+ */
+
+
+
+#include "StringServices.h"
+
+#include <DebugServices.h>
+
+
+
+
+
+extern BOOL
+
+BSTRToUTF8
+
+       (
+
+       BSTR                    inString,
+
+       std::string     &       outString
+
+       )
+
+{
+
+       USES_CONVERSION;
+
+       
+
+       char    *       utf8String      = NULL;
+
+       OSStatus    err                 = kNoErr;
+
+

 
 

-    Change History (most recent first):
-    
-$Log: StringServices.cpp,v $
-Revision 1.2  2009/06/02 18:43:57  herscher
-<rdar://problem/3948252> Allow component consumers to pass in null strings
-
-Revision 1.1  2009/05/26 04:43:54  herscher
-<rdar://problem/3948252> COM component that can be used with any .NET language and VB.
-\r
-\r
-*/\r
-\r
-#include "StringServices.h"\r
-#include <DebugServices.h>\r
-\r
-\r
-extern BOOL\r
-BSTRToUTF8\r
-       (\r
-       BSTR                    inString,\r
-       std::string     &       outString\r
-       )\r
-{\r
-       USES_CONVERSION;\r
-       \r
-       char    *       utf8String      = NULL;\r
-       OSStatus    err                 = kNoErr;\r
-\r

        outString = "";
 
        outString = "";
 

-       if ( inString )\r
+       if ( inString )
+

        {
                TCHAR   *       utf16String     = NULL;
                size_t      size                = 0;
        {
                TCHAR   *       utf16String     = NULL;
                size_t      size                = 0;

-\r
-               utf16String = OLE2T( inString );\r
-               require_action( utf16String != NULL, exit, err = kUnknownErr );\r
-\r
-               if ( wcslen( utf16String ) > 0 )\r
-               {\r
-                       size = (size_t) WideCharToMultiByte( CP_UTF8, 0, utf16String, ( int ) wcslen( utf16String ), NULL, 0, NULL, NULL );\r
-                       err = translate_errno( size != 0, GetLastError(), kUnknownErr );\r
-                       require_noerr( err, exit );\r
-\r
-                       try\r
-                       {\r
-                               utf8String = new char[ size + 1 ];\r
-                       }\r
-                       catch ( ... )\r
-                       {\r
-                               utf8String = NULL;\r
-                       }\r
-\r
-                       require_action( utf8String != NULL, exit, err = kNoMemoryErr );\r
-                       size = (size_t) WideCharToMultiByte( CP_UTF8, 0, utf16String, ( int ) wcslen( utf16String ), utf8String, (int) size, NULL, NULL);\r
-                       err = translate_errno( size != 0, GetLastError(), kUnknownErr );\r
-                       require_noerr( err, exit );\r
-\r
-                       // have to add the trailing 0 because WideCharToMultiByte doesn't do it,\r
-                       // although it does return the correct size\r
-\r
-                       utf8String[size] = '\0';\r
-                       outString = utf8String;\r
+
+
+               utf16String = OLE2T( inString );
+
+               require_action( utf16String != NULL, exit, err = kUnknownErr );
+
+
+
+               if ( wcslen( utf16String ) > 0 )
+
+               {
+
+                       size = (size_t) WideCharToMultiByte( CP_UTF8, 0, utf16String, ( int ) wcslen( utf16String ), NULL, 0, NULL, NULL );
+
+                       err = translate_errno( size != 0, GetLastError(), kUnknownErr );
+
+                       require_noerr( err, exit );
+
+
+
+                       try
+
+                       {
+
+                               utf8String = new char[ size + 1 ];
+
+                       }
+
+                       catch ( ... )
+
+                       {
+
+                               utf8String = NULL;
+
+                       }
+
+
+
+                       require_action( utf8String != NULL, exit, err = kNoMemoryErr );
+
+                       size = (size_t) WideCharToMultiByte( CP_UTF8, 0, utf16String, ( int ) wcslen( utf16String ), utf8String, (int) size, NULL, NULL);
+
+                       err = translate_errno( size != 0, GetLastError(), kUnknownErr );
+
+                       require_noerr( err, exit );
+
+
+
+                       // have to add the trailing 0 because WideCharToMultiByte doesn't do it,
+
+                       // although it does return the correct size
+
+
+
+                       utf8String[size] = '\0';
+
+                       outString = utf8String;
+

                }
                }

-       }\r
-\r
-exit:\r
-\r
-       if ( utf8String != NULL )\r
-       {\r
-               delete [] utf8String;\r
-       }\r
-\r
-       return ( !err ) ? TRUE : FALSE;\r
-}\r
-\r
-\r
-extern BOOL\r
-UTF8ToBSTR\r
-       (\r
-       const char      *       inString,\r
-       CComBSTR        &       outString\r
-       )\r
-{\r
-       wchar_t *       unicode = NULL;\r
-       OSStatus        err             = 0;\r
-\r
-       if ( inString )\r
+       }
+
+
+
+exit:
+
+
+
+       if ( utf8String != NULL )
+
+       {
+
+               delete [] utf8String;
+
+       }
+
+
+
+       return ( !err ) ? TRUE : FALSE;
+
+}
+
+
+
+
+
+extern BOOL
+
+UTF8ToBSTR
+
+       (
+
+       const char      *       inString,
+
+       CComBSTR        &       outString
+
+       )
+
+{
+
+       wchar_t *       unicode = NULL;
+
+       OSStatus        err             = 0;
+
+
+
+       if ( inString )
+

        {
                int n;
 
        {
                int n;
 

-               n = MultiByteToWideChar( CP_UTF8, 0, inString, -1, NULL, 0 );\r
-           \r
-               if ( n > 0 )\r
-               {\r
-                       try\r
-                       {\r
-                               unicode = new wchar_t[ n ];\r
-                       }\r
-                       catch ( ... )\r
-                       {\r
-                               unicode = NULL;\r
-                       }\r
-\r
-                       require_action( unicode, exit, err = ERROR_INSUFFICIENT_BUFFER );\r
-\r
-                       n = MultiByteToWideChar( CP_UTF8, 0, inString, -1, unicode, n );\r
-               }\r
-\r
-               outString = unicode;\r
+               n = MultiByteToWideChar( CP_UTF8, 0, inString, -1, NULL, 0 );
+
+           
+
+               if ( n > 0 )
+
+               {
+
+                       try
+
+                       {
+
+                               unicode = new wchar_t[ n ];
+
+                       }
+
+                       catch ( ... )
+
+                       {
+
+                               unicode = NULL;
+
+                       }
+
+
+
+                       require_action( unicode, exit, err = ERROR_INSUFFICIENT_BUFFER );
+
+
+
+                       n = MultiByteToWideChar( CP_UTF8, 0, inString, -1, unicode, n );
+
+               }
+
+
+
+               outString = unicode;
+

        }
        }

-\r
-exit:\r
-\r
-    if ( unicode != NULL )\r
-    {\r
-        delete [] unicode;\r
-       }\r
-\r
-       return ( !err ) ? TRUE : FALSE;\r
-}\r
-\r
-\r
-BOOL\r
-ByteArrayToVariant\r
-       (\r
-       const void      *       inArray,\r
-       size_t                  inArrayLen,\r
-       VARIANT         *       outVariant\r
-       )\r
-{\r
-       LPBYTE                  buf     = NULL;\r
-       HRESULT                 hr      = 0;\r
-       BOOL                    ok      = TRUE;\r
-\r
-       VariantClear( outVariant );\r
-       outVariant->vt          = VT_ARRAY|VT_UI1;\r
-       outVariant->parray      = SafeArrayCreateVector( VT_UI1, 0, ( ULONG ) inArrayLen );\r
-       require_action( outVariant->parray, exit, ok = FALSE );\r
-       hr = SafeArrayAccessData( outVariant->parray, (LPVOID *)&buf );\r
-       require_action( hr == S_OK, exit, ok = FALSE );\r
-       memcpy( buf, inArray, inArrayLen );\r
-       hr = SafeArrayUnaccessData( outVariant->parray );\r
-       require_action( hr == S_OK, exit, ok = FALSE );\r
-\r
-exit:\r
-\r
-       return ok;\r
-}\r
-\r
-\r
-extern BOOL\r
-VariantToByteArray\r
-       (\r
-       VARIANT                         *       inVariant,\r
-       std::vector< BYTE >     &       outArray\r
-       )\r
-{\r
-       SAFEARRAY       *       psa                     = NULL;\r
-       BYTE            *       pData           = NULL;\r
-       ULONG                   cElements       = 0;\r
-       HRESULT                 hr;\r
-       BOOL                    ok = TRUE;\r
-\r
-       require_action( V_VT( inVariant ) == ( VT_ARRAY|VT_UI1 ), exit, ok = FALSE );\r
-       psa = V_ARRAY( inVariant );\r
-       require_action( psa, exit, ok = FALSE );\r
-       require_action( SafeArrayGetDim( psa ) == 1, exit, ok = FALSE );\r
-       hr = SafeArrayAccessData( psa, ( LPVOID* )&pData );\r
-       require_action( hr == S_OK, exit, ok = FALSE );\r
-       cElements = psa->rgsabound[0].cElements;\r
-       outArray.reserve( cElements );\r
-       outArray.assign( cElements, 0 );\r
-       memcpy( &outArray[ 0 ], pData, cElements );\r
-       SafeArrayUnaccessData( psa );\r
-\r
-exit:\r
-\r
-       return ok;\r
+
+
+exit:
+
+
+
+    if ( unicode != NULL )
+
+    {
+
+        delete [] unicode;
+
+       }
+
+
+
+       return ( !err ) ? TRUE : FALSE;
+
+}
+
+
+
+
+
+BOOL
+
+ByteArrayToVariant
+
+       (
+
+       const void      *       inArray,
+
+       size_t                  inArrayLen,
+
+       VARIANT         *       outVariant
+
+       )
+
+{
+
+       LPBYTE                  buf     = NULL;
+
+       HRESULT                 hr      = 0;
+
+       BOOL                    ok      = TRUE;
+
+
+
+       VariantClear( outVariant );
+
+       outVariant->vt          = VT_ARRAY|VT_UI1;
+
+       outVariant->parray      = SafeArrayCreateVector( VT_UI1, 0, ( ULONG ) inArrayLen );
+
+       require_action( outVariant->parray, exit, ok = FALSE );
+
+       hr = SafeArrayAccessData( outVariant->parray, (LPVOID *)&buf );
+
+       require_action( hr == S_OK, exit, ok = FALSE );
+
+       memcpy( buf, inArray, inArrayLen );
+
+       hr = SafeArrayUnaccessData( outVariant->parray );
+
+       require_action( hr == S_OK, exit, ok = FALSE );
+
+
+
+exit:
+
+
+
+       return ok;
+
+}
+
+
+
+
+
+extern BOOL
+
+VariantToByteArray
+       (
+       VARIANT                         *       inVariant,
+       std::vector< BYTE >     &       outArray
+       )
+{
+       BOOL ok = TRUE;
+
+       if ( V_VT( inVariant ) == VT_BSTR )
+       {
+               BSTR bstr = V_BSTR( inVariant );
+               std::string utf8;
+
+               BSTRToUTF8( bstr, utf8 );
+
+               outArray.reserve( utf8.size() );
+               outArray.assign( utf8.begin(), utf8.end() );
+       }
+       else if ( V_VT( inVariant ) == VT_ARRAY )
+       {
+               SAFEARRAY       *       psa                     = NULL;
+               BYTE            *       pData           = NULL;
+               ULONG                   cElements       = 0;
+               HRESULT                 hr;
+               
+               psa = V_ARRAY( inVariant );
+
+               require_action( psa, exit, ok = FALSE );
+
+               require_action( SafeArrayGetDim( psa ) == 1, exit, ok = FALSE );
+
+               hr = SafeArrayAccessData( psa, ( LPVOID* )&pData );
+
+               require_action( hr == S_OK, exit, ok = FALSE );
+
+               cElements = psa->rgsabound[0].cElements;
+
+               outArray.reserve( cElements );
+
+               outArray.assign( cElements, 0 );
+
+               memcpy( &outArray[ 0 ], pData, cElements );
+
+               SafeArrayUnaccessData( psa );
+       }
+       else
+       {
+               ok = FALSE;
+       }
+
+exit:
+
+       return ok;
+

 }
\ No newline at end of file
 }
\ No newline at end of file