为什么即使我打破了关于长度计入NUL终止的规定，RegSetValueEx仍能正常工作？

Question

I've got a simple program that adds calc.exe to startup:

#include <windows.h>
#include <tchar.h>

int main(){
    _tprintf(TEXT("Adding calc.exe to SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run...\n"));

    HKEY hRegRunKey;
    LPCTSTR lpKeyName = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");
    LPCTSTR lpKeyValue = TEXT("Calculator");

    LPCTSTR lpProgram = TEXT("C:\\WINDOWS\\system32\\calc.exe");
    DWORD cchProgram = _tcslen(lpProgram);

    _tprintf(TEXT("Path: %s. \n"), lpProgram);
    _tprintf(TEXT("Length: %d. \n"), cchProgram);

    if(RegOpenKeyEx( HKEY_LOCAL_MACHINE, lpKeyName, 0, KEY_SET_VALUE, &hRegRunKey) == ERROR_SUCCESS){
        if(RegSetValueEx(hRegRunKey, lpKeyValue, 0, REG_SZ, (const BYTE *)lpProgram, cchProgram * sizeof(TCHAR)) != ERROR_SUCCESS){
            _tprintf(TEXT("ERROR: Can't set key value.\n"));
            exit(1);
        }else{
            _tprintf(TEXT("Key has been added sucessfully.\n"));
        }
    }

    Sleep(5000);
    RegCloseKey(hRegRunKey);
}

For me the world of c/c++/WIN32API is still full of misteries... so I have few questions.

1. When I define string is it automatically null terminated?

LPCTSTR lpProgram = TEXT("C:\\WINDOWS\\system32\\calc.exe");

or should it be done:

LPCTSTR lpProgram = TEXT("C:\\WINDOWS\\system32\\calc.exe\0");

2. In my code is final argument to RegSetValueEx set to correct value?

From MSDN - RegSetValueEx function page:

cbData [in] The size of the information pointed to by the lpData parameter, in bytes. If the data is of type REG_SZ, REG_EXPAND_SZ, or REG_MULTI_SZ, cbData must include the size of the terminating null character or characters.

cchProgram is set to 28 characters without null termination. On my system(because of UNICODE I think?) cchProgram * sizeof(TCHAR) = 56.

Shouldn't I set it to 58 to add null termination?

---

When I run this program, as it is above, without any modifications and I'll check Calculator value in registry via Modify binary date I get:

43 00 3A 00 5C 00 57 00 C.:.\.W.
49 00 4E 00 44 00 4F 00 I.N.D.O.
57 00 53 00 5C 00 73 00 W.S.\.s.
79 00 73 00 74 00 65 00 y.s.t.e.
6D 00 33 00 32 00 5C 00 m.3.2.\.
63 00 61 00 6C 00 63 00 c.a.l.c.
2E 00 65 00 78 00 65 00 ..e.x.e.
00 00                   ..

Its 58 bytes including null termination. I'am confuse:/

UPDATE

Accounting for a NULL character by adding 1 to string length when calculating cbData yields exactly same result as without adding it.

cchProgram * sizeof(TCHAR) produces same data entry as (cchProgram + 1) * sizeof(TCHAR)

Providing value smaller then a string length doesn't add NULL byte and copies given number of bytes.

27 * sizeof(TCHAR) as cbData produces:

43 00 3A 00 5C 00 57 00 C.:.\.W.
49 00 4E 00 44 00 4F 00 I.N.D.O.
57 00 53 00 5C 00 73 00 W.S.\.s.
79 00 73 00 74 00 65 00 y.s.t.e.
6D 00 33 00 32 00 5C 00 m.3.2.\.
63 00 61 00 6C 00 63 00 c.a.l.c.
2E 00 65 00 78 00       ..e.x.

I am on some old XP, service pack god knows what, I don't know how other version of windows would handle it.

Answer 1

1: Yes, it will be null terminated without the need for \\0 .

Double quoted strings (") are literal constants whose type is in fact a null-terminated array of characters. So string literals enclosed between double quotes always have a null character ('\\0') automatically appended at the end.

2: _tcslen() doesn't include the null terminator. You can add sizeof(TCHAR) to add it.

The reason the value still works is probably because Windows tries to be robust even when given incorrect input. It is probably automatically appending the null terminator for you. However, because the documentation says you must include the null terminator it may not always append it.

Answer 2

When I define string is it automatically null terminated?

String literals are null-terminated, yes. "Hello" is actually {'H', 'e', 'l', 'l', 'o', '\\0'} .

In my code is final argument to RegSetValueEx set to correct value?

You're right that you need the null terminator. An easier way would be sizeof(TEXT("C:\\\\WINDOWS\\\\system32\\\\calc.exe")) if the string literal is short, since sizeof("Hello") is 6; it includes the null-terminator, but in most cases, you'll need your variable and will have to add one to the length you get from string character-counting functions, since they don't include the null-terminator.

Ben Voigt made an excellent point below that a const TCHAR[] program = TEXT("text"); can be used the same way as a literal in the call ( sizeof(program) ), but it a lot more maintainable when you want to change one less place in the code, which is a must for any actual project instead of a really small test, and even that can grow.

Finally, there are two things you should get out of your head early:

1. Hungarian notation: Don't do it. It's outdated and rather pointless.

2. TCHAR : Just use wide strings with any Windows API functions you can.

What you're doing absolutely right is checking function calls for errors. You wouldn't believe how many problems asked about can be solved by checking for failure and using GetLastError when the documentation says to.

---

Since you asked how you're supposed to use C++ facilities, here's one way, with a couple changes that make more sense for using C++:

#include <windows.h>

int main(){
    //R means raw string literal. Note one backslash
    std::cout << R"(Adding calc.exe to SOFTWARE\Microsoft\Windows\CurrentVersion\Run...)" << '\n';

    const WCHAR[] keyName = LR"(SOFTWARE\Microsoft\Windows\CurrentVersion\Run)");

    std::cout << "Enter program name: ";
    std::wstring keyValue;        
    if (!std::getline(std::wcin, keyValue)) {/*error*/}

    std::cout << "Enter full program path: ";
    std::wstring program;
    if (!std::getline(std::wcin, program)) {/*error*/}

    std::wcout << "Path: " << program << ".\n";
    std::cout << "Length: " << program.size() << ".\n";

    HKEY runKey;
    if(RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyName, 0, KEY_SET_VALUE, &runKey)) {/*error*/}

    if(RegSetValueExW(runKey, keyValue.c_str(), 0, REG_SZ, reinterpret_cast<const BYTE *>(program.c_str()), (program.size() + 1) * 2)) {
        std::cout << "ERROR: Can't set key value.\n";
        return 1;
    }

    if (RegCloseKey(runKey)) {/*error*/}

    std::cout << "Key has been added successfully.\n";

    std::cout << "Press enter to continue..."    
    std::cin.get();
}

A better way to do this using C++ idioms would be to at least have a RegKey RAII class that calls RegCloseKey in its destructor and saves you the work. At the very least, it could be used like this:

RegKey key(HKEY_LOCAL_MACHINE, keyName, KEY_SET_VALUE);
RegSetValueExW(key, ...); //could have implicit or explicit conversion, fill in the ...
//RegCloseKey called when key goes out of scope