← Older posts
09
10
26
 Leave a comment

Changing a Domain Password When Paste Fails in PowerShell

Posted by | Windows | Tagged |

While changing a domain administrator’s password in Windows PowerShell on a domain controller, I ran into a paste problem with Read-Host -AsSecureString. Typing a password manually worked, but pasting into the hidden prompt left the variable empty. Reading the clipboard with Get-Clipboard and converting its contents to a SecureString worked in the same session.

This is the procedure I used. It changes the password of the currently signed-in domain account and requires its existing password.

(more…)
30
09
26
 Leave a comment

How I Expanded the C: Drive on Windows 10

Posted by | Windows |

My Windows 10 C: drive was almost completely full. Its capacity was only about 31.45 GB, while Disk Management showed another 18 GB of unallocated space on the same disk. Expanding C: looked straightforward, but a small recovery partition stood in the way. Then disabling Windows Recovery Environment failed because the drive was too full.

(more…)
29
09
26
 Leave a comment

How to Set Up a Graphical Desktop on Ubuntu 24.04 and Connect from Windows via RDP

Posted by | Ubuntu |

This guide explains how to add a graphical desktop to an Ubuntu 24.04 VPS and access it using Windows Remote Desktop. The setup uses XFCE, xrdp, and a regular Linux user. RDP connections travel through an SSH tunnel, with xrdp listening only on localhost.

(more…)
25
09
26
 Leave a comment

An example when we don’t need std::shared_ptr in C++

Posted by | C++ |

In the previous example, independent components needed shared ownership of cached objects. For a TCP session, however, we can compare two designs: multiple callbacks keeping the session alive through std::shared_ptr, or a single owning coroutine using std::unique_ptr and structured concurrency. In the second design, reading and writing still run concurrently, but the owner waits for both operations to stop before destroying the session. No shared ownership or reference counting is needed.

(more…)
25
09
26
 1 Comment

An example when we really need std::shared_ptr in C++

Posted by | C++ |

A practical example of using std::shared_ptr, std::weak_ptr, and a custom deleter to implement a thread-safe object cache. Multiple independent components can share the same object by retrieving it by name. When the last owner releases its shared_ptr, the custom deleter automatically removes the corresponding entry from the cache and destroys the object.

This example demonstrates how shared ownership simplifies object lifetime management without requiring centralized tracking of individual users.

(more…)
01
09
26
 Leave a comment

An example of how GCC 13 optimizes std::memcpy

Posted by | C++ |

C++ code below demonstrates how GCC 13 optimizes std::memcpy and a temporary std::array:

#include <array>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <new>
#include <type_traits>

template <class T>
T* startLifetimeAs(void* const buffer)
{
    std::array<std::byte, sizeof(T)> representation;

    // Preserve the bytes before placement new ends the previous lifetime.
    std::memcpy(representation.data(), buffer, representation.size());

    // Start the lifetime of T in the original storage.
    T* const result = ::new (buffer) T;

    // Initialize the object representation of the newly created T.
    std::memcpy(result, representation.data(), representation.size());

    return result;
}
(more…)
27
08
26
 Leave a comment

How Placement New Ends an Object’s Lifetime

Posted by | C++ |

Below I provided an example demonstrating how placement new creates multiple objects within the same byte storage. Non-overlapping objects can coexist, while constructing an overlapping object ends the lifetime of the previously existing object. Accessing an object after its lifetime has ended causes undefined behavior.

#include <cstddef>
#include <cstdint>
#include <iostream>
#include <new>

struct Packet final
{
    std::uint64_t Data[4];
};

struct A final
{
    std::uint32_t First;
    std::uint32_t Second;
};

struct B final
{
    std::uint32_t First;
    std::uint32_t Second;
};

struct C final
{
    std::uint32_t Value;
};
(more…)
26
08
26
 2 Comments

Examples of Undefined Behavior Related to Type Accessibility in C++

Posted by | C++ |

From C++ standard:

Attempting to read or modify the stored value through any other type results in undefined behavior.

Any other type means type accessablity:

The first basic example illustrating this principle:

#include <cstdint>

std::uint32_t toInt(float value)
{
    auto* p = reinterpret_cast<std::uint32_t*>(&value); // The cast itself is permitted.
    return *p; // Undefined behavior: accesses a float object through a std::uint32_t glvalue.
}
(more…)
26
08
26
 Leave a comment

Violating strict aliasing with reinterpret_cast in C++

Posted by | C++ |

The first simple example:

#include <bit>
#include <cstdint>
#include <iomanip>
#include <iostream>

std::uint32_t badBits(const float value)
{
  // const prevents writes, but reading a float through a uint32_t pointer
  // still violates the strict-aliasing rule.
  const auto* bits = reinterpret_cast<const std::uint32_t*>(&value);
  return *bits; // Undefined behavior.
}

std::uint32_t goodBits(const float value)
{
  // std::bit_cast copies the object representation without violating
  // strict-aliasing or object-lifetime rules.
  return std::bit_cast<std::uint32_t>(value);
}

int main()
{
  constexpr float value = 1.0F;

  std::cout << std::hex
      << "bad:  0x" << badBits(value) << '\n'
      << "good: 0x" << goodBits(value) << '\n';
}
(more…)
22
05
26
 Leave a comment

Show RDP connections with credentials in PowerShell

Posted by | Network and Internet | 
Get-ChildItem `
'HKCU:\Software\Microsoft\Terminal Server Client\Servers' |
ForEach-Object {
    $p = Get-ItemProperty $_.PSPath

    [PSCustomObject]@{
        Server   = $_.PSChildName
        Username = $p.UsernameHint
    }
}
(more…)
← Older posts