diff --git a/dlls/ole32/stg_prop.c b/dlls/ole32/stg_prop.c
index 302840ad6b5..fb1e54ca8e3 100644
--- a/dlls/ole32/stg_prop.c
+++ b/dlls/ole32/stg_prop.c
@@ -31,7 +31,7 @@
  * below, but it gives the best "big picture" that I've found.
  *
  * TODO: There's a lot missing in here.  Biggies:
- * - There are all sorts of restricions I don't honor, like maximum property
+ * - There are all sorts of restrictions I don't honor, like maximum property
  *   set byte size, maximum property name length
  * - Certain bogus files could result in reading past the end of a buffer.
  * - This will probably fail on big-endian machines, especially reading and
@@ -130,6 +130,22 @@ static HRESULT PropertyStorage_CreateDictionaries(
 static void PropertyStorage_DestroyDictionaries(
  struct tagPropertyStorage_impl *);
 
+/* Copies from propvar to prop.  If propvar's type is VT_LPSTR, copies the
+ * string using PropertyStorage_StringCopy.
+ */
+static HRESULT PropertyStorage_PropVariantCopy(PROPVARIANT *prop,
+ const PROPVARIANT *propvar, LCID targetCP, LCID srcCP);
+
+/* Copies the string src, which is encoded using code page srcCP, and returns
+ * it in *dst, in the code page specified by targetCP.  The returned string is
+ * allocated using CoTaskMemAlloc.
+ * If srcCP is CP_UNICODE, src is in fact an LPCWSTR.  Similarly, if targetCP
+ * is CP_UNICODE, the returned string is in fact an LPWSTR.
+ * Returns S_OK on success, something else on failure.
+ */
+static HRESULT PropertyStorage_StringCopy(LPCSTR src, LPSTR *dst, LCID targetCP,
+ LCID srcCP);
+
 static IPropertyStorageVtbl IPropertyStorage_Vtbl;
 
 /***********************************************************************
@@ -280,23 +296,144 @@ static HRESULT WINAPI IPropertyStorage_fnReadMultiple(
              rgpspec[i].u.lpwstr);
 
             if (prop)
-                PropVariantCopy(&rgpropvar[i], prop);
+                PropertyStorage_PropVariantCopy(&rgpropvar[i], prop, GetACP(),
+                 This->codePage);
         }
         else
         {
-            PROPVARIANT *prop = PropertyStorage_FindProperty(This,
-             rgpspec[i].u.propid);
+            switch (rgpspec[i].u.propid)
+            {
+                case PID_CODEPAGE:
+                    rgpropvar[i].vt = VT_I2;
+                    rgpropvar[i].u.iVal = This->codePage;
+                    break;
+                case PID_LOCALE:
+                    rgpropvar[i].vt = VT_I4;
+                    rgpropvar[i].u.lVal = This->locale;
+                    break;
+                default:
+                {
+                    PROPVARIANT *prop = PropertyStorage_FindProperty(This,
+                     rgpspec[i].u.propid);
 
-            if (prop)
-                PropVariantCopy(&rgpropvar[i], prop);
+                    if (prop)
+                        PropertyStorage_PropVariantCopy(&rgpropvar[i], prop,
+                         GetACP(), This->codePage);
+                }
+            }
         }
     }
     LeaveCriticalSection(&This->cs);
     return hr;
 }
 
+static HRESULT PropertyStorage_StringCopy(LPCSTR src, LPSTR *dst, LCID targetCP,
+ LCID srcCP)
+{
+    HRESULT hr = S_OK;
+    int len;
+
+    TRACE("%s, %p, %ld, %ld\n",
+     srcCP == CP_UNICODE ? debugstr_w((LPCWSTR)src) : debugstr_a(src), dst,
+     targetCP, srcCP);
+    assert(src);
+    assert(dst);
+    *dst = NULL;
+    if (targetCP == srcCP)
+    {
+        size_t len;
+
+        if (targetCP == CP_UNICODE)
+            len = (strlenW((LPCWSTR)src) + 1) * sizeof(WCHAR);
+        else
+            len = strlen(src) + 1;
+        *dst = CoTaskMemAlloc(len * sizeof(WCHAR));
+        if (!*dst)
+            hr = STG_E_INSUFFICIENTMEMORY;
+        else
+            memcpy(*dst, src, len);
+    }
+    else
+    {
+        if (targetCP == CP_UNICODE)
+        {
+            len = MultiByteToWideChar(srcCP, 0, src, -1, NULL, 0);
+            *dst = CoTaskMemAlloc(len * sizeof(WCHAR));
+            if (!*dst)
+                hr = STG_E_INSUFFICIENTMEMORY;
+            else
+                MultiByteToWideChar(srcCP, 0, src, -1, (LPWSTR)*dst, len);
+        }
+        else
+        {
+            LPWSTR wideStr;
+
+            if (srcCP == CP_UNICODE)
+                wideStr = (LPWSTR)src;
+            else
+            {
+                len = MultiByteToWideChar(srcCP, 0, src, -1, NULL, 0);
+                wideStr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
+                if (wideStr)
+                    MultiByteToWideChar(srcCP, 0, src, -1, wideStr, len);
+                else
+                    hr = STG_E_INSUFFICIENTMEMORY;
+            }
+            if (SUCCEEDED(hr))
+            {
+                len = WideCharToMultiByte(targetCP, 0, wideStr, -1, NULL, 0,
+                 NULL, NULL);
+                *dst = CoTaskMemAlloc(len);
+                if (!*dst)
+                    hr = STG_E_INSUFFICIENTMEMORY;
+                else
+                {
+                    BOOL defCharUsed = FALSE;
+
+                    if (WideCharToMultiByte(targetCP, 0, wideStr, -1, *dst,
+                     len, NULL, &defCharUsed) == 0 || defCharUsed)
+                    {
+                        CoTaskMemFree(*dst);
+                        *dst = NULL;
+                        hr = HRESULT_FROM_WIN32(ERROR_NO_UNICODE_TRANSLATION);
+                    }
+                }
+            }
+            if (wideStr != (LPWSTR)src)
+                HeapFree(GetProcessHeap(), 0, wideStr);
+        }
+    }
+    TRACE("returning 0x%08lx (%s)\n", hr,
+     targetCP == CP_UNICODE ? debugstr_w((LPCWSTR)*dst) : debugstr_a(*dst));
+    return hr;
+}
+
+static HRESULT PropertyStorage_PropVariantCopy(PROPVARIANT *prop,
+ const PROPVARIANT *propvar, LCID targetCP, LCID srcCP)
+{
+    HRESULT hr = S_OK;
+
+    assert(prop);
+    assert(propvar);
+    if (propvar->vt == VT_LPSTR)
+    {
+        hr = PropertyStorage_StringCopy(propvar->u.pszVal, &prop->u.pszVal,
+         targetCP, srcCP);
+        if (SUCCEEDED(hr))
+            prop->vt = VT_LPSTR;
+    }
+    else
+        PropVariantCopy(prop, propvar);
+    return hr;
+}
+
+/* Stores the property with id propid and value propvar into this property
+ * storage.  lcid is ignored if propvar's type is not VT_LPSTR.  If propvar's
+ * type is VT_LPSTR, converts the string using lcid as the source code page
+ * and This->codePage as the target code page before storing.
+ */
 static HRESULT PropertyStorage_StorePropWithId(PropertyStorage_impl *This,
- PROPID propid, const PROPVARIANT *propvar)
+ PROPID propid, const PROPVARIANT *propvar, LCID lcid)
 {
     HRESULT hr = S_OK;
     PROPVARIANT *prop = PropertyStorage_FindProperty(This, propid);
@@ -307,7 +444,8 @@ static HRESULT PropertyStorage_StorePropWithId(PropertyStorage_impl *This,
     if (prop)
     {
         PropVariantClear(prop);
-        PropVariantCopy(prop, propvar);
+        hr = PropertyStorage_PropVariantCopy(prop, propvar, This->codePage,
+         lcid);
     }
     else
     {
@@ -315,10 +453,16 @@ static HRESULT PropertyStorage_StorePropWithId(PropertyStorage_impl *This,
          sizeof(PROPVARIANT));
         if (prop)
         {
-            PropVariantCopy(prop, propvar);
-            dictionary_insert(This->propid_to_prop, (void *)propid, prop);
-            if (propid > This->highestProp)
-                This->highestProp = propid;
+            hr = PropertyStorage_PropVariantCopy(prop, propvar, This->codePage,
+             lcid);
+            if (SUCCEEDED(hr))
+            {
+                dictionary_insert(This->propid_to_prop, (void *)propid, prop);
+                if (propid > This->highestProp)
+                    This->highestProp = propid;
+            }
+            else
+                HeapFree(GetProcessHeap(), 0, prop);
         }
         else
             hr = STG_E_INSUFFICIENTMEMORY;
@@ -383,7 +527,7 @@ static HRESULT WINAPI IPropertyStorage_fnWriteMultiple(
                     dictionary_insert(This->propid_to_name, (void *)nextId,
                      name);
                     hr = PropertyStorage_StorePropWithId(This, nextId,
-                     &rgpropvar[i]);
+                     &rgpropvar[i], GetACP());
                 }
             }
         }
@@ -419,7 +563,7 @@ static HRESULT WINAPI IPropertyStorage_fnWriteMultiple(
                     hr = STG_E_INVALIDPARAMETER;
                 else
                     hr = PropertyStorage_StorePropWithId(This,
-                     rgpspec[i].u.propid, &rgpropvar[i]);
+                     rgpspec[i].u.propid, &rgpropvar[i], GetACP());
             }
         }
     }
@@ -541,16 +685,23 @@ static HRESULT WINAPI IPropertyStorage_fnWritePropertyNames(
     hr = S_OK;
     EnterCriticalSection(&This->cs);
     This->dirty = TRUE;
-    for (i = 0; i < cpropid; i++)
+    for (i = 0; SUCCEEDED(hr) && i < cpropid; i++)
     {
         if (rgpropid[i] != PID_ILLEGAL)
         {
             size_t len = lstrlenW(rglpwstrName[i]) + 1;
             LPWSTR name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 
-            strcpyW(name, rglpwstrName[i]);
-            dictionary_insert(This->name_to_propid, name, (void *)rgpropid[i]);
-            dictionary_insert(This->propid_to_name, (void *)rgpropid[i], name);
+            if (name)
+            {
+                strcpyW(name, rglpwstrName[i]);
+                dictionary_insert(This->name_to_propid, name,
+                 (void *)rgpropid[i]);
+                dictionary_insert(This->propid_to_name, (void *)rgpropid[i],
+                 name);
+            }
+            else
+                hr = STG_E_INSUFFICIENTMEMORY;
         }
     }
     if (This->grfFlags & PROPSETFLAG_UNBUFFERED)
@@ -879,8 +1030,9 @@ static HRESULT PropertyStorage_ReadProperty(PROPVARIANT *prop, const BYTE *data)
         {
             /* FIXME: if the host is big-endian, this'll suck */
             memcpy(prop->u.pszVal, data + sizeof(DWORD), count);
-            /* FIXME: so far so good, but this may be Unicode or DBCS depending
-             * on This->codePage.
+            /* This is stored in the code page specified in This->codePage.
+             * Don't convert it, the caller will just store it as-is.
+             * (Note the trace will be misleading if the code page is Unicode.)
              */
             TRACE("Read string value %s\n", debugstr_a(prop->u.pszVal));
         }
@@ -1160,7 +1312,7 @@ static HRESULT PropertyStorage_ReadFromStream(PropertyStorage_impl *This)
                         break;
                     default:
                         hr = PropertyStorage_StorePropWithId(This,
-                         idOffset->propid, &prop);
+                         idOffset->propid, &prop, This->codePage);
                     }
                 }
             }
@@ -2106,12 +2258,12 @@ HRESULT WINAPI FmtIdToPropStgName(const FMTID *rfmtid, LPOLESTR str)
  */
 HRESULT WINAPI PropStgNameToFmtId(const LPOLESTR str, FMTID *rfmtid)
 {
-    HRESULT hr = E_INVALIDARG;
+    HRESULT hr = STG_E_INVALIDNAME;
 
     TRACE("%s, %p\n", debugstr_w(str), rfmtid);
 
     if (!rfmtid) return E_INVALIDARG;
-    if (!str) return E_INVALIDARG;
+    if (!str) return STG_E_INVALIDNAME;
 
     if (!lstrcmpiW(str, szDocSummaryInfo))
     {
diff --git a/dlls/ole32/tests/stg_prop.c b/dlls/ole32/tests/stg_prop.c
index e309093f933..f1059f6531c 100644
--- a/dlls/ole32/tests/stg_prop.c
+++ b/dlls/ole32/tests/stg_prop.c
@@ -211,12 +211,10 @@ static void testProps(void)
     /* revert it */
     hr = IPropertyStorage_Revert(propertyStorage);
     ok(SUCCEEDED(hr), "Revert failed: 0x%08lx\n", hr);
-    /* and make sure it's still an integer */
-    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
-    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
-    ok(var.vt == VT_I4 && U(var).lVal == 1,
-     "Didn't get expected type or value for property (got type %d, value %ld)\n",
-     var.vt, U(var).lVal);
+    /* Oddly enough, there's no guarantee that a successful revert actually
+     * implies the value wasn't saved.  Maybe transactional mode needs to be
+     * used for that?
+     */
 
     IPropertyStorage_Release(propertyStorage);
     propertyStorage = NULL;
@@ -260,6 +258,161 @@ static void testProps(void)
     DeleteFileW(filename);
 }
 
+void testCodepage(void)
+{
+    static const WCHAR szDot[] = { '.',0 };
+    static const WCHAR szPrefix[] = { 's','t','g',0 };
+    static const WCHAR wval[] = { 'h','i',0 };
+    HRESULT hr;
+    IStorage *storage = NULL;
+    IPropertySetStorage *propSetStorage = NULL;
+    IPropertyStorage *propertyStorage = NULL;
+    PROPSPEC spec;
+    PROPVARIANT var;
+    WCHAR fileName[MAX_PATH];
+
+    if(!GetTempFileNameW(szDot, szPrefix, 0, fileName))
+        return;
+
+    hr = StgCreateDocfile(fileName,
+     STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
+    ok(SUCCEEDED(hr), "StgCreateDocfile failed: 0x%08lx\n", hr);
+
+    hr = StgCreatePropSetStg(storage, 0, &propSetStorage);
+    ok(SUCCEEDED(hr), "StgCreatePropSetStg failed: 0x%08lx\n", hr);
+
+    hr = IPropertySetStorage_Create(propSetStorage,
+     &FMTID_SummaryInformation, NULL, PROPSETFLAG_DEFAULT,
+     STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
+     &propertyStorage);
+    ok(SUCCEEDED(hr), "IPropertySetStorage_Create failed: 0x%08lx\n", hr);
+
+    PropVariantInit(&var);
+    spec.ulKind = PRSPEC_PROPID;
+    U(spec).propid = PID_CODEPAGE;
+    /* check code page before it's been explicitly set */
+    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
+    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
+    ok(var.vt == VT_I2 && U(var).iVal == 1200,
+     "Didn't get expected type or value for property\n");
+    /* Set the code page to ascii */
+    var.vt = VT_I2;
+    U(var).iVal = 1252;
+    hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
+    ok(SUCCEEDED(hr), "WriteMultiple failed: 0x%08lx\n", hr);
+    /* check code page */
+    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
+    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
+    ok(var.vt == VT_I2 && U(var).iVal == 1252,
+     "Didn't get expected type or value for property\n");
+    /* Set code page to Unicode */
+    U(var).iVal = 1200;
+    hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
+    ok(SUCCEEDED(hr), "WriteMultiple failed: 0x%08lx\n", hr);
+    /* check code page */
+    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
+    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
+    ok(var.vt == VT_I2 && U(var).iVal == 1200,
+     "Didn't get expected type or value for property\n");
+    /* Set a string value */
+    spec.ulKind = PRSPEC_PROPID;
+    U(spec).propid = PID_FIRST_USABLE;
+    var.vt = VT_LPSTR;
+    U(var).pszVal = "hi";
+    hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
+    ok(SUCCEEDED(hr), "WriteMultiple failed: 0x%08lx\n", hr);
+    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
+    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
+    ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, "hi"),
+     "Didn't get expected type or value for property\n");
+    /* This seemingly non-sensical test is to show that the string is indeed
+     * interpreted according to the current system code page, not according to
+     * the property set's code page.  (If the latter were true, the whole
+     * string would be maintained.  As it is, only the first character is.)
+     */
+    U(var).pszVal = (LPSTR)wval;
+    hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
+    ok(SUCCEEDED(hr), "WriteMultiple failed: 0x%08lx\n", hr);
+    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
+    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
+    ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, "h"),
+     "Didn't get expected type or value for property\n");
+    /* now that a property's been set, you can't change the code page */
+    spec.ulKind = PRSPEC_PROPID;
+    U(spec).propid = PID_CODEPAGE;
+    var.vt = VT_I2;
+    U(var).iVal = 1200;
+    hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
+    ok(hr == STG_E_INVALIDPARAMETER,
+     "Expected STG_E_INVALIDPARAMETER, got 0x%08lx\n", hr);
+
+    IPropertyStorage_Release(propertyStorage);
+    IPropertySetStorage_Release(propSetStorage);
+    IStorage_Release(storage);
+
+    DeleteFileW(fileName);
+
+    /* same tests, but with PROPSETFLAG_ANSI */
+    hr = StgCreateDocfile(fileName,
+     STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
+    ok(SUCCEEDED(hr), "StgCreateDocfile failed: 0x%08lx\n", hr);
+
+    hr = StgCreatePropSetStg(storage, 0, &propSetStorage);
+    ok(SUCCEEDED(hr), "StgCreatePropSetStg failed: 0x%08lx\n", hr);
+
+    hr = IPropertySetStorage_Create(propSetStorage,
+     &FMTID_SummaryInformation, NULL, PROPSETFLAG_ANSI,
+     STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
+     &propertyStorage);
+    ok(SUCCEEDED(hr), "IPropertySetStorage_Create failed: 0x%08lx\n", hr);
+
+    /* check code page before it's been explicitly set */
+    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
+    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
+    ok(var.vt == VT_I2 && U(var).iVal == 1252,
+     "Didn't get expected type or value for property\n");
+    /* Set code page to Unicode */
+    U(var).iVal = 1200;
+    hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
+    ok(SUCCEEDED(hr), "WriteMultiple failed: 0x%08lx\n", hr);
+    /* check code page */
+    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
+    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
+    ok(var.vt == VT_I2 && U(var).iVal == 1200,
+     "Didn't get expected type or value for property\n");
+    /* This test is commented out for documentation.  It fails under Wine,
+     * and I expect it would under Windows as well, yet it succeeds.  There's
+     * obviously something about string conversion I don't understand.
+     */
+#if 0
+    static const char strVal[] = { 0x81, 0xff, 0x04, 0 };
+    /* Set code page to 950 (Traditional Chinese) */
+    U(var).iVal = 950;
+    hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
+    ok(SUCCEEDED(hr), "WriteMultiple failed: 0x%08lx\n", hr);
+    /* Try writing an invalid string: lead byte 0x81 is unused in Traditional
+     * Chinese.
+     */
+    spec.ulKind = PRSPEC_PROPID;
+    U(spec).propid = PID_FIRST_USABLE;
+    var.vt = VT_LPSTR;
+    U(var).pszVal = (LPSTR)strVal;
+    hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
+    ok(SUCCEEDED(hr), "WriteMultiple failed: 0x%08lx\n", hr);
+    /* Check returned string */
+    hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
+    ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08lx\n", hr);
+    ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, strVal),
+     "Didn't get expected type or value for property\n");
+#endif
+
+    IPropertyStorage_Release(propertyStorage);
+    IPropertySetStorage_Release(propSetStorage);
+    IStorage_Release(storage);
+
+    DeleteFileW(fileName);
+}
+
 static void testFmtId(void)
 {
     WCHAR szSummaryInfo[] = { 5,'S','u','m','m','a','r','y',
@@ -302,7 +455,8 @@ static void testFmtId(void)
     hr = pPropStgNameToFmtId(NULL, NULL);
     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08lx\n", hr);
     hr = pPropStgNameToFmtId(NULL, &fmtid);
-    ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08lx\n", hr);
+    ok(hr == STG_E_INVALIDNAME, "Expected STG_E_INVALIDNAME, got 0x%08lx\n",
+     hr);
     hr = pPropStgNameToFmtId(szDocSummaryInfo, NULL);
     ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08lx\n", hr);
     /* test the known format IDs */
@@ -337,5 +491,6 @@ START_TEST(stg_prop)
 {
     init_function_pointers();
     testProps();
+    testCodepage();
     testFmtId();
 }