}
Socket::Socket(int fd)
- : instream(0), outstream(0),
+ : instream(nullptr), outstream(nullptr),
isShutdown_(false), queryConnection(false)
{
initSockets();
}
Socket::Socket()
- : instream(0), outstream(0),
+ : instream(nullptr), outstream(nullptr),
isShutdown_(false), queryConnection(false)
{
initSockets();
}
SocketListener::SocketListener(int fd)
- : fd(fd), filter(0)
+ : fd(fd), filter(nullptr)
{
initSockets();
}
SocketListener::SocketListener()
- : fd(-1), filter(0)
+ : fd(-1), filter(nullptr)
{
initSockets();
}
int new_sock = -1;
// Accept an incoming connection
- if ((new_sock = ::accept(fd, 0, 0)) < 0)
+ if ((new_sock = ::accept(fd, nullptr, nullptr)) < 0)
throw SocketException("unable to accept new connection", errorNumber);
// Create the socket object & check connection is allowed
Socket* s = createSocket(new_sock);
if (filter && !filter->verifyConnection(s)) {
delete s;
- return NULL;
+ return nullptr;
}
return s;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
- hints.ai_canonname = NULL;
- hints.ai_addr = NULL;
- hints.ai_next = NULL;
+ hints.ai_canonname = nullptr;
+ hints.ai_addr = nullptr;
+ hints.ai_next = nullptr;
- if ((result = getaddrinfo(host, NULL, &hints, &ai)) != 0) {
+ if ((result = getaddrinfo(host, nullptr, &hints, &ai)) != 0) {
throw GAIException("unable to resolve host by name", result);
}
sock = -1;
err = 0;
- for (current = ai; current != NULL; current = current->ai_next) {
+ for (current = ai; current != nullptr; current = current->ai_next) {
int family;
vnc_sockaddr_t sa;
socklen_t salen;
else
sa.u.sin6.sin6_port = htons(port);
- getnameinfo(&sa.u.sa, salen, ntop, sizeof(ntop), NULL, 0, NI_NUMERICHOST);
+ getnameinfo(&sa.u.sa, salen, ntop, sizeof(ntop), nullptr, 0, NI_NUMERICHOST);
vlog.debug("Connecting to %s [%s] port %d", host, ntop, port);
sock = socket (family, SOCK_STREAM, 0);
buffer[0] = '[';
ret = getnameinfo(&sa.u.sa, sizeof(sa.u.sin6),
- buffer + 1, sizeof(buffer) - 2, NULL, 0,
+ buffer + 1, sizeof(buffer) - 2, nullptr, 0,
NI_NUMERICHOST);
if (ret != 0) {
vlog.error("unable to convert peer name to a string");
char *name;
name = inet_ntoa(sa.u.sin.sin_addr);
- if (name == NULL) {
+ if (name == nullptr) {
vlog.error("unable to convert peer name to a string");
return "(N/A)";
}
hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
- hints.ai_canonname = NULL;
- hints.ai_addr = NULL;
- hints.ai_next = NULL;
+ hints.ai_canonname = nullptr;
+ hints.ai_addr = nullptr;
+ hints.ai_next = nullptr;
// Windows doesn't like NULL for service, so specify something
- if ((getaddrinfo(NULL, "1", &hints, &ai)) != 0)
+ if ((getaddrinfo(nullptr, "1", &hints, &ai)) != 0)
return result;
- for (current= ai; current != NULL; current = current->ai_next) {
+ for (current= ai; current != nullptr; current = current->ai_next) {
char addr[INET6_ADDRSTRLEN];
switch (current->ai_family) {
}
getnameinfo(current->ai_addr, current->ai_addrlen, addr, INET6_ADDRSTRLEN,
- NULL, 0, NI_NUMERICHOST);
+ nullptr, 0, NI_NUMERICHOST);
result.push_back(addr);
}
ai[1].ai_family = sa[1].u.sin6.sin6_family;
ai[1].ai_addr = &sa[1].u.sa;
ai[1].ai_addrlen = sizeof(sa[1].u.sin6);
- ai[1].ai_next = NULL;
+ ai[1].ai_next = nullptr;
createTcpListeners(listeners, ai);
}
hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
- hints.ai_canonname = NULL;
- hints.ai_addr = NULL;
- hints.ai_next = NULL;
+ hints.ai_canonname = nullptr;
+ hints.ai_addr = nullptr;
+ hints.ai_next = nullptr;
snprintf (service, sizeof (service) - 1, "%d", port);
service[sizeof (service) - 1] = '\0';
initSockets();
- for (current = ai; current != NULL; current = current->ai_next) {
+ for (current = ai; current != nullptr; current = current->ai_next) {
switch (current->ai_family) {
case AF_INET:
if (!UseIPv4)
parts[0].erase(parts.size()-1, 1);
}
- if ((result = getaddrinfo (parts[0].c_str(), NULL, &hints, &ai)) != 0) {
+ if ((result = getaddrinfo (parts[0].c_str(), nullptr, &hints, &ai)) != 0) {
throw GAIException("unable to resolve host by name", result);
}
if (p.address.u.sa.sa_family == AF_INET) {
getnameinfo(&p.address.u.sa, sizeof(p.address.u.sin),
- addr, sizeof(addr), NULL, 0, NI_NUMERICHOST);
+ addr, sizeof(addr), nullptr, 0, NI_NUMERICHOST);
} else if (p.address.u.sa.sa_family == AF_INET6) {
addr[0] = '[';
getnameinfo(&p.address.u.sa, sizeof(p.address.u.sin6),
- addr + 1, sizeof(addr) - 2, NULL, 0, NI_NUMERICHOST);
+ addr + 1, sizeof(addr) - 2, nullptr, 0, NI_NUMERICHOST);
strcat(addr, "]");
} else
addr[0] = '\0';
int ret;
systemMutex = new pthread_mutex_t;
- ret = pthread_mutex_init((pthread_mutex_t*)systemMutex, NULL);
+ ret = pthread_mutex_init((pthread_mutex_t*)systemMutex, nullptr);
if (ret != 0)
throw rdr::SystemException("Failed to create mutex", ret);
#endif
int ret;
systemCondition = new pthread_cond_t;
- ret = pthread_cond_init((pthread_cond_t*)systemCondition, NULL);
+ ret = pthread_cond_init((pthread_cond_t*)systemCondition, nullptr);
if (ret != 0)
throw rdr::SystemException("Failed to create condition variable", ret);
#endif
using namespace os;
-Thread::Thread() : running(false), threadId(NULL)
+Thread::Thread() : running(false), threadId(nullptr)
{
mutex = new Mutex;
AutoMutex a(mutex);
#ifdef WIN32
- *(HANDLE*)threadId = CreateThread(NULL, 0, startRoutine, this, 0, NULL);
- if (*(HANDLE*)threadId == NULL)
+ *(HANDLE*)threadId = CreateThread(nullptr, 0, startRoutine, this, 0, nullptr);
+ if (*(HANDLE*)threadId == nullptr)
throw rdr::SystemException("Failed to create thread", GetLastError());
#else
int ret;
if (ret != 0)
throw rdr::SystemException("Failed to mask signals", ret);
- ret = pthread_create((pthread_t*)threadId, NULL, startRoutine, this);
+ ret = pthread_create((pthread_t*)threadId, nullptr, startRoutine, this);
- pthread_sigmask(SIG_SETMASK, &old, NULL);
+ pthread_sigmask(SIG_SETMASK, &old, nullptr);
if (ret != 0)
throw rdr::SystemException("Failed to create thread", ret);
#else
int ret;
- ret = pthread_join(*(pthread_t*)threadId, NULL);
+ ret = pthread_join(*(pthread_t*)threadId, nullptr);
if (ret != 0)
throw rdr::SystemException("Failed to join thread", ret);
#endif
self->running = false;
self->mutex->unlock();
+#ifdef WIN32
return 0;
+#else
+ return nullptr;
+#endif
}
#ifndef WIN32
homedir = getenv("HOME");
- if (homedir == NULL) {
+ if (homedir == nullptr) {
uid = getuid();
passwd = getpwuid(uid);
- if (passwd == NULL) {
+ if (passwd == nullptr) {
/* Do we want emit error msg here? */
- return NULL;
+ return nullptr;
}
homedir = passwd->pw_dir;
}
return homedir;
xdgdir = getenv(xdg_env);
- if (xdgdir != NULL && xdgdir[0] == '/')
+ if (xdgdir != nullptr && xdgdir[0] == '/')
snprintf(dir, sizeof(dir), "%s/tigervnc", xdgdir);
else
snprintf(dir, sizeof(dir), "%s/%s/tigervnc", homedir, xdg_def);
(void) xdg_env;
if (userDir)
- ret = SHGetSpecialFolderPath(NULL, dir, CSIDL_PROFILE, FALSE);
+ ret = SHGetSpecialFolderPath(nullptr, dir, CSIDL_PROFILE, FALSE);
else
- ret = SHGetSpecialFolderPath(NULL, dir, CSIDL_APPDATA, FALSE);
+ ret = SHGetSpecialFolderPath(nullptr, dir, CSIDL_APPDATA, FALSE);
if (ret == FALSE)
- return NULL;
+ return nullptr;
if (userDir)
return dir;
- ret = SHGetSpecialFolderPath(NULL, legacy, CSIDL_APPDATA, FALSE);
+ ret = SHGetSpecialFolderPath(nullptr, legacy, CSIDL_APPDATA, FALSE);
if (ret == FALSE)
- return NULL;
+ return nullptr;
if (strlen(dir) + strlen("\\TigerVNC") >= sizeof(dir))
- return NULL;
+ return nullptr;
if (strlen(legacy) + strlen("\\vnc") >= sizeof(legacy))
- return NULL;
+ return nullptr;
strcat(dir, "\\TigerVNC");
strcat(legacy, "\\vnc");
const char* os::getuserhomedir()
{
- return getvncdir(true, NULL, NULL);
+ return getvncdir(true, nullptr, nullptr);
}
const char* os::getvncconfigdir()
: bufSize(DEFAULT_BUF_SIZE), offset(0)
{
ptr = end = start = new uint8_t[bufSize];
- gettimeofday(&lastSizeCheck, NULL);
+ gettimeofday(&lastSizeCheck, nullptr);
peakUsage = 0;
}
end = newBuffer + (end - ptr);
ptr = start = newBuffer;
- gettimeofday(&lastSizeCheck, NULL);
+ gettimeofday(&lastSizeCheck, nullptr);
peakUsage = needed;
}
peakUsage = needed;
// Time to shrink an excessive buffer?
- gettimeofday(&now, NULL);
+ gettimeofday(&now, nullptr);
if ((avail() == 0) && (bufSize > DEFAULT_BUF_SIZE) &&
((now.tv_sec < lastSizeCheck.tv_sec) ||
(now.tv_sec > (lastSizeCheck.tv_sec + 5)))) {
bufSize = newSize;
}
- gettimeofday(&lastSizeCheck, NULL);
+ gettimeofday(&lastSizeCheck, nullptr);
peakUsage = needed;
}
{
ptr = start = sentUpTo = new uint8_t[bufSize];
end = start + bufSize;
- gettimeofday(&lastSizeCheck, NULL);
+ gettimeofday(&lastSizeCheck, nullptr);
peakUsage = 0;
}
ptr = sentUpTo = start;
// Time to shrink an excessive buffer?
- gettimeofday(&now, NULL);
+ gettimeofday(&now, nullptr);
if ((sentUpTo == ptr) && (bufSize > DEFAULT_BUF_SIZE) &&
((now.tv_sec < lastSizeCheck.tv_sec) ||
(now.tv_sec > (lastSizeCheck.tv_sec + 5)))) {
bufSize = newSize;
}
- gettimeofday(&lastSizeCheck, NULL);
+ gettimeofday(&lastSizeCheck, nullptr);
peakUsage = 0;
}
}
sentUpTo = start = newBuffer;
end = newBuffer + newSize;
- gettimeofday(&lastSizeCheck, NULL);
+ gettimeofday(&lastSizeCheck, nullptr);
peakUsage = totalNeeded;
return;
wchar_t *currStr = new wchar_t[len-strlen(str_)];
wcsncpy(currStr, gai_strerrorW(err), len-1-strlen(str_));
WideCharToMultiByte(CP_UTF8, 0, currStr, -1, str_+strlen(str_),
- len-1-strlen(str_), 0, 0);
+ len-1-strlen(str_), nullptr, nullptr);
delete [] currStr;
#else
strncat(str_, gai_strerror(err), len-1-strlen(str_));
#ifdef _WIN32
wchar_t *currStr = new wchar_t[len-strlen(str_)];
FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
- 0, err, 0, currStr, len-1-strlen(str_), 0);
+ nullptr, err, 0, currStr, len-1-strlen(str_), nullptr);
WideCharToMultiByte(CP_UTF8, 0, currStr, -1, str_+strlen(str_),
- len-1-strlen(str_), 0, 0);
+ len-1-strlen(str_), nullptr, nullptr);
delete [] currStr;
int l = strlen(str_);
struct Exception {
enum { len = 256 };
char str_[len];
- Exception(const char *format = 0, ...)
+ Exception(const char *format=nullptr, ...)
__attribute__((__format__ (__printf__, 2, 3)));
virtual ~Exception() {}
virtual const char* str() const { return str_; }
FD_ZERO(&fds);
FD_SET(fd, &fds);
- n = select(fd+1, &fds, 0, 0, &tv);
+ n = select(fd+1, &fds, nullptr, nullptr, &tv);
} while (n < 0 && errorNumber == EINTR);
if (n < 0)
#endif
fd(fd_)
{
- gettimeofday(&lastWrite, NULL);
+ gettimeofday(&lastWrite, nullptr);
}
FdOutStream::~FdOutStream()
FD_ZERO(&fds);
FD_SET(fd, &fds);
- n = select(fd+1, 0, &fds, 0, &tv);
+ n = select(fd+1, nullptr, &fds, nullptr, &tv);
} while (n < 0 && errorNumber == EINTR);
if (n < 0)
if (n < 0)
throw SystemException("write", errorNumber);
- gettimeofday(&lastWrite, NULL);
+ gettimeofday(&lastWrite, nullptr);
return n;
}
FileInStream::~FileInStream(void) {
if (file) {
fclose(file);
- file = NULL;
+ file = nullptr;
}
}
#endif
if (length > (size_t)(end - ptr)) {
- if (restorePoint != NULL) {
+ if (restorePoint != nullptr) {
bool ret;
size_t restoreDiff;
inline void setRestorePoint() {
#ifdef RFB_INSTREAM_CHECK
- if (restorePoint != NULL)
+ if (restorePoint != nullptr)
throw Exception("Nested use of input stream restore point");
#endif
restorePoint = ptr;
}
inline void clearRestorePoint() {
#ifdef RFB_INSTREAM_CHECK
- if (restorePoint == NULL)
+ if (restorePoint == nullptr)
throw Exception("Incorrect clearing of input stream restore point");
#endif
- restorePoint = NULL;
+ restorePoint = nullptr;
}
inline void gotoRestorePoint() {
#ifdef RFB_INSTREAM_CHECK
- if (restorePoint == NULL)
+ if (restorePoint == nullptr)
throw Exception("Incorrect activation of input stream restore point");
#endif
ptr = restorePoint;
protected:
- InStream() : restorePoint(NULL)
+ InStream() : restorePoint(nullptr)
#ifdef RFB_INSTREAM_CHECK
,checkedBytes(0)
#endif
protected:
- OutStream() : ptr(NULL), end(NULL), corked(false) {}
+ OutStream() : ptr(nullptr), end(nullptr), corked(false) {}
public:
{
#ifdef RFB_HAVE_WINCRYPT
provider = 0;
- if (!CryptAcquireContext(&provider, 0, 0, PROV_RSA_FULL, 0)) {
+ if (!CryptAcquireContext(&provider, nullptr, nullptr,
+ PROV_RSA_FULL, 0)) {
if (GetLastError() == (DWORD)NTE_BAD_KEYSET) {
- if (!CryptAcquireContext(&provider, 0, 0, PROV_RSA_FULL, CRYPT_NEWKEYSET)) {
+ if (!CryptAcquireContext(&provider, nullptr, nullptr,
+ PROV_RSA_FULL, CRYPT_NEWKEYSET)) {
vlog.error("unable to create keyset");
provider = 0;
}
#endif
#endif
vlog.error("no OS supplied random source - using rand()");
- seed += (unsigned int) time(0) + getpid() + getpid() * 987654 + rand();
+ seed += (unsigned int) time(nullptr) + getpid() + getpid() * 987654 + rand();
srand(seed);
}
}
self->streamEmpty = false;
delete self->saved_exception;
- self->saved_exception = NULL;
+ self->saved_exception = nullptr;
try {
if (!in->hasData(1)) {
}
TLSInStream::TLSInStream(InStream* _in, gnutls_session_t _session)
- : session(_session), in(_in), saved_exception(NULL)
+ : session(_session), in(_in), saved_exception(nullptr)
{
gnutls_transport_ptr_t recv, send;
TLSInStream::~TLSInStream()
{
- gnutls_transport_set_pull_function(session, NULL);
+ gnutls_transport_set_pull_function(session, nullptr);
delete saved_exception;
}
OutStream *out = self->out;
delete self->saved_exception;
- self->saved_exception = NULL;
+ self->saved_exception = nullptr;
try {
out->writeBytes((const uint8_t*)data, size);
}
TLSOutStream::TLSOutStream(OutStream* _out, gnutls_session_t _session)
- : session(_session), out(_out), saved_exception(NULL)
+ : session(_session), out(_out), saved_exception(nullptr)
{
gnutls_transport_ptr_t recv, send;
} catch (Exception&) {
}
#endif
- gnutls_transport_set_push_function(session, NULL);
+ gnutls_transport_set_push_function(session, nullptr);
delete saved_exception;
}
using namespace rdr;
ZlibInStream::ZlibInStream()
- : underlying(0), zs(NULL), bytesIn(0)
+ : underlying(nullptr), zs(nullptr), bytesIn(0)
{
init();
}
skip(avail());
}
- setUnderlying(NULL, 0);
+ setUnderlying(nullptr, 0);
}
void ZlibInStream::reset()
void ZlibInStream::init()
{
- assert(zs == NULL);
+ assert(zs == nullptr);
zs = new z_stream;
- zs->zalloc = Z_NULL;
- zs->zfree = Z_NULL;
- zs->opaque = Z_NULL;
- zs->next_in = Z_NULL;
+ zs->zalloc = nullptr;
+ zs->zfree = nullptr;
+ zs->opaque = nullptr;
+ zs->next_in = nullptr;
zs->avail_in = 0;
if (inflateInit(zs) != Z_OK) {
delete zs;
- zs = NULL;
+ zs = nullptr;
throw Exception("ZlibInStream: inflateInit failed");
}
}
void ZlibInStream::deinit()
{
- assert(zs != NULL);
- setUnderlying(NULL, 0);
+ assert(zs != nullptr);
+ setUnderlying(nullptr, 0);
inflateEnd(zs);
delete zs;
- zs = NULL;
+ zs = nullptr;
}
bool ZlibInStream::fillBuffer()
: underlying(os), compressionLevel(compressLevel), newLevel(compressLevel)
{
zs = new z_stream;
- zs->zalloc = Z_NULL;
- zs->zfree = Z_NULL;
- zs->opaque = Z_NULL;
- zs->next_in = Z_NULL;
+ zs->zalloc = nullptr;
+ zs->zfree = nullptr;
+ zs->opaque = nullptr;
+ zs->next_in = nullptr;
zs->avail_in = 0;
if (deflateInit(zs, compressLevel) != Z_OK) {
delete zs;
void ZlibOutStream::flush()
{
BufferedOutStream::flush();
- if (underlying != NULL)
+ if (underlying != nullptr)
underlying->flush();
}
void ZlibOutStream::cork(bool enable)
{
BufferedOutStream::cork(enable);
- if (underlying != NULL)
+ if (underlying != nullptr)
underlying->cork(enable);
}
public:
- ZlibOutStream(OutStream* os=0, int compressionLevel=-1);
+ ZlibOutStream(OutStream* os=nullptr, int compressionLevel=-1);
virtual ~ZlibOutStream();
void setUnderlying(OutStream* os);
// Entry exists - has it reached the threshold yet?
if ((*i).second.marks >= threshold) {
// Yes - entry is blocked - has the timeout expired?
- time_t now = time(0);
+ time_t now = time(nullptr);
if (now >= (*i).second.blockUntil) {
// Timeout has expired. Reset timeout and allow
// a re-try.
static LogWriter vlog("CConnection");
CConnection::CConnection()
- : csecurity(0),
+ : csecurity(nullptr),
supportsLocalCursor(false), supportsCursorPosition(false),
supportsDesktopResize(false), supportsLEDState(false),
- is(0), os(0), reader_(0), writer_(0),
+ is(nullptr), os(nullptr), reader_(nullptr), writer_(nullptr),
shared(false),
state_(RFBSTATE_UNINITIALISED),
pendingPFChange(false), preferredEncoding(encodingTight),
formatChange(false), encodingChange(false),
firstUpdate(true), pendingUpdate(false), continuousUpdates(false),
forceNonincremental(true),
- framebuffer(NULL), decoder(this),
+ framebuffer(nullptr), decoder(this),
hasRemoteClipboard(false), hasLocalClipboard(false)
{
}
void CConnection::setServerName(const char* name_)
{
- if (name_ == NULL)
+ if (name_ == nullptr)
name_ = "";
serverName = name_;
}
assert(fb->height() == server.height());
}
- if ((framebuffer != NULL) && (fb != NULL)) {
+ if ((framebuffer != nullptr) && (fb != nullptr)) {
Rect rect;
const uint8_t* data;
vlog.error("%s", e.str());
}
- setFramebuffer(NULL);
+ setFramebuffer(nullptr);
delete csecurity;
- csecurity = NULL;
+ csecurity = nullptr;
delete reader_;
- reader_ = NULL;
+ reader_ = nullptr;
delete writer_;
- writer_ = NULL;
+ writer_ = nullptr;
}
void CConnection::setDesktopSize(int w, int h)
server.height());
resizeFramebuffer();
- assert(framebuffer != NULL);
+ assert(framebuffer != nullptr);
assert(framebuffer->width() == server.width());
assert(framebuffer->height() == server.height());
}
server.height());
resizeFramebuffer();
- assert(framebuffer != NULL);
+ assert(framebuffer != nullptr);
assert(framebuffer->width() == server.width());
assert(framebuffer->height() == server.height());
}
vlog.debug("initialisation done");
initDone();
- assert(framebuffer != NULL);
+ assert(framebuffer != nullptr);
assert(framebuffer->width() == server.width());
assert(framebuffer->height() == server.height());
{
CMsgHandler::framebufferUpdateStart();
- assert(framebuffer != NULL);
+ assert(framebuffer != nullptr);
// Note: This might not be true if continuous updates are supported
pendingUpdate = false;
}
zis.flushUnderlying();
- zis.setUnderlying(NULL, 0);
+ zis.setUnderlying(nullptr, 0);
handler->handleClipboardProvide(flags, lengths, buffers);
void CMsgWriter::writeClientCutText(const char* str)
{
- if (strchr(str, '\r') != NULL)
+ if (strchr(str, '\r') != nullptr)
throw Exception("Invalid carriage return in clipboard data");
std::string latin1(utf8ToLatin1(str));
: CSecurity(cc), state(ReadPublicKey),
keySize(_keySize), isAllEncrypted(_isAllEncrypted), secType(_secType),
clientKey(), clientPublicKey(), serverKey(),
- serverKeyN(NULL), serverKeyE(NULL),
- clientKeyN(NULL), clientKeyE(NULL),
- rais(NULL), raos(NULL), rawis(NULL), rawos(NULL)
+ serverKeyN(nullptr), serverKeyE(nullptr),
+ clientKeyN(nullptr), clientKeyE(nullptr),
+ rais(nullptr), raos(nullptr), rawis(nullptr), rawos(nullptr)
{
assert(keySize == 128 || keySize == 256);
}
// set e = 65537
mpz_set_ui(clientPublicKey.e, 65537);
if (!rsa_generate_keypair(&clientPublicKey, &clientKey,
- &rs, random_func, NULL, NULL, clientKeyLength, 0))
+ &rs, random_func, nullptr, nullptr,
+ clientKeyLength, 0))
throw AuthFailureException("failed to generate key");
clientKeyN = new uint8_t[rsaKeySize];
clientKeyE = new uint8_t[rsaKeySize];
delete[] serverKeyE;
delete[] clientKeyN;
delete[] clientKeyE;
- serverKeyN = NULL;
- serverKeyE = NULL;
- clientKeyN = NULL;
- clientKeyE = NULL;
+ serverKeyN = nullptr;
+ serverKeyE = nullptr;
+ clientKeyN = nullptr;
+ clientKeyE = nullptr;
memset(serverRandom, 0, sizeof(serverRandom));
memset(clientRandom, 0, sizeof(clientRandom));
}
if (subtype == secTypeRA2UserPass)
(CSecurity::upg)->getUserPasswd(isSecure(), &username, &password);
else
- (CSecurity::upg)->getUserPasswd(isSecure(), NULL, &password);
+ (CSecurity::upg)->getUserPasswd(isSecure(), nullptr, &password);
if (subtype == secTypeRA2UserPass) {
if (username.size() > 255)
class CSecurityStack : public CSecurity {
public:
CSecurityStack(CConnection* cc, int Type,
- CSecurity* s0 = NULL, CSecurity* s1 = NULL);
+ CSecurity* s0 = nullptr, CSecurity* s1 = nullptr);
~CSecurityStack();
virtual bool processMsg();
virtual int getType() const {return type;};
const char* configdir;
configdir = os::getvncconfigdir();
- if (configdir == NULL)
+ if (configdir == nullptr)
return "";
snprintf(full_path, sizeof(full_path), "%s/%s", configdir, fn);
}
CSecurityTLS::CSecurityTLS(CConnection* cc, bool _anon)
- : CSecurity(cc), session(NULL), anon_cred(NULL), cert_cred(NULL),
- anon(_anon), tlsis(NULL), tlsos(NULL), rawis(NULL), rawos(NULL)
+ : CSecurity(cc), session(nullptr),
+ anon_cred(nullptr), cert_cred(nullptr),
+ anon(_anon), tlsis(nullptr), tlsos(nullptr),
+ rawis(nullptr), rawos(nullptr)
{
if (gnutls_global_init() != GNUTLS_E_SUCCESS)
throw AuthFailureException("gnutls_global_init failed");
if (anon_cred) {
gnutls_anon_free_client_credentials(anon_cred);
- anon_cred = 0;
+ anon_cred = nullptr;
}
if (cert_cred) {
gnutls_certificate_free_credentials(cert_cred);
- cert_cred = 0;
+ cert_cred = nullptr;
}
if (rawis && rawos) {
cc->setStreams(rawis, rawos);
- rawis = NULL;
- rawos = NULL;
+ rawis = nullptr;
+ rawos = nullptr;
}
if (tlsis) {
delete tlsis;
- tlsis = NULL;
+ tlsis = nullptr;
}
if (tlsos) {
delete tlsos;
- tlsos = NULL;
+ tlsos = nullptr;
}
if (session) {
gnutls_deinit(session);
- session = 0;
+ session = nullptr;
}
}
prio = (char*)malloc(strlen(Security::GnuTLSPriority) +
strlen(kx_anon_priority) + 1);
- if (prio == NULL)
+ if (prio == nullptr)
throw AuthFailureException("Not enough memory for GnuTLS priority string");
strcpy(prio, Security::GnuTLSPriority);
prio = (char*)malloc(strlen(gnutls_default_priority) +
strlen(kx_anon_priority) + 1);
- if (prio == NULL)
+ if (prio == nullptr)
throw AuthFailureException("Not enough memory for GnuTLS priority string");
strcpy(prio, gnutls_default_priority);
/* Certificate has some user overridable problems, so TOFU time */
hostsDir = os::getvncstatedir();
- if (hostsDir == NULL) {
+ if (hostsDir == nullptr) {
throw AuthFailureException("Could not obtain VNC state directory "
"path for known hosts storage");
}
std::string dbPath;
dbPath = (std::string)hostsDir + "/x509_known_hosts";
- err = gnutls_verify_stored_pubkey(dbPath.c_str(), NULL,
- client->getServerName(), NULL,
+ err = gnutls_verify_stored_pubkey(dbPath.c_str(), nullptr,
+ client->getServerName(), nullptr,
GNUTLS_CRT_X509, &cert_list[0], 0);
/* Previously known? */
}
}
- if (gnutls_store_pubkey(dbPath.c_str(), NULL, client->getServerName(),
- NULL, GNUTLS_CRT_X509, &cert_list[0], 0, 0))
+ if (gnutls_store_pubkey(dbPath.c_str(), nullptr,
+ client->getServerName(), nullptr,
+ GNUTLS_CRT_X509, &cert_list[0], 0, 0))
vlog.error("Failed to store server certificate to known hosts database");
vlog.info("Exception added for server host");
static LogWriter vlog("CVeNCrypt");
CSecurityVeNCrypt::CSecurityVeNCrypt(CConnection* cc, SecurityClient* sec)
- : CSecurity(cc), csecurity(NULL), security(sec)
+ : CSecurity(cc), csecurity(nullptr), security(sec)
{
haveRecvdMajorVersion = false;
haveRecvdMinorVersion = false;
minorVersion = 0;
chosenType = secTypeVeNCrypt;
nAvailableTypes = 0;
- availableTypes = NULL;
+ availableTypes = nullptr;
}
CSecurityVeNCrypt::~CSecurityVeNCrypt()
uint8_t challenge[vncAuthChallengeSize];
is->readBytes(challenge, vncAuthChallengeSize);
std::string passwd;
- (CSecurity::upg)->getUserPasswd(cc->isSecure(), 0, &passwd);
+ (CSecurity::upg)->getUserPasswd(cc->isSecure(), nullptr, &passwd);
// Calculate the correct response
uint8_t key[8];
{
setName("");
- cursor_ = new Cursor(0, 0, Point(), NULL);
+ cursor_ = new Cursor(0, 0, Point(), nullptr);
clipFlags = clipboardUTF8 | clipboardRTF | clipboardHTML |
clipboardRequest | clipboardNotify | clipboardProvide;
// -=- The Global/server/viewer Configuration objects
-Configuration* Configuration::global_ = 0;
-Configuration* Configuration::server_ = 0;
-Configuration* Configuration::viewer_ = 0;
+Configuration* Configuration::global_ = nullptr;
+Configuration* Configuration::server_ = nullptr;
+Configuration* Configuration::viewer_ = nullptr;
Configuration* Configuration::global() {
if (!global_)
return current;
current = current->_next;
}
- return _next ? _next->get(param) : 0;
+ return _next ? _next->get(param) : nullptr;
}
void Configuration::list(int width, int nameWidth) {
ConfigurationObject co)
: immutable(false), name(name_), description(desc_)
{
- Configuration *conf = NULL;
+ Configuration *conf = nullptr;
switch (co) {
case ConfGlobal: conf = Configuration::global();
bool
IntParameter::setParam(const char* v) {
if (immutable) return true;
- return setParam(strtol(v, NULL, 0));
+ return setParam(strtol(v, nullptr, 0));
}
bool
BinaryParameter::BinaryParameter(const char* name_, const char* desc_,
const uint8_t* v, size_t l, ConfigurationObject co)
-: VoidParameter(name_, desc_, co), value(0), length(0), def_value(0), def_length(0) {
+: VoidParameter(name_, desc_, co),
+ value(nullptr), length(0), def_value(nullptr), def_length(0) {
if (l) {
assert(v);
value = new uint8_t[l];
if (immutable) return;
vlog.debug("set %s(Binary)", getName());
delete [] value;
- value = NULL;
+ value = nullptr;
length = 0;
if (len) {
assert(v);
class Configuration {
public:
// - Create a new Configuration object
- Configuration(const char* name_) : name(name_), head(0), _next(0) {}
+ Configuration(const char* name_)
+ : name(name_), head(nullptr), _next(nullptr) {}
// - Return the buffer containing the Configuration's name
const char* getName() const { return name.c_str(); }
baseRTT(-1), congWindow(INITIAL_WINDOW), inSlowStart(true),
safeBaseRTT(-1), measurements(0), minRTT(-1), minCongestedRTT(-1)
{
- gettimeofday(&lastUpdate, NULL);
- gettimeofday(&lastSent, NULL);
+ gettimeofday(&lastUpdate, nullptr);
+ gettimeofday(&lastSent, nullptr);
memset(&lastPong, 0, sizeof(lastPong));
- gettimeofday(&lastPongArrival, NULL);
- gettimeofday(&lastAdjustment, NULL);
+ gettimeofday(&lastPongArrival, nullptr);
+ gettimeofday(&lastAdjustment, nullptr);
}
Congestion::~Congestion()
struct timeval now;
unsigned delta, consumed;
- gettimeofday(&now, NULL);
+ gettimeofday(&now, nullptr);
delta = pos - lastPosition;
if ((delta > 0) || (extraBuffer > 0))
congWindow = __rfbmin(INITIAL_WINDOW, congWindow);
baseRTT = -1;
measurements = 0;
- gettimeofday(&lastAdjustment, NULL);
+ gettimeofday(&lastAdjustment, nullptr);
minRTT = minCongestedRTT = -1;
inSlowStart = true;
}
memset(&rttInfo, 0, sizeof(struct RTTInfo));
- gettimeofday(&rttInfo.tv, NULL);
+ gettimeofday(&rttInfo.tv, nullptr);
rttInfo.pos = lastPosition;
rttInfo.extra = getExtraBuffer();
rttInfo.congested = isCongested();
if (pings.empty())
return;
- gettimeofday(&now, NULL);
+ gettimeofday(&now, nullptr);
rttInfo = pings.front();
pings.pop_front();
#ifdef __linux__
FILE *f;
f = fopen(filename, "ab");
- if (f != NULL) {
+ if (f != nullptr) {
struct tcp_info info;
int buffered;
socklen_t len;
TCP_INFO, &info, &len) == 0) &&
(ioctl(fd, SIOCOUTQ, &buffered) == 0)) {
struct timeval now;
- gettimeofday(&now, NULL);
+ gettimeofday(&now, nullptr);
fprintf(f, "%u.%06u,%u,%u,%u,%u\n",
(unsigned)now.tv_sec, (unsigned)now.tv_usec,
congWindow, info.tcpi_snd_cwnd * info.tcpi_snd_mss,
#endif
measurements = 0;
- gettimeofday(&lastAdjustment, NULL);
+ gettimeofday(&lastAdjustment, nullptr);
minRTT = minCongestedRTT = -1;
}
static LogWriter vlog("DecodeManager");
DecodeManager::DecodeManager(CConnection *conn) :
- conn(conn), threadException(NULL)
+ conn(conn), threadException(nullptr)
{
size_t cpuCount;
QueueEntry *entry;
- assert(pb != NULL);
+ assert(pb != nullptr);
if (!Decoder::supported(encoding)) {
vlog.error("Unknown encoding %d", encoding);
{
os::AutoMutex a(queueMutex);
- if (threadException != NULL)
+ if (threadException != nullptr)
return;
threadException = new rdr::Exception("Exception on worker thread: %s", e.str());
{
os::AutoMutex a(queueMutex);
- if (threadException == NULL)
+ if (threadException == nullptr)
return;
rdr::Exception e(*threadException);
delete threadException;
- threadException = NULL;
+ threadException = nullptr;
throw e;
}
// Look for an available entry in the work queue
entry = findEntry();
- if (entry == NULL) {
+ if (entry == nullptr) {
// Wait and try again
manager->consumerCond->wait();
continue;
Region lockedRegion;
if (manager->workQueue.empty())
- return NULL;
+ return nullptr;
if (!manager->workQueue.front()->active)
return manager->workQueue.front();
lockedRegion.assign_union(entry->affectedRegion);
}
- return NULL;
+ return nullptr;
}
return new H264Decoder();
#endif
default:
- return NULL;
+ return nullptr;
}
}
{
StatsVector::iterator iter;
- encoders.resize(encoderClassMax, NULL);
+ encoders.resize(encoderClassMax, nullptr);
activeEncoders.resize(encoderTypeMax, encoderRaw);
encoders[encoderRaw] = new RawEncoder(conn);
* We need to render the cursor seperately as it has its own
* magical pixel buffer, so split it out from the changed region.
*/
- if (renderedCursor != NULL) {
+ if (renderedCursor != nullptr) {
cursorRegion = changed.intersect(renderedCursor->getEffectiveRect());
changed.assign_subtract(renderedCursor->getEffectiveRect());
}
for (std::deque<H264DecoderContext*>::iterator it = contexts.begin(); it != contexts.end(); it++)
if ((*it)->isEqualRect(r))
return *it;
- return NULL;
+ return nullptr;
}
bool H264Decoder::readRect(const Rect& /*r*/,
uint32_t len = is.readU32();
uint32_t flags = is.readU32();
- H264DecoderContext* ctx = NULL;
+ H264DecoderContext* ctx = nullptr;
if (flags & resetAllContexts)
{
resetContexts();
bool H264LibavDecoderContext::initCodec() {
os::AutoMutex lock(&mutex);
- sws = NULL;
- swsBuffer = NULL;
- h264WorkBuffer = NULL;
+ sws = nullptr;
+ swsBuffer = nullptr;
+ h264WorkBuffer = nullptr;
h264WorkBufferLength = 0;
const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264);
return false;
}
- if (avcodec_open2(avctx, codec, NULL) < 0)
+ if (avcodec_open2(avctx, codec, nullptr) < 0)
{
av_parser_close(parser);
avcodec_free_context(&avctx);
if (!h264WorkBuffer || reserve_len > h264WorkBufferLength)
{
h264WorkBuffer = (uint8_t*)realloc(h264WorkBuffer, reserve_len);
- if (h264WorkBuffer == NULL) {
+ if (h264WorkBuffer == nullptr) {
throw Exception("H264LibavDecoderContext: Unable to allocate memory");
}
h264WorkBufferLength = reserve_len;
#ifdef FFMPEG_INIT_PACKET_DEPRECATED
packet->size = 0;
- packet->data = NULL;
+ packet->data = nullptr;
av_packet_free(&packet);
#else
delete packet;
sws = sws_getCachedContext(sws, frame->width, frame->height, avctx->pix_fmt,
frame->width, frame->height, AV_PIX_FMT_RGB32,
- 0, NULL, NULL, NULL);
+ 0, nullptr, nullptr, nullptr);
int stride;
pb->getBuffer(rect, &stride);
#include <mfapi.h>
#include <mferror.h>
#include <wmcodecdsp.h>
-#define SAFE_RELEASE(obj) if (obj) { obj->Release(); obj = NULL; }
+#define SAFE_RELEASE(obj) if (obj) { obj->Release(); obj = nullptr; }
#include <os/Mutex.h>
#include <rfb/LogWriter.h>
return false;
}
- if (FAILED(CoCreateInstance(CLSID_CMSH264DecoderMFT, NULL, CLSCTX_INPROC_SERVER, IID_IMFTransform, (LPVOID*)&decoder)))
+ if (FAILED(CoCreateInstance(CLSID_CMSH264DecoderMFT, nullptr, CLSCTX_INPROC_SERVER, IID_IMFTransform, (LPVOID*)&decoder)))
{
vlog.error("MediaFoundation H264 codec not found");
return false;
}
GUID CLSID_VideoProcessorMFT = { 0x88753b26, 0x5b24, 0x49bd, { 0xb2, 0xe7, 0xc, 0x44, 0x5c, 0x78, 0xc9, 0x82 } };
- if (FAILED(CoCreateInstance(CLSID_VideoProcessorMFT, NULL, CLSCTX_INPROC_SERVER, IID_IMFTransform, (LPVOID*)&converter)))
+ if (FAILED(CoCreateInstance(CLSID_VideoProcessorMFT, nullptr, CLSCTX_INPROC_SERVER, IID_IMFTransform, (LPVOID*)&converter)))
{
vlog.error("Cannot create MediaFoundation Video Processor (available only on Windows 8+). Trying ColorConvert DMO.");
- if (FAILED(CoCreateInstance(CLSID_CColorConvertDMO, NULL, CLSCTX_INPROC_SERVER, IID_IMFTransform, (LPVOID*)&converter)))
+ if (FAILED(CoCreateInstance(CLSID_CColorConvertDMO, nullptr, CLSCTX_INPROC_SERVER, IID_IMFTransform, (LPVOID*)&converter)))
{
decoder->Release();
vlog.error("ColorConvert DMO not found");
// set decoder output type (NV12)
DWORD output_index = 0;
- IMFMediaType* output_type = NULL;
+ IMFMediaType* output_type = nullptr;
while (SUCCEEDED(decoder->GetOutputAvailableType(0, output_index++, &output_type)))
{
GUID subtype;
}
BYTE* locked;
- input_buffer->Lock(&locked, NULL, NULL);
+ input_buffer->Lock(&locked, nullptr, nullptr);
memcpy(locked, h264_buffer, len);
input_buffer->Unlock();
decoded_data.dwStreamID = 0;
decoded_data.pSample = decoded_sample;
decoded_data.dwStatus = 0;
- decoded_data.pEvents = NULL;
+ decoded_data.pEvents = nullptr;
DWORD status;
HRESULT hr = decoder->ProcessOutput(0, 1, &decoded_data, &status);
// need to setup output type and try decoding again
DWORD output_index = 0;
- IMFMediaType* output_type = NULL;
+ IMFMediaType* output_type = nullptr;
while (SUCCEEDED(decoder->GetOutputAvailableType(0, output_index++, &output_type)))
{
GUID subtype;
break;
}
output_type->Release();
- output_type = NULL;
+ output_type = nullptr;
}
// reinitialize output type (NV12) that now has correct properties (width/height/framerate)
converted_data.dwStreamID = 0;
converted_data.pSample = converted_sample;
converted_data.dwStatus = 0;
- converted_data.pEvents = NULL;
+ converted_data.pEvents = nullptr;
DWORD status;
HRESULT hr = converter->ProcessOutput(0, 1, &converted_data, &status);
BYTE* out;
DWORD len;
- converted_buffer->Lock(&out, NULL, &len);
+ converted_buffer->Lock(&out, nullptr, &len);
pb->imageRect(rect, out + offset_y * stride + offset_x * 4, (int)stride / 4);
converted_buffer->Unlock();
}
uint32_t crop_height = 0;
uint32_t offset_x = 0;
uint32_t offset_y = 0;
- IMFTransform *decoder = NULL;
- IMFTransform *converter = NULL;
- IMFSample *input_sample = NULL;
- IMFSample *decoded_sample = NULL;
- IMFSample *converted_sample = NULL;
- IMFMediaBuffer *input_buffer = NULL;
- IMFMediaBuffer *decoded_buffer = NULL;
- IMFMediaBuffer *converted_buffer = NULL;
+ IMFTransform *decoder = nullptr;
+ IMFTransform *converter = nullptr;
+ IMFSample *input_sample = nullptr;
+ IMFSample *decoded_sample = nullptr;
+ IMFSample *converted_sample = nullptr;
+ IMFMediaBuffer *input_buffer = nullptr;
+ IMFMediaBuffer *decoded_buffer = nullptr;
+ IMFMediaBuffer *converted_buffer = nullptr;
void ParseSPS(const uint8_t* buffer, int length);
};
template<class T>
HextileTile<T>::HextileTile()
- : m_tile(NULL), m_width(0), m_height(0),
+ : m_tile(nullptr), m_width(0), m_height(0),
m_size(0), m_flags(0), m_background(0), m_foreground(0),
m_numSubrects(0)
{
namespace rfb {
static bool isAllSpace(const char *string) {
- if (string == NULL)
+ if (string == nullptr)
return false;
while(*string != '\0') {
if (! isspace(*string))
const char* hostEnd;
const char* portStart;
- if (hi == NULL)
+ if (hi == nullptr)
throw rdr::Exception("NULL host specified");
// Trim leading whitespace
if (hi[0] == '[') {
hostStart = &hi[1];
hostEnd = strchr(hostStart, ']');
- if (hostEnd == NULL)
+ if (hostEnd == nullptr)
throw rdr::Exception("unmatched [ in host");
portStart = hostEnd + 1;
if (isAllSpace(portStart))
- portStart = NULL;
+ portStart = nullptr;
} else {
hostStart = &hi[0];
hostEnd = strrchr(hostStart, ':');
- if (hostEnd == NULL) {
+ if (hostEnd == nullptr) {
hostEnd = hostStart + strlen(hostStart);
- portStart = NULL;
+ portStart = nullptr;
} else {
if ((hostEnd > hostStart) && (hostEnd[-1] == ':'))
hostEnd--;
if (portStart != hostEnd) {
// We found more : in the host. This is probably an IPv6 address
hostEnd = hostStart + strlen(hostStart);
- portStart = NULL;
+ portStart = nullptr;
}
}
}
else
*host = std::string(hostStart, hostEnd - hostStart);
- if (portStart == NULL)
+ if (portStart == nullptr)
*port = basePort;
else {
char* end;
int w = r.width();
int h = r.height();
int pixelsize;
- uint8_t * volatile srcBuf = NULL;
+ uint8_t * volatile srcBuf = nullptr;
volatile bool srcBufIsTemp = false;
- JSAMPROW * volatile rowPointer = NULL;
+ JSAMPROW * volatile rowPointer = nullptr;
if(setjmp(err->jmpBuffer)) {
// this will execute if libjpeg has an error
int h = r.height();
int pixelsize;
int dstBufStride;
- uint8_t * volatile dstBuf = NULL;
+ uint8_t * volatile dstBuf = nullptr;
volatile bool dstBufIsTemp = false;
- JSAMPROW * volatile rowPointer = NULL;
+ JSAMPROW * volatile rowPointer = nullptr;
if(setjmp(err->jmpBuffer)) {
// this will execute if libjpeg has an error
using namespace rfb;
-LogWriter::LogWriter(const char* name) : m_name(name), m_level(0), m_log(0), m_next(log_writers) {
+LogWriter::LogWriter(const char* name)
+ : m_name(name), m_level(0), m_log(nullptr), m_next(log_writers) {
log_writers = this;
}
if (strcasecmp(name, current->m_name) == 0) return current;
current = current->m_next;
}
- return 0;
+ return nullptr;
}
bool LogWriter::setLogParams(const char* params) {
return false;
}
int level = atoi(parts[2].c_str());
- Logger* logger = 0;
+ Logger* logger = nullptr;
if (!parts[1].empty()) {
logger = Logger::getLogger(parts[1].c_str());
if (!logger)
using namespace rfb;
-Logger* Logger::loggers = 0;
+Logger* Logger::loggers = nullptr;
-Logger::Logger(const char* name) : registered(false), m_name(name), m_next(0) {
+Logger::Logger(const char* name)
+ : registered(false), m_name(name), m_next(nullptr)
+{
}
Logger::~Logger() {
if (strcasecmp(name, current->m_name) == 0) return current;
current = current->m_next;
}
- return 0;
+ return nullptr;
}
void
using namespace rfb;
Logger_File::Logger_File(const char* loggerName)
- : Logger(loggerName), indent(13), width(79), m_file(0),
+ : Logger(loggerName), indent(13), width(79), m_file(nullptr),
m_lastLogTime(0)
{
m_filename[0] = '\0';
if (!m_file) return;
}
- time_t current = time(0);
+ time_t current = time(nullptr);
if (current != m_lastLogTime) {
m_lastLogTime = current;
fprintf(m_file, "\n%s", ctime(&m_lastLogTime));
{
if (m_file) {
fclose(m_file);
- m_file = 0;
+ m_file = nullptr;
}
}
Logger_Syslog::Logger_Syslog(const char* loggerName)
: Logger(loggerName)
{
- openlog(0, LOG_CONS | LOG_PID, LOG_USER);
+ openlog(nullptr, LOG_CONS | LOG_PID, LOG_USER);
}
Logger_Syslog::~Logger_Syslog()
hash_key = genHash(colour);
pnode = hash[hash_key];
- prev_pnode = NULL;
+ prev_pnode = nullptr;
// Do we already have an entry for this colour?
- while (pnode != NULL) {
+ while (pnode != nullptr) {
if (pnode->colour == colour) {
// Yup
// Create a new colour entry
pnode = &list[numColours];
- pnode->next = NULL;
+ pnode->next = nullptr;
pnode->idx = 0;
pnode->colour = colour;
// Add it to the hash table
- if (prev_pnode != NULL)
+ if (prev_pnode != nullptr)
prev_pnode->next = pnode;
else
hash[hash_key] = pnode;
hash_key = genHash(colour);
pnode = hash[hash_key];
- while (pnode != NULL) {
+ while (pnode != nullptr) {
if (pnode->colour == colour)
return pnode->idx;
pnode = pnode->next;
{
}
-FullFramePixelBuffer::FullFramePixelBuffer() : data(0) {}
+FullFramePixelBuffer::FullFramePixelBuffer() : data(nullptr) {}
FullFramePixelBuffer::~FullFramePixelBuffer() {}
throw rfb::Exception("Invalid PixelBuffer height of %d pixels requested", height);
if ((stride_ < 0) || (stride_ > maxPixelBufferStride) || (stride_ < width))
throw rfb::Exception("Invalid PixelBuffer stride of %d pixels requested", stride_);
- if ((width != 0) && (height != 0) && (data_ == NULL))
+ if ((width != 0) && (height != 0) && (data_ == nullptr))
throw rfb::Exception("PixelBuffer requested without a valid memory area");
ModifiablePixelBuffer::setSize(width, height);
// Automatically allocates enough space for the specified format & area
ManagedPixelBuffer::ManagedPixelBuffer()
- : data_(NULL), datasize(0)
+ : data_(nullptr), datasize(0)
{
}
ManagedPixelBuffer::ManagedPixelBuffer(const PixelFormat& pf, int w, int h)
- : FullFramePixelBuffer(pf, 0, 0, NULL, 0), data_(NULL), datasize(0)
+ : FullFramePixelBuffer(pf, 0, 0, nullptr, 0), data_(nullptr), datasize(0)
{
setSize(w, h);
}
if (datasize < new_datasize) {
if (data_) {
delete [] data_;
- data_ = NULL;
+ data_ = nullptr;
datasize = 0;
}
if (new_datasize) {
static LogWriter vlog("SConnection");
SConnection::SConnection(AccessRights accessRights)
- : readyForSetColourMapEntries(false),
- is(0), os(0), reader_(0), writer_(0), ssecurity(0),
+ : readyForSetColourMapEntries(false), is(nullptr), os(nullptr),
+ reader_(nullptr), writer_(nullptr), ssecurity(nullptr),
authFailureTimer(this, &SConnection::handleAuthFailureTimeout),
state_(RFBSTATE_UNINITIALISED), preferredEncoding(encodingRaw),
accessRights(accessRights), hasRemoteClipboard(false),
void SConnection::cleanup()
{
delete ssecurity;
- ssecurity = NULL;
+ ssecurity = nullptr;
delete reader_;
- reader_ = NULL;
+ reader_ = nullptr;
delete writer_;
- writer_ = NULL;
+ writer_ = nullptr;
}
void SConnection::writeFakeColourMap(void)
// later, after queryConnection() has returned. It can only be called when
// in state RFBSTATE_QUERYING. On rejection, an AuthFailureException is
// thrown, so this must be handled appropriately by the caller.
- void approveConnection(bool accept, const char* reason=0);
+ void approveConnection(bool accept, const char* reason=nullptr);
// Methods to terminate the connection
// a plain black desktop of the specified format.
class SStaticDesktop : public SDesktop {
public:
- SStaticDesktop(const Point& size) : server(0), buffer(0) {
+ SStaticDesktop(const Point& size)
+ : server(nullptr), buffer(nullptr)
+ {
PixelFormat pf;
const uint8_t black[4] = { 0, 0, 0, 0 };
buffer = new ManagedPixelBuffer(pf, size.x, size.y);
if (buffer)
buffer->fillRect(buffer->getRect(), black);
}
- SStaticDesktop(const Point& size, const PixelFormat& pf) : buffer(0) {
+ SStaticDesktop(const Point& size, const PixelFormat& pf)
+ : buffer(nullptr)
+ {
const uint8_t black[4] = { 0, 0, 0, 0 };
buffer = new ManagedPixelBuffer(pf, size.x, size.y);
if (buffer)
}
virtual void queryConnection(network::Socket* sock,
const char* /*userName*/) {
- server->approveConnection(sock, true, NULL);
+ server->approveConnection(sock, true, nullptr);
}
protected:
}
zis.flushUnderlying();
- zis.setUnderlying(NULL, 0);
+ zis.setUnderlying(nullptr, 0);
handler->handleClipboardProvide(flags, lengths, buffers);
void SMsgWriter::writeServerCutText(const char* str)
{
- if (strchr(str, '\r') != NULL)
+ if (strchr(str, '\r') != nullptr)
throw Exception("Invalid carriage return in clipboard data");
std::string latin1(utf8ToLatin1(str));
SSecurityNone(SConnection* sc) : SSecurity(sc) {}
virtual bool processMsg() { return true; }
virtual int getType() const {return secTypeNone;}
- virtual const char* getUserName() const {return 0;}
+ virtual const char* getUserName() const {return nullptr;}
};
}
#endif
#elif !defined(__APPLE__)
valid = new UnixPasswordValidator();
#else
- valid = NULL;
+ valid = nullptr;
#endif
state = 0;
: SSecurity(sc), state(SendPublicKey),
keySize(_keySize), isAllEncrypted(_isAllEncrypted), secType(_secType),
serverKey(), clientKey(),
- serverKeyN(NULL), serverKeyE(NULL), clientKeyN(NULL), clientKeyE(NULL),
+ serverKeyN(nullptr), serverKeyE(nullptr),
+ clientKeyN(nullptr), clientKeyE(nullptr),
accessRights(AccessDefault),
- rais(NULL), raos(NULL), rawis(NULL), rawos(NULL)
+ rais(nullptr), raos(nullptr), rawis(nullptr), rawos(nullptr)
{
assert(keySize == 128 || keySize == 256);
}
delete[] serverKeyE;
delete[] clientKeyN;
delete[] clientKeyE;
- serverKeyN = NULL;
- serverKeyE = NULL;
- clientKeyN = NULL;
- clientKeyE = NULL;
+ serverKeyN = nullptr;
+ serverKeyE = nullptr;
+ clientKeyN = nullptr;
+ clientKeyE = nullptr;
memset(serverRandom, 0, sizeof(serverRandom));
memset(clientRandom, 0, sizeof(clientRandom));
}
const char* SSecurityStack::getUserName() const
{
- const char* c = 0;
+ const char* c = nullptr;
if (state1 && !c)
c = state1->getUserName();
class SSecurityStack : public SSecurity {
public:
SSecurityStack(SConnection* sc, int Type,
- SSecurity* s0 = NULL, SSecurity* s1 = NULL);
+ SSecurity* s0 = nullptr, SSecurity* s1 = nullptr);
~SSecurityStack();
virtual bool processMsg();
virtual int getType() const { return type; };
static LogWriter vlog("TLS");
SSecurityTLS::SSecurityTLS(SConnection* sc, bool _anon)
- : SSecurity(sc), session(NULL), anon_cred(NULL),
- cert_cred(NULL), anon(_anon), tlsis(NULL), tlsos(NULL),
- rawis(NULL), rawos(NULL)
+ : SSecurity(sc), session(nullptr), anon_cred(nullptr),
+ cert_cred(nullptr), anon(_anon), tlsis(nullptr), tlsos(nullptr),
+ rawis(nullptr), rawos(nullptr)
{
#if defined (SSECURITYTLS__USE_DEPRECATED_DH)
- dh_params = NULL;
+ dh_params = nullptr;
#endif
if (gnutls_global_init() != GNUTLS_E_SUCCESS)
if (anon_cred) {
gnutls_anon_free_server_credentials(anon_cred);
- anon_cred = 0;
+ anon_cred = nullptr;
}
if (cert_cred) {
gnutls_certificate_free_credentials(cert_cred);
- cert_cred = 0;
+ cert_cred = nullptr;
}
if (rawis && rawos) {
sc->setStreams(rawis, rawos);
- rawis = NULL;
- rawos = NULL;
+ rawis = nullptr;
+ rawos = nullptr;
}
if (tlsis) {
delete tlsis;
- tlsis = NULL;
+ tlsis = nullptr;
}
if (tlsos) {
delete tlsos;
- tlsos = NULL;
+ tlsos = nullptr;
}
if (session) {
gnutls_deinit(session);
- session = 0;
+ session = nullptr;
}
}
prio = (char*)malloc(strlen(Security::GnuTLSPriority) +
strlen(kx_anon_priority) + 1);
- if (prio == NULL)
+ if (prio == nullptr)
throw AuthFailureException("Not enough memory for GnuTLS priority string");
strcpy(prio, Security::GnuTLSPriority);
prio = (char*)malloc(strlen(gnutls_default_priority) +
strlen(kx_anon_priority) + 1);
- if (prio == NULL)
+ if (prio == nullptr)
throw AuthFailureException("Not enough memory for GnuTLS priority string");
strcpy(prio, gnutls_default_priority);
SSecurityTLS(SConnection* sc, bool _anon);
virtual ~SSecurityTLS();
virtual bool processMsg();
- virtual const char* getUserName() const {return 0;}
+ virtual const char* getUserName() const {return nullptr;}
virtual int getType() const { return anon ? secTypeTLSNone : secTypeX509None;}
static StringParameter X509_CertFile;
SSecurityVeNCrypt::SSecurityVeNCrypt(SConnection* sc, SecurityServer *sec)
: SSecurity(sc), security(sec)
{
- ssecurity = NULL;
+ ssecurity = nullptr;
haveSentVersion = false;
haveRecvdMajorVersion = false;
haveRecvdMinorVersion = false;
haveChosenType = false;
chosenType = secTypeVeNCrypt;
numTypes = 0;
- subTypes = NULL;
+ subTypes = nullptr;
}
SSecurityVeNCrypt::~SSecurityVeNCrypt()
const char* SSecurityVeNCrypt::getUserName() const
{
- if (ssecurity == NULL)
- return NULL;
+ if (ssecurity == nullptr)
+ return nullptr;
return ssecurity->getUserName();
}
AccessRights SSecurityVeNCrypt::getAccessRights() const
{
- if (ssecurity == NULL)
+ if (ssecurity == nullptr)
return SSecurity::getAccessRights();
return ssecurity->getAccessRights();
}
VncAuthPasswdParameter::VncAuthPasswdParameter(const char* name,
const char* desc,
StringParameter* passwdFile_)
-: BinaryParameter(name, desc, 0, 0, ConfServer), passwdFile(passwdFile_) {
+: BinaryParameter(name, desc, nullptr, 0, ConfServer),
+ passwdFile(passwdFile_)
+{
}
void VncAuthPasswdParameter::getVncAuthPasswd(std::string *password, std::string *readOnlyPassword) {
}
}
- assert(password != NULL);
- assert(readOnlyPassword != NULL);
+ assert(password != nullptr);
+ assert(readOnlyPassword != nullptr);
try {
*password = deobfuscate(obfuscated.data(), obfuscated.size());
SSecurityVncAuth(SConnection* sc);
virtual bool processMsg();
virtual int getType() const {return secTypeVncAuth;}
- virtual const char* getUserName() const {return 0;}
+ virtual const char* getUserName() const {return nullptr;}
virtual AccessRights getAccessRights() const { return accessRights; }
static StringParameter vncAuthPasswdFile;
static VncAuthPasswdParameter vncAuthPasswd;
using namespace rdr;
using namespace rfb;
-UserPasswdGetter *CSecurity::upg = NULL;
+UserPasswdGetter *CSecurity::upg = nullptr;
#if defined(HAVE_GNUTLS) || defined(HAVE_NETTLE)
-UserMsgBox *CSecurity::msg = NULL;
+UserMsgBox *CSecurity::msg = nullptr;
#endif
StringParameter SecurityClient::secTypes
CSecurity* SecurityClient::GetCSecurity(CConnection* cc, uint32_t secType)
{
- assert (CSecurity::upg != NULL); /* (upg == NULL) means bug in the viewer */
+ assert (CSecurity::upg != nullptr); /* (upg == nullptr) means bug in the viewer */
#if defined(HAVE_GNUTLS) || defined(HAVE_NETTLE)
- assert (CSecurity::msg != NULL);
+ assert (CSecurity::msg != nullptr);
#endif
if (!IsSupported(secType))
{
setName("");
- cursor_ = new Cursor(0, 0, Point(), NULL);
+ cursor_ = new Cursor(0, 0, Point(), nullptr);
clipFlags = 0;
memset(clipSizes, 0, sizeof(clipSizes));
size_t rowSize, dataSize;
uint8_t* netbuf;
- netbuf = NULL;
+ netbuf = nullptr;
if (palSize != 0) {
if (palSize <= 2)
zis[streamId].readBytes(netbuf, dataSize);
zis[streamId].flushUnderlying();
- zis[streamId].setUnderlying(NULL, 0);
+ zis[streamId].setUnderlying(nullptr, 0);
delete ms;
bufptr = netbuf;
rdr::ZlibOutStream* zos;
zos = dynamic_cast<rdr::ZlibOutStream*>(os_);
- if (zos == NULL)
+ if (zos == nullptr)
return;
zos->cork(false);
zos->flush();
- zos->setUnderlying(NULL);
+ zos->setUnderlying(nullptr);
os = conn->getOutStream();
if (pending.empty())
return -1;
- gettimeofday(&start, 0);
+ gettimeofday(&start, nullptr);
while (pending.front()->isBefore(start)) {
Timer* timer;
int Timer::getNextTimeout() {
timeval now;
- gettimeofday(&now, 0);
+ gettimeofday(&now, nullptr);
if (pending.empty())
return -1;
void Timer::start(int timeoutMs_) {
timeval now;
- gettimeofday(&now, 0);
+ gettimeofday(&now, nullptr);
stop();
timeoutMs = timeoutMs_;
dueTime = addMillis(now, timeoutMs);
void Timer::repeat(int timeoutMs_) {
timeval now;
- gettimeofday(&now, 0);
+ gettimeofday(&now, nullptr);
if (isStarted()) {
vlog.error("Incorrectly repeating already running timer");
int Timer::getRemainingMs() {
timeval now;
- gettimeofday(&now, 0);
+ gettimeofday(&now, nullptr);
return __rfbmax(0, diffTimeMillis(dueTime, now));
}
class ClippingUpdateTracker : public UpdateTracker {
public:
- ClippingUpdateTracker() : ut(0) {}
+ ClippingUpdateTracker() : ut(nullptr) {}
ClippingUpdateTracker(UpdateTracker* ut_, const Rect& r=Rect()) : ut(ut_), clipRect(r) {}
void setUpdateTracker(UpdateTracker* ut_) {ut = ut_;}
static LogWriter vlog("VNCSConnST");
-static Cursor emptyCursor(0, 0, Point(0, 0), NULL);
+static Cursor emptyCursor(0, 0, Point(0, 0), nullptr);
VNCSConnectionST::VNCSConnectionST(VNCServerST* server_, network::Socket *s,
bool reverse, AccessRights ar)
sock(s), reverseConnection(reverse),
inProcessMessages(false),
pendingSyncFence(false), syncFence(false), fenceFlags(0),
- fenceDataLen(0), fenceData(NULL), congestionTimer(this),
+ fenceDataLen(0), fenceData(nullptr), congestionTimer(this),
losslessTimer(this), server(server_),
updateRenderedCursor(false), removeRenderedCursor(false),
continuousUpdates(false), encodeManager(this), idleTimer(this),
if (!client.supportsLocalCursor())
return true;
if ((server->getCursorPos() != pointerEventPos) &&
- (time(0) - pointerEventTime) > 0)
+ (time(nullptr) - pointerEventTime) > 0)
return true;
return false;
{
if (rfb::Server::idleTimeout)
idleTimer.start(secsToMillis(rfb::Server::idleTimeout));
- pointerEventTime = time(0);
+ pointerEventTime = time(nullptr);
if (!accessCheck(AccessPtrEvents)) return;
if (!rfb::Server::acceptPointerEvents) return;
pointerEventPos = pos;
fenceFlags = flags & (fenceFlagBlockBefore | fenceFlagBlockAfter | fenceFlagSyncNext);
fenceDataLen = len;
delete [] fenceData;
- fenceData = NULL;
+ fenceData = nullptr;
if (len > 0) {
fenceData = new uint8_t[len];
memcpy(fenceData, data, len);
// Does the client need a server-side rendered cursor?
- cursor = NULL;
+ cursor = nullptr;
if (needRenderedCursor()) {
Rect renderedCursorRect;
// Prepare the cursor in case it overlaps with a region getting
// refreshed
- cursor = NULL;
+ cursor = nullptr;
if (needRenderedCursor())
cursor = server->getRenderedCursor();
// acceptance, or false for rejection, in which case a string
// reason may also be given.
virtual void approveConnection(network::Socket* sock, bool accept,
- const char* reason = NULL) = 0;
+ const char* reason = nullptr) = 0;
// - Close all currently-connected clients, by calling
// their close() method with the supplied reason.
VNCServerST::VNCServerST(const char* name_, SDesktop* desktop_)
: blHosts(&blacklist), desktop(desktop_), desktopStarted(false),
- blockCounter(0), pb(0), ledState(ledUnknown),
- name(name_), pointerClient(0), clipboardClient(0),
+ blockCounter(0), pb(nullptr), ledState(ledUnknown),
+ name(name_), pointerClient(nullptr), clipboardClient(nullptr),
pointerClientTime(0),
- comparer(0), cursor(new Cursor(0, 0, Point(), NULL)),
+ comparer(nullptr), cursor(new Cursor(0, 0, Point(), nullptr)),
renderedCursorInvalid(false),
keyRemapper(&KeyRemapper::defInstance),
idleTimer(this), disconnectTimer(this), connectTimer(this),
if ((*ci)->getSock() == sock) {
// - Remove any references to it
if (pointerClient == *ci)
- pointerClient = NULL;
+ pointerClient = nullptr;
if (clipboardClient == *ci)
handleClipboardAnnounce(*ci, false);
clipboardRequestors.remove(*ci);
pb = pb_;
delete comparer;
- comparer = 0;
+ comparer = nullptr;
if (!pb) {
screenLayout = ScreenSet();
void VNCServerST::requestClipboard()
{
- if (clipboardClient == NULL) {
+ if (clipboardClient == nullptr) {
slog.debug("Got request for client clipboard but no client currently owns the clipboard");
return;
}
{
std::list<VNCSConnectionST*>::iterator ci, ci_next;
- if (strchr(data, '\r') != NULL)
+ if (strchr(data, '\r') != nullptr)
throw Exception("Invalid carriage return in clipboard data");
for (ci = clipboardRequestors.begin();
void VNCServerST::add_changed(const Region& region)
{
- if (comparer == NULL)
+ if (comparer == nullptr)
return;
comparer->add_changed(region);
void VNCServerST::add_copied(const Region& dest, const Point& delta)
{
- if (comparer == NULL)
+ if (comparer == nullptr)
return;
comparer->add_copied(dest, delta);
void VNCServerST::pointerEvent(VNCSConnectionST* client,
const Point& pos, int buttonMask)
{
- time_t now = time(0);
+ time_t now = time(nullptr);
if (rfb::Server::maxIdleTime)
idleTimer.start(secsToMillis(rfb::Server::maxIdleTime));
// Let one client own the cursor whilst buttons are pressed in order
// to provide a bit more sane user experience. But limit the time to
// prevent locking out all others when e.g. the network is down.
- if ((pointerClient != NULL) && (pointerClient != client) &&
+ if ((pointerClient != nullptr) && (pointerClient != client) &&
((now - pointerClientTime) < 10))
return;
if (buttonMask)
pointerClient = client;
else
- pointerClient = NULL;
+ pointerClient = nullptr;
desktop->pointerEvent(pos, buttonMask);
}
else {
if (client != clipboardClient)
return;
- clipboardClient = NULL;
+ clipboardClient = nullptr;
}
desktop->handleClipboardAnnounce(available);
}
if ((*ci)->getSock() == sock)
return (SConnection*)*ci;
}
- return 0;
+ return nullptr;
}
void VNCServerST::handleTimeout(Timer* t)
// - Are we configured to do queries?
if (!rfb::Server::queryConnect &&
!client->getSock()->requiresQuery()) {
- approveConnection(client->getSock(), true, NULL);
+ approveConnection(client->getSock(), true, nullptr);
return;
}
// - Does the client have the right to bypass the query?
if (client->accessCheck(AccessNoQuery))
{
- approveConnection(client->getSock(), true, NULL);
+ approveConnection(client->getSock(), true, nullptr);
return;
}
virtual void approveConnection(network::Socket* sock, bool accept,
const char* reason);
- virtual void closeClients(const char* reason) {closeClients(reason, 0);}
+ virtual void closeClients(const char* reason) {closeClients(reason, nullptr);}
virtual SConnection* getConnection(network::Socket* sock);
virtual void add_changed(const Region ®ion);
}
zis->flushUnderlying();
- zis->setUnderlying(NULL, 0);
+ zis->setUnderlying(nullptr, 0);
}
ZRLEEncoder::ZRLEEncoder(SConnection* conn)
: Encoder(conn, encodingZRLE, EncoderPlain, 127),
- zos(0, 2), mos(129*1024)
+ zos(nullptr, 2), mos(129*1024)
{
if (zlibLevel != -1) {
vlog.info("Warning: The ZlibLevel option is deprecated and is "
ZRLEEncoder::~ZRLEEncoder()
{
- zos.setUnderlying(NULL);
+ zos.setUnderlying(nullptr);
}
bool ZRLEEncoder::isSupported()
{
std::vector<uint8_t> buf(8);
- assert(str != NULL);
+ assert(str != nullptr);
size_t l = strlen(str), i;
for (i=0; i<8; i++)
if (len != 8)
throw rdr::Exception("bad obfuscated password length");
- assert(data != NULL);
+ assert(data != nullptr);
deskey(d3desObfuscationKey, DE1);
des((uint8_t*)data, (uint8_t*)buf);
std::string out;
va_start(ap, fmt);
- len = vsnprintf(NULL, 0, fmt, ap);
+ len = vsnprintf(nullptr, 0, fmt, ap);
va_end(ap);
if (len < 0)
start = src;
do {
stop = strchr(start, delimiter);
- if (stop == NULL) {
+ if (stop == nullptr) {
out.push_back(start);
} else {
out.push_back(std::string(start, stop-start));
start = stop + 1;
}
- } while (stop != NULL);
+ } while (stop != nullptr);
return out;
}
{
struct timeval now;
- gettimeofday(&now, NULL);
+ gettimeofday(&now, nullptr);
return msBetween(then, &now);
}
struct timeval start, stop;
struct stats s;
- gettimeofday(&start, NULL);
+ gettimeofday(&start, nullptr);
try {
cc = new CConn(fn);
exit(1);
}
- gettimeofday(&stop, NULL);
+ gettimeofday(&stop, nullptr);
s.decodeTime = cc->cpuTime;
s.realTime = (double)stop.tv_sec - start.tv_sec;
: SConnection(rfb::AccessDefault)
{
out = new DummyOutStream;
- setStreams(NULL, out);
+ setStreams(nullptr, out);
setWriter(new rfb::SMsgWriter(&client, out));
void SConn::writeUpdate(const rfb::UpdateInfo& ui, const rfb::PixelBuffer* pb)
{
- manager->writeUpdate(ui, pb, NULL);
+ manager->writeUpdate(ui, pb, nullptr);
}
void SConn::getStats(double& ratio, unsigned long long& bytes,
struct stats s;
struct timeval start, stop;
- gettimeofday(&start, NULL);
+ gettimeofday(&start, nullptr);
try {
cc = new CConn(fn);
exit(1);
}
- gettimeofday(&stop, NULL);
+ gettimeofday(&stop, nullptr);
s.decodeTime = cc->decodeTime;
s.encodeTime = cc->encodeTime;
const char *fn;
- fn = NULL;
+ fn = nullptr;
for (i = 1; i < argc; i++) {
if (rfb::Configuration::setParam(argv[i]))
continue;
usage(argv[0]);
}
- if (fn != NULL)
+ if (fn != nullptr)
usage(argv[0]);
fn = argv[i];
double *dev = new double[runCount];
double median, meddev;
- if (fn == NULL) {
+ if (fn == nullptr) {
fprintf(stderr, "No file specified!\n\n");
usage(argv[0]);
}
TestWindow::TestWindow() :
Fl_Window(0, 0, "Framebuffer Performance Test"),
- fb(NULL)
+ fb(nullptr)
{
}
hide();
delete fb;
- fb = NULL;
+ fb = nullptr;
Fl::remove_idle(timer, this);
}
}
OverlayTestWindow::OverlayTestWindow() :
- overlay(NULL), offscreen(NULL)
+ overlay(nullptr), offscreen(nullptr)
{
}
#if !defined(__APPLE__)
offscreen = new Surface(w(), h());
#else
- offscreen = NULL;
+ offscreen = nullptr;
#endif
}
PartialTestWindow::stop();
delete offscreen;
- offscreen = NULL;
+ offscreen = nullptr;
delete overlay;
- overlay = NULL;
+ overlay = nullptr;
}
void OverlayTestWindow::draw()
win->start(width, height);
- gettimeofday(&start, NULL);
+ gettimeofday(&start, nullptr);
while (rfb::msSince(&start) < 3000)
Fl::wait();
syscounter_t *c;
c = (syscounter_t*)malloc(sizeof(syscounter_t) * 2);
- if (c == NULL)
- return NULL;
+ if (c == nullptr)
+ return nullptr;
memset(c, 0, sizeof(syscounter_t) * 2);
#ifdef WIN32
QueryPerformanceCounter(&timeStart);
#else
- gettimeofday(&timeStart, NULL);
+ gettimeofday(&timeStart, nullptr);
#endif
}
#ifdef WIN32
QueryPerformanceCounter(&timeEnd);
#else
- gettimeofday(&timeEnd, NULL);
+ gettimeofday(&timeEnd, nullptr);
#endif
}
for (i = 0;i < ARRAY_SIZE(latin1utf8);i++) {
/* Expected failure? */
- if (strchr(latin1utf8[i].latin1, '?') != NULL)
+ if (strchr(latin1utf8[i].latin1, '?') != nullptr)
continue;
out = rfb::latin1ToUTF8(latin1utf8[i].latin1);
for (i = 0;i < ARRAY_SIZE(utf8utf16);i++) {
/* Expected failure? */
- if (strstr(utf8utf16[i].utf8, "\xef\xbf\xbd") != NULL)
+ if (strstr(utf8utf16[i].utf8, "\xef\xbf\xbd") != nullptr)
continue;
wout = rfb::utf8ToUTF16(utf8utf16[i].utf8);
class TXButton : public TXWindow, public TXEventHandler {
public:
- TXButton(Display* dpy_, const char* text_, TXButtonCallback* cb_=0,
- TXWindow* parent_=0, int w=1, int h=1)
+ TXButton(Display* dpy_, const char* text_,
+ TXButtonCallback* cb_=nullptr,
+ TXWindow* parent_=nullptr, int w=1, int h=1)
: TXWindow(dpy_, w, h, parent_), cb(cb_), down(false),
disabled_(false)
{
setEventHandler(this);
setText(text_);
- gc = XCreateGC(dpy, win(), 0, 0);
+ gc = XCreateGC(dpy, win(), 0, nullptr);
XSetFont(dpy, gc, defaultFont);
addEventMask(ExposureMask | ButtonPressMask | ButtonReleaseMask);
}
class TXCheckbox : public TXWindow, public TXEventHandler {
public:
TXCheckbox(Display* dpy_, const char* text_, TXCheckboxCallback* cb_,
- bool radio_=false, TXWindow* parent_=0, int w=1, int h=1)
- : TXWindow(dpy_, w, h, parent_), cb(cb_), text(0),
+ bool radio_=false, TXWindow* parent_=nullptr,
+ int w=1, int h=1)
+ : TXWindow(dpy_, w, h, parent_), cb(cb_), text(nullptr),
boxSize(radio_ ? 12 : 13), boxPad(4),
checked_(false), disabled_(false), radio(radio_)
{
setEventHandler(this);
setText(text_);
- gc = XCreateGC(dpy, win(), 0, 0);
+ gc = XCreateGC(dpy, win(), 0, nullptr);
XSetFont(dpy, gc, defaultFont);
addEventMask(ExposureMask| ButtonPressMask | ButtonReleaseMask);
}
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(ConnectionNumber(dpy), &rfds);
- int n = select(FD_SETSIZE, &rfds, 0, 0, 0);
+ int n = select(FD_SETSIZE, &rfds, nullptr, nullptr, nullptr);
if (n < 0) throw rdr::SystemException("select",errno);
}
}
enum HAlign { left, centre, right };
enum VAlign { top, middle, bottom };
- TXLabel(Display* dpy_, const char* text_, TXWindow* parent_=0,
+ TXLabel(Display* dpy_, const char* text_, TXWindow* parent_=nullptr,
int w=1, int h=1, HAlign ha=centre, VAlign va=middle)
: TXWindow(dpy_, w, h, parent_), lineSpacing(2), lines(0),
halign(ha), valign(va)
unsigned long TXWindow::enabledBg;
unsigned long TXWindow::scrollbarBg;
Colormap TXWindow::cmap = 0;
-GC TXWindow::defaultGC = 0;
+GC TXWindow::defaultGC = nullptr;
Font TXWindow::defaultFont = 0;
-XFontStruct* TXWindow::defaultFS = 0;
+XFontStruct* TXWindow::defaultFS = nullptr;
Time TXWindow::cutBufferTime = 0;
Pixmap TXWindow::dot = 0, TXWindow::tick = 0;
const int TXWindow::dotSize = 4, TXWindow::tickSize = 8;
char* TXWindow::defaultWindowClass;
-TXGlobalEventHandler* TXWindow::globalEventHandler = NULL;
+TXGlobalEventHandler* TXWindow::globalEventHandler = nullptr;
void TXWindow::init(Display* dpy, const char* defaultWindowClass_)
{
darkBg = disabledFg = cols[3].pixel;
scrollbarBg = cols[4].pixel;
white = enabledBg = cols[5].pixel;
- defaultGC = XCreateGC(dpy, DefaultRootWindow(dpy), 0, 0);
+ defaultGC = XCreateGC(dpy, DefaultRootWindow(dpy), 0, nullptr);
defaultFS
= XLoadQueryFont(dpy, "-*-helvetica-medium-r-*-*-12-*-*-*-*-*-*-*");
if (!defaultFS) {
TXWindow::TXWindow(Display* dpy_, int w, int h, TXWindow* parent_,
int borderWidth)
: dpy(dpy_), xPad(3), yPad(3), bevel(2), parent(parent_), width_(w),
- height_(h), eventHandler(0), dwc(0), eventMask(0), toplevel_(false)
+ height_(h), eventHandler(nullptr), dwc(nullptr), eventMask(0),
+ toplevel_(false)
{
sizeHints.flags = 0;
XSetWindowAttributes attr;
attr.border_pixel = 0;
Window par = parent ? parent->win() : DefaultRootWindow(dpy);
win_ = XCreateWindow(dpy, par, 0, 0, width_, height_, borderWidth,
- CopyFromParent, CopyFromParent, CopyFromParent,
+ CopyFromParent, CopyFromParent,
+ (Visual*)CopyFromParent,
CWBackPixel | CWBorderPixel, &attr);
if (parent) map();
if (!windowClass) windowClass = defaultWindowClass;
classHint.res_name = (char*)name;
classHint.res_class = (char*)windowClass;
- XSetWMProperties(dpy, win(), 0, 0, argv, argc,
+ XSetWMProperties(dpy, win(), nullptr, nullptr, argv, argc,
&sizeHints, &wmHints, &classHint);
XStoreName(dpy, win(), name);
XSetIconName(dpy, win(), name);
break;
}
}
- selectionNotify(&ev->xselection, 0, 0, 0, 0);
+ selectionNotify(&ev->xselection, 0, 0, 0, nullptr);
break;
case SelectionRequest:
// background (currently grey). It is mapped by default if it has a parent.
// If no parent is specified its parent is the root window and it will remain
// unmapped.
- TXWindow(Display* dpy_, int width=1, int height=1, TXWindow* parent_=0,
+ TXWindow(Display* dpy_, int width=1, int height=1,
+ TXWindow* parent_=nullptr,
int borderWidth=0);
virtual ~TXWindow();
// window-manager-related properties are set on the window. The given
// TXDeleteWindowCallback is notified when the window is "deleted" (cloesd)
// by the user.
- void toplevel(const char* name, TXDeleteWindowCallback* dwc=0,
- int argc=0, char** argv=0, const char* windowClass=0,
+ void toplevel(const char* name, TXDeleteWindowCallback* dwc=nullptr,
+ int argc=0, char** argv=nullptr,
+ const char* windowClass=nullptr,
bool iconic=false);
// setMaxSize() tells the window manager the maximum size to allow a
// strEmptyToNull() returns the string it's given but turns an empty string
// into null, which can be useful for passing rfb parameters to Xlib calls.
- static char* strEmptyToNull(char* s) { return s && s[0] ? s : 0; }
+ static char* strEmptyToNull(char* s) { return s && s[0] ? s : nullptr; }
// The following are default values for various things.
static unsigned long black, white;
#define SET_PRIMARY "SetPrimary"
#define SEND_PRIMARY "SendPrimary"
-char* programName = 0;
+char* programName = nullptr;
Display* dpy;
int vncExtEventBase, vncExtErrorBase;
setPrimaryCB(dpy, "Also set primary selection", this, false, this),
sendClipboard(dpy, "Send clipboard to viewers", this, false, this),
sendPrimaryCB(dpy, "Send primary selection to viewers", this,false,this),
- queryConnectDialog(0)
+ queryConnectDialog(nullptr)
{
int y = yPad;
acceptClipboard.move(xPad, y);
sendPrimaryCB.disabled(!sendClipboard.checked());
y += sendPrimaryCB.height();
setEventHandler(this);
- toplevel("VNC config", this, 0, 0, 0, iconic);
+ toplevel("VNC config", this, 0, nullptr, nullptr, iconic);
XVncExtSelectInput(dpy, win(), VncExtQueryConnectMask);
}
vlog.debug("query connection event");
if (queryConnectDialog)
delete queryConnectDialog;
- queryConnectDialog = 0;
+ queryConnectDialog = nullptr;
char* qcAddress;
char* qcUser;
int qcTimeout;
while (true) {
struct timeval tv;
- struct timeval* tvp = 0;
+ struct timeval* tvp = nullptr;
// Process any incoming X events
TXWindow::handleXEvents(dpy);
fd_set rfds;
FD_ZERO(&rfds);
FD_SET(ConnectionNumber(dpy), &rfds);
- int n = select(FD_SETSIZE, &rfds, 0, 0, tvp);
+ int n = select(FD_SETSIZE, &rfds, nullptr, nullptr, tvp);
if (n < 0) throw rdr::SystemException("select",errno);
}
result[strlen(result)-1] = 0;
return buf;
}
- return 0;
+ return nullptr;
}
// Reads passwords from stdin and prints encrypted passwords to stdout.
// We support a maximum of two passwords right now
for (i = 0;i < 2;i++) {
- const char *result = getpassword(NULL);
+ const char *result = getpassword(nullptr);
if (!result)
break;
static std::vector<uint8_t> readpassword() {
while (true) {
const char *passwd = getpassword("Password:");
- if (passwd == NULL) {
+ if (passwd == nullptr) {
perror("getpassword error");
exit(1);
}
}
passwd = getpassword("Verify:");
- if (passwd == NULL) {
+ if (passwd == nullptr) {
perror("getpass error");
exit(1);
}
if (fname[0] == '\0') {
const char *configDir = os::getvncconfigdir();
- if (configDir == NULL) {
+ if (configDir == nullptr) {
fprintf(stderr, "Can't obtain VNC config directory\n");
exit(1);
}
fprintf(stderr, "Would you like to enter a view-only password (y/n)? ");
char yesno[3];
- if (fgets(yesno, 3, stdin) != NULL && (yesno[0] == 'y' || yesno[0] == 'Y')) {
+ if (fgets(yesno, 3, stdin) != nullptr && (yesno[0] == 'y' || yesno[0] == 'Y')) {
obfuscatedReadOnly = readpassword();
} else {
fprintf(stderr, "A view-only password is not used\n");
{
Rect result; // empty by default
- if (arg != NULL && strlen(arg) > 0) {
+ if (arg != nullptr && strlen(arg) > 0) {
int w, h;
int x = 0, y = 0;
char sign_x[2] = "+";
static rfb::LogWriter vlog("Image");
Image::Image(Display *d)
- : xim(NULL), dpy(d)
+ : xim(nullptr), dpy(d)
{
imageCleanup.images.push_back(this);
}
Image::Image(Display *d, int width, int height)
- : xim(NULL), dpy(d)
+ : xim(nullptr), dpy(d)
{
imageCleanup.images.push_back(this);
Init(width, height);
}
xim = XCreateImage(dpy, vis, DefaultDepth(dpy, DefaultScreen(dpy)),
- ZPixmap, 0, 0, width, height, BitmapPad(dpy), 0);
+ ZPixmap, 0, nullptr, width, height,
+ BitmapPad(dpy), 0);
xim->data = (char *)malloc(xim->bytes_per_line * xim->height);
- if (xim->data == NULL) {
+ if (xim->data == nullptr) {
vlog.error("malloc() failed");
exit(1);
}
imageCleanup.images.remove(this);
// XDestroyImage will free xim->data if necessary
- if (xim != NULL)
+ if (xim != nullptr)
XDestroyImage(xim);
}
}
ShmImage::ShmImage(Display *d)
- : Image(d), shminfo(NULL)
+ : Image(d), shminfo(nullptr)
{
}
ShmImage::ShmImage(Display *d, int width, int height)
- : Image(d), shminfo(NULL)
+ : Image(d), shminfo(nullptr)
{
Init(width, height);
}
Visual *visual;
int depth;
- if (vinfo == NULL) {
+ if (vinfo == nullptr) {
visual = DefaultVisual(dpy, DefaultScreen(dpy));
depth = DefaultDepth(dpy, DefaultScreen(dpy));
} else {
shminfo = new XShmSegmentInfo;
- xim = XShmCreateImage(dpy, visual, depth, ZPixmap, 0, shminfo,
+ xim = XShmCreateImage(dpy, visual, depth, ZPixmap, nullptr, shminfo,
width, height);
- if (xim == NULL) {
+ if (xim == nullptr) {
vlog.error("XShmCreateImage() failed");
delete shminfo;
- shminfo = NULL;
+ shminfo = nullptr;
return;
}
vlog.error("shmget() failed (%d bytes requested)",
int(xim->bytes_per_line * xim->height));
XDestroyImage(xim);
- xim = NULL;
+ xim = nullptr;
delete shminfo;
- shminfo = NULL;
+ shminfo = nullptr;
return;
}
- shminfo->shmaddr = xim->data = (char *)shmat(shminfo->shmid, 0, 0);
+ shminfo->shmaddr = xim->data = (char *)shmat(shminfo->shmid, nullptr, 0);
if (shminfo->shmaddr == (char *)-1) {
perror("shmat");
vlog.error("shmat() failed (%d bytes requested)",
int(xim->bytes_per_line * xim->height));
- shmctl(shminfo->shmid, IPC_RMID, 0);
+ shmctl(shminfo->shmid, IPC_RMID, nullptr);
XDestroyImage(xim);
- xim = NULL;
+ xim = nullptr;
delete shminfo;
- shminfo = NULL;
+ shminfo = nullptr;
return;
}
if (caughtShmError) {
vlog.error("XShmAttach() failed");
shmdt(shminfo->shmaddr);
- shmctl(shminfo->shmid, IPC_RMID, 0);
+ shmctl(shminfo->shmid, IPC_RMID, nullptr);
XDestroyImage(xim);
- xim = NULL;
+ xim = nullptr;
delete shminfo;
- shminfo = NULL;
+ shminfo = nullptr;
return;
}
}
ShmImage::~ShmImage()
{
- if (shminfo != NULL) {
+ if (shminfo != nullptr) {
XShmDetach(dpy, shminfo);
shmdt(shminfo->shmaddr);
- shmctl(shminfo->shmid, IPC_RMID, 0);
+ shmctl(shminfo->shmid, IPC_RMID, nullptr);
delete shminfo;
}
}
Image *ImageFactory::newImage(Display *d, int width, int height)
{
- Image *image = NULL;
+ Image *image = nullptr;
// Now, try to use shared memory image.
if (mayUseShm) {
image = new ShmImage(d, width, height);
- if (image->xim != NULL) {
+ if (image->xim != nullptr) {
return image;
}
protected:
- void Init(int width, int height, const XVisualInfo *vinfo = NULL);
+ void Init(int width, int height, const XVisualInfo *vinfo = nullptr);
XShmSegmentInfo *shminfo;
};
XDesktop::XDesktop(Display* dpy_, Geometry *geometry_)
- : dpy(dpy_), geometry(geometry_), pb(0), server(0),
- queryConnectDialog(0), queryConnectSock(0),
+ : dpy(dpy_), geometry(geometry_), pb(nullptr), server(nullptr),
+ queryConnectDialog(nullptr), queryConnectSock(nullptr),
oldButtonMask(0), haveXtest(false), haveDamage(false),
maxButtons(0), running(false), ledMasks(), ledState(0),
- codeMap(0), codeMapLen(0)
+ codeMap(nullptr), codeMapLen(0)
{
int major, minor;
Bool on;
a = XInternAtom(dpy, ledNames[i], True);
- if (!a || !XkbGetNamedIndicator(dpy, a, &shift, &on, NULL, NULL))
+ if (!a || !XkbGetNamedIndicator(dpy, a, &shift, &on, nullptr, nullptr))
continue;
ledMasks[i] = 1u << shift;
#endif
delete queryConnectDialog;
- queryConnectDialog = 0;
+ queryConnectDialog = nullptr;
- server->setPixelBuffer(0);
+ server->setPixelBuffer(nullptr);
delete pb;
- pb = 0;
+ pb = nullptr;
}
void XDesktop::terminate() {
if (XkbKeysymToKeycode(dpy, it->first) != it->second)
continue;
- XkbChangeTypesOfKey(xkb, it->second, 0, XkbGroup1Mask, NULL, &changes);
+ XkbChangeTypesOfKey(xkb, it->second, 0, XkbGroup1Mask, nullptr, &changes);
if (it->second < lowestKeyCode)
lowestKeyCode = it->second;
if (cev->window == cev->root)
return false;
- server->setCursor(0, 0, Point(), NULL);
+ server->setCursor(0, 0, Point(), nullptr);
return true;
#endif
}
void XDesktop::queryApproved()
{
assert(isRunning());
- server->approveConnection(queryConnectSock, true, 0);
- queryConnectSock = 0;
+ server->approveConnection(queryConnectSock, true, nullptr);
+ queryConnectSock = nullptr;
}
void XDesktop::queryRejected()
assert(isRunning());
server->approveConnection(queryConnectSock, false,
"Connection rejected by local user");
- queryConnectSock = 0;
+ queryConnectSock = nullptr;
}
#ifdef HAVE_XFIXES
XFixesCursorImage *cim;
cim = XFixesGetCursorImage(dpy);
- if (cim == NULL)
+ if (cim == nullptr)
return false;
// Copied from XserverDesktop::setCursor() in
XPixelBuffer::XPixelBuffer(Display *dpy, ImageFactory &factory,
const Rect &rect)
: FullFramePixelBuffer(),
- m_poller(0),
+ m_poller(nullptr),
m_dpy(dpy),
m_image(factory.newImage(dpy, rect.width(), rect.height())),
m_offsetLeft(rect.tl.x),
return "";
struct passwd* pwent = getpwuid(getuid());
- if (pwent == NULL)
+ if (pwent == nullptr)
return "";
- int len = snprintf(NULL, 0, "%s@%s", pwent->pw_name, hostname.data());
+ int len = snprintf(nullptr, 0, "%s@%s", pwent->pw_name, hostname.data());
if (len < 0)
return "";
public:
FileTcpFilter(const char *fname)
- : TcpFilter("-"), fileName(NULL), lastModTime(0)
+ : TcpFilter("-"), fileName(nullptr), lastModTime(0)
{
- if (fname != NULL)
+ if (fname != nullptr)
fileName = strdup((char *)fname);
}
virtual ~FileTcpFilter()
{
- if (fileName != NULL)
+ if (fileName != nullptr)
free(fileName);
}
bool reloadRules()
{
- if (fileName == NULL)
+ if (fileName == nullptr)
return true;
struct stat st;
if (st.st_mtime != lastModTime) {
// Actually reload only if the file was modified
FILE *fp = fopen(fileName, "r");
- if (fp == NULL)
+ if (fp == nullptr)
return false;
// Remove all the rules from the parent class
bool readLine(char *buf, int bufSize, FILE *fp)
{
- if (fp == NULL || buf == NULL || bufSize == 0)
+ if (fp == nullptr || buf == nullptr || bufSize == 0)
return false;
- if (fgets(buf, bufSize, fp) == NULL)
+ if (fgets(buf, bufSize, fp) == nullptr)
return false;
char *ptr = strchr(buf, '\n');
- if (ptr != NULL) {
+ if (ptr != nullptr) {
*ptr = '\0'; // remove newline at the end
} else {
if (!feof(fp)) {
const char *addr = interface;
if (strcasecmp(addr, "all") == 0)
- addr = 0;
+ addr = nullptr;
if (localhostOnly)
createLocalTcpListeners(&tcp_listeners, (int)rfbport);
else
// Do the wait...
sched.sleepStarted();
- int n = select(FD_SETSIZE, &rfds, &wfds, 0,
- wait_ms ? &tv : NULL);
+ int n = select(FD_SETSIZE, &rfds, &wfds, nullptr,
+ wait_ms ? &tv : nullptr);
sched.sleepFinished();
if (n < 0) {
LogWriter *vlog;
va_list ap;
vlog = LogWriter::getLogWriter(name);
- if (vlog == NULL)
+ if (vlog == nullptr)
return;
va_start(ap, format);
vlog->verror(format, ap);
LogWriter *vlog;
va_list ap;
vlog = LogWriter::getLogWriter(name);
- if (vlog == NULL)
+ if (vlog == nullptr)
return;
va_start(ap, format);
vlog->vstatus(format, ap);
LogWriter *vlog;
va_list ap;
vlog = LogWriter::getLogWriter(name);
- if (vlog == NULL)
+ if (vlog == nullptr)
return;
va_start(ap, format);
vlog->vinfo(format, ap);
LogWriter *vlog;
va_list ap;
vlog = LogWriter::getLogWriter(name);
- if (vlog == NULL)
+ if (vlog == nullptr)
return;
va_start(ap, format);
vlog->vdebug(format, ap);
int vncSetParam(const char *name, const char *value)
{
- if (value != NULL)
+ if (value != nullptr)
return rfb::Configuration::setParam(name, value);
else {
VoidParameter *param;
param = rfb::Configuration::getParam(name);
- if (param == NULL)
+ if (param == nullptr)
return false;
return param->setParam();
}
// Hack to avoid exposing password!
if (strcasecmp(name, "Password") == 0)
- return NULL;
+ return nullptr;
param = rfb::Configuration::getParam(name);
- if (param == NULL)
- return NULL;
+ if (param == nullptr)
+ return nullptr;
return strdup(param->getValueStr().c_str());
}
rfb::VoidParameter *param;
param = rfb::Configuration::getParam(name);
- if (param == NULL)
- return NULL;
+ if (param == nullptr)
+ return nullptr;
return param->getDescription();
}
BoolParameter *bparam;
param = rfb::Configuration::getParam(name);
- if (param == NULL)
+ if (param == nullptr)
return false;
bparam = dynamic_cast<BoolParameter*>(param);
- if (bparam == NULL)
+ if (bparam == nullptr)
return false;
return true;
}
data = (char*)malloc(len + 1);
- if (data == NULL)
- return NULL;
+ if (data == nullptr)
+ return nullptr;
ptr = data;
for (ParameterIterator i; i.param; i.next()) {
try {
return strdup(convertLF(src, bytes).c_str());
} catch (...) {
- return NULL;
+ return nullptr;
}
}
try {
return strdup(latin1ToUTF8(src, bytes).c_str());
} catch (...) {
- return NULL;
+ return nullptr;
}
}
try {
return strdup(utf8ToLatin1(src, bytes).c_str());
} catch (...) {
- return NULL;
+ return nullptr;
}
}
void* fbptr, int stride_)
: screenIndex(screenIndex_),
server(0), listeners(listeners_),
- shadowFramebuffer(NULL),
+ shadowFramebuffer(nullptr),
queryConnectId(0), queryConnectTimer(this)
{
format = pf;
if (shadowFramebuffer) {
delete [] shadowFramebuffer;
- shadowFramebuffer = NULL;
+ shadowFramebuffer = nullptr;
}
if (!fbptr) {
void XserverDesktop::grabRegion(const rfb::Region& region)
{
- if (shadowFramebuffer == NULL)
+ if (shadowFramebuffer == nullptr)
return;
std::vector<rfb::Rect> rects;
return "";
struct passwd* pwent = getpwuid(getuid());
- if (pwent == NULL)
+ if (pwent == nullptr)
return "";
- size_t len = snprintf(NULL, 0, "%s@%s", pwent->pw_name, hostname.data());
+ size_t len = snprintf(nullptr, 0, "%s@%s", pwent->pw_name, hostname.data());
if (len < 0)
return "";
try {
for (int scr = 0; scr < vncGetScreenCount(); scr++) {
delete desktop[scr];
- desktop[scr] = NULL;
+ desktop[scr] = nullptr;
}
} catch (rdr::Exception& e) {
vncFatalError("vncExtInit: %s\n",e.str());
BaseTouchHandler::BaseTouchHandler()
{
- gettimeofday(&lastTapTime, NULL);
+ gettimeofday(&lastTapTime, nullptr);
}
BaseTouchHandler::~BaseTouchHandler()
} else {
firstDoubleTapEvent = ev;
}
- gettimeofday(&lastTapTime, NULL);
+ gettimeofday(&lastTapTime, nullptr);
fakeMotionEvent(newEv);
fakeButtonEvent(true, buttonEvent, newEv);
// Time new bandwidth estimates are weighted against (in ms)
static const unsigned bpsEstimateWindow = 1000;
-CConn::CConn(const char* vncServerName, network::Socket* socket=NULL)
- : serverPort(0), desktop(NULL), updateCount(0), pixelCount(0),
+CConn::CConn(const char* vncServerName, network::Socket* socket=nullptr)
+ : serverPort(0), desktop(nullptr), updateCount(0), pixelCount(0),
lastServerEncoding((unsigned int)-1), bpsEstimate(20000000)
{
setShared(::shared);
if (!noJpeg)
setQualityLevel(::qualityLevel);
- if(sock == NULL) {
+ if(sock == nullptr) {
try {
#ifndef WIN32
- if (strchr(vncServerName, '/') != NULL) {
+ if (strchr(vncServerName, '/') != nullptr) {
sock = new network::UnixSocket(vncServerName);
serverHost = sock->getPeerAddress();
vlog.info(_("Connected to socket %s"), serverHost.c_str());
CConnection::framebufferUpdateStart();
// For bandwidth estimate
- gettimeofday(&updateStartTime, NULL);
+ gettimeofday(&updateStartTime, nullptr);
updateStartPos = sock->inStream().pos();
// Update the screen prematurely for very slow updates
updateCount++;
// Calculate bandwidth everything managed to maintain during this update
- gettimeofday(&now, NULL);
+ gettimeofday(&now, nullptr);
elapsed = (now.tv_sec - updateStartTime.tv_sec) * 1000000;
elapsed += now.tv_usec - updateStartTime.tv_usec;
if (elapsed == 0)
DesktopWindow::DesktopWindow(int w, int h, const char *name,
const rfb::PixelFormat& serverPF,
CConn* cc_)
- : Fl_Window(w, h), cc(cc_), offscreen(NULL), overlay(NULL),
+ : Fl_Window(w, h), cc(cc_), offscreen(nullptr), overlay(nullptr),
firstUpdate(true),
delayedFullscreen(false), delayedDesktopSize(false),
keyboardGrabbed(false), mouseGrabbed(false),
statsLastUpdates(0), statsLastPixels(0), statsLastPosition(0),
- statsGraph(NULL)
+ statsGraph(nullptr)
{
Fl_Group* group;
// Dummy group to prevent FLTK from moving our widgets around
group = new Fl_Group(0, 0, w, h);
- group->resizable(NULL);
+ group->resizable(nullptr);
resizable(group);
viewport = new Viewport(w, h, serverPF, cc);
#if !defined(__APPLE__)
// Adjust offscreen surface dimensions
- if ((offscreen == NULL) ||
+ if ((offscreen == nullptr) ||
(offscreen->width() != w()) || (offscreen->height() != h())) {
delete offscreen;
offscreen = new Surface(w(), h());
overlay = new Surface(image);
overlayAlpha = 0;
- gettimeofday(&overlayStart, NULL);
+ gettimeofday(&overlayStart, nullptr);
delete image;
delete [] buffer;
Fl::add_timeout(1.0/60, updateOverlay, self);
} else {
delete self->overlay;
- self->overlay = NULL;
+ self->overlay = nullptr;
}
self->damage(FL_DAMAGE_USER1);
// FLTK keeps spamming bogus FL_MOVE events if _any_ X event is
// received with the mouse pointer outside our windows
// https://github.com/fltk/fltk/issues/76
- if ((event == FL_MOVE) && (win == NULL))
+ if ((event == FL_MOVE) && (win == nullptr))
return 0;
ret = Fl::handle_(event, win);
self->stats[statsCount-1].pps = (pixels - self->statsLastPixels) * 1000 / elapsed;
self->stats[statsCount-1].bps = (pos - self->statsLastPosition) * 1000 / elapsed;
- gettimeofday(&self->statsLastTime, NULL);
+ gettimeofday(&self->statsLastTime, nullptr);
self->statsLastUpdates = updates;
self->statsLastPixels = pixels;
self->statsLastPosition = pos;
return;
}
- gettimeofday(&ght.started, NULL);
+ gettimeofday(&ght.started, nullptr);
ght.active = true;
ght.lastX = ght.firstX = x;
ght.lastY = ght.firstY = y;
longpressTimer.stop();
if (!waitingRelease) {
- gettimeofday(&releaseStart, NULL);
+ gettimeofday(&releaseStart, nullptr);
waitingRelease = true;
// Can't be a tap that requires more touches than we current have
// For most gesture events the current (average) position is the
// most useful
- getPosition(NULL, NULL, &avgX, &avgY);
+ getPosition(nullptr, nullptr, &avgX, &avgY);
// However we have a slight distance to detect gestures, so for the
// first gesture event we want to use the first positions we saw
if (t == GestureBegin)
- getPosition(&avgX, &avgY, NULL, NULL);
+ getPosition(&avgX, &avgY, nullptr, nullptr);
// For these gestures, we always want the event coordinates
// to be where the gesture began, not the current touch location.
switch (state) {
case GH_TWODRAG:
case GH_PINCH:
- getPosition(&avgX, &avgY, NULL, NULL);
+ getPosition(&avgX, &avgY, nullptr, nullptr);
break;
}
if (state == GH_PINCH) {
if (t == GestureBegin)
getAverageDistance(&gev.magnitudeX, &gev.magnitudeY,
- NULL, NULL);
+ nullptr, nullptr);
else
- getAverageDistance(NULL, NULL,
+ getAverageDistance(nullptr, nullptr,
&gev.magnitudeX, &gev.magnitudeY);
} else if (state == GH_TWODRAG) {
if (t == GestureBegin)
if (number.size() <= 0)
return false;
- int v = strtol(number.c_str(), NULL, 0);
+ int v = strtol(number.c_str(), nullptr, 0);
if (v <= 0)
return false;
void OptionsDialog::showDialog(void)
{
- static OptionsDialog *dialog = NULL;
+ static OptionsDialog *dialog = nullptr;
if (!dialog)
dialog = new OptionsDialog();
encodingGroup->end();
/* Needed for resize to work sanely */
- encodingGroup->resizable(NULL);
+ encodingGroup->resizable(nullptr);
encodingGroup->size(encodingGroup->w(), ty - encodingGroup->y());
col1_ty = ty;
colorlevelGroup->end();
/* Needed for resize to work sanely */
- colorlevelGroup->resizable(NULL);
+ colorlevelGroup->resizable(nullptr);
colorlevelGroup->size(colorlevelGroup->w(),
ty - colorlevelGroup->y());
col2_ty = ty;
encryptionGroup->end();
/* Needed for resize to work sanely */
- encryptionGroup->resizable(NULL);
+ encryptionGroup->resizable(nullptr);
encryptionGroup->size(encryptionGroup->w(),
ty - encryptionGroup->y());
authenticationGroup->end();
/* Needed for resize to work sanely */
- authenticationGroup->resizable(NULL);
+ authenticationGroup->resizable(nullptr);
authenticationGroup->size(authenticationGroup->w(),
ty - authenticationGroup->y());
mouseGroup->end();
/* Needed for resize to work sanely */
- mouseGroup->resizable(NULL);
+ mouseGroup->resizable(nullptr);
mouseGroup->size(mouseGroup->w(), ty - mouseGroup->y());
/* Back to normal */
menuKeyChoice = new Fl_Choice(LBLLEFT(tx, ty, 150, CHOICE_HEIGHT, _("Menu key")));
- fltk_menu_add(menuKeyChoice, _("None"), 0, NULL, (void*)0, FL_MENU_DIVIDER);
+ fltk_menu_add(menuKeyChoice, _("None"), 0, nullptr, nullptr, FL_MENU_DIVIDER);
for (int i = 0; i < getMenuKeySymbolCount(); i++)
- fltk_menu_add(menuKeyChoice, getMenuKeySymbols()[i].name, 0, NULL, 0, 0);
+ fltk_menu_add(menuKeyChoice, getMenuKeySymbols()[i].name, 0, nullptr, nullptr, 0);
ty += CHOICE_HEIGHT + TIGHT_MARGIN;
}
keyboardGroup->end();
/* Needed for resize to work sanely */
- keyboardGroup->resizable(NULL);
+ keyboardGroup->resizable(nullptr);
keyboardGroup->size(keyboardGroup->w(), ty - keyboardGroup->y());
/* Back to normal */
clipboardGroup->end();
/* Needed for resize to work sanely */
- clipboardGroup->resizable(NULL);
+ clipboardGroup->resizable(nullptr);
clipboardGroup->size(clipboardGroup->w(), ty - clipboardGroup->y());
/* Back to normal */
displayModeGroup->end();
/* Needed for resize to work sanely */
- displayModeGroup->resizable(NULL);
+ displayModeGroup->resizable(nullptr);
displayModeGroup->size(displayModeGroup->w(),
ty - displayModeGroup->y());
public:
static void showDialog(void);
- static void addCallback(OptionsCallback *cb, void *data = NULL);
+ static void addCallback(OptionsCallback *cb, void *data = nullptr);
static void removeCallback(OptionsCallback *cb);
void show(void);
PlatformPixelBuffer::PlatformPixelBuffer(int width, int height) :
FullFramePixelBuffer(rfb::PixelFormat(32, 24, false, true,
255, 255, 255, 16, 8, 0),
- 0, 0, NULL, 0),
+ 0, 0, nullptr, 0),
Surface(width, height)
#if !defined(WIN32) && !defined(__APPLE__)
- , shminfo(NULL), xim(NULL)
+ , shminfo(nullptr), xim(nullptr)
#endif
{
#if !defined(WIN32) && !defined(__APPLE__)
if (!setupShm(width, height)) {
- xim = XCreateImage(fl_display, CopyFromParent, 32,
- ZPixmap, 0, 0, width, height, 32, 0);
+ xim = XCreateImage(fl_display, (Visual*)CopyFromParent, 32,
+ ZPixmap, 0, nullptr, width, height, 32, 0);
if (!xim)
throw rdr::Exception("XCreateImage");
vlog.debug("Freeing shared memory XImage");
XShmDetach(fl_display, shminfo);
shmdt(shminfo->shmaddr);
- shmctl(shminfo->shmid, IPC_RMID, 0);
+ shmctl(shminfo->shmid, IPC_RMID, nullptr);
delete shminfo;
- shminfo = NULL;
+ shminfo = nullptr;
}
// XDestroyImage() will free(xim->data) if appropriate
if (xim)
XDestroyImage(xim);
- xim = NULL;
+ xim = nullptr;
#endif
}
GC gc;
- gc = XCreateGC(fl_display, pixmap, 0, NULL);
+ gc = XCreateGC(fl_display, pixmap, 0, nullptr);
if (shminfo) {
XShmPutImage(fl_display, pixmap, gc, xim,
r.tl.x, r.tl.y, r.tl.x, r.tl.y,
int major, minor;
Bool pixmaps;
XErrorHandler old_handler;
- const char *display_name = XDisplayName (NULL);
+ const char *display_name = XDisplayName(nullptr);
/* Don't use MIT-SHM on remote displays */
if (*display_name && *display_name != ':')
shminfo = new XShmSegmentInfo;
- xim = XShmCreateImage(fl_display, CopyFromParent, 32,
- ZPixmap, 0, shminfo, width, height);
+ xim = XShmCreateImage(fl_display, (Visual*)CopyFromParent, 32,
+ ZPixmap, nullptr, shminfo, width, height);
if (!xim)
goto free_shminfo;
if (shminfo->shmid == -1)
goto free_xim;
- shminfo->shmaddr = xim->data = (char*)shmat(shminfo->shmid, 0, 0);
- shmctl(shminfo->shmid, IPC_RMID, 0); // to avoid memory leakage
+ shminfo->shmaddr = xim->data = (char*)shmat(shminfo->shmid, nullptr, 0);
+ shmctl(shminfo->shmid, IPC_RMID, nullptr); // to avoid memory leakage
if (shminfo->shmaddr == (char *)-1)
goto free_xim;
free_xim:
XDestroyImage(xim);
- xim = NULL;
+ xim = nullptr;
free_shminfo:
delete shminfo;
- shminfo = NULL;
+ shminfo = nullptr;
return 0;
}
y += BUTTON_HEIGHT + INNER_MARGIN;
/* Needed for resize to work sanely */
- resizable(NULL);
+ resizable(nullptr);
h(y-INNER_MARGIN+OUTER_MARGIN);
callback(this->handleCancel, this);
while (dialog.shown()) Fl::wait();
- if (dialog.serverName->value() == NULL) {
+ if (dialog.serverName->value() == nullptr) {
newservername[0] = '\0';
return;
}
Fl::wait();
// Did the user hit cancel?
- if (file_chooser->value() == NULL) {
+ if (file_chooser->value() == nullptr) {
delete(file_chooser);
return;
}
Fl::wait();
// Did the user hit cancel?
- if (file_chooser->value() == NULL) {
+ if (file_chooser->value() == nullptr) {
delete(file_chooser);
return;
}
// The file already exists.
fclose(f);
int overwrite_choice = fl_choice(_("%s already exists. Do you want to overwrite?"),
- _("Overwrite"), _("No"), NULL, filename);
+ _("Overwrite"), _("No"), nullptr, filename);
if (overwrite_choice == 1) {
// If the user doesn't want to overwrite:
dialog->hide();
try {
- saveViewerParameters(NULL, servername);
+ saveViewerParameters(nullptr, servername);
} catch (Exception& e) {
vlog.error("%s", e.str());
fl_alert(_("Unable to save the default configuration:\n\n%s"),
#endif
const char* stateDir = os::getvncstatedir();
- if (stateDir == NULL)
+ if (stateDir == nullptr)
throw Exception(_("Could not obtain the state directory path"));
char filepath[PATH_MAX];
#endif
const char* stateDir = os::getvncstatedir();
- if (stateDir == NULL)
+ if (stateDir == nullptr)
throw Exception(_("Could not obtain the state directory path"));
char filepath[PATH_MAX];
CGImageRef image;
- provider = CGDataProviderCreateWithData(NULL, data,
- w * h * 4, NULL);
+ provider = CGDataProviderCreateWithData(nullptr, data,
+ w * h * 4, nullptr);
if (!provider)
throw rdr::Exception("CGDataProviderCreateWithData");
image = CGImageCreate(w, h, 8, 32, w * 4, lut,
alpha | kCGBitmapByteOrder32Little,
- provider, NULL, false, kCGRenderingIntentDefault);
+ provider, nullptr, false,
+ kCGRenderingIntentDefault);
CGDataProviderRelease(provider);
if (!image)
throw rdr::Exception("CGImageCreate");
{
HDC origdc, dstdc;
- dstdc = CreateCompatibleDC(NULL);
+ dstdc = CreateCompatibleDC(nullptr);
if (!dstdc)
throw rdr::SystemException("CreateCompatibleDC", GetLastError());
HDC dstdc, srcdc;
BLENDFUNCTION blend;
- dstdc = CreateCompatibleDC(NULL);
+ dstdc = CreateCompatibleDC(nullptr);
if (!dstdc)
throw rdr::SystemException("CreateCompatibleDC", GetLastError());
- srcdc = CreateCompatibleDC(NULL);
+ srcdc = CreateCompatibleDC(nullptr);
if (!srcdc)
throw rdr::SystemException("CreateCompatibleDC", GetLastError());
bih.biHeight = -height(); // Negative to get top-down
bih.biCompression = BI_RGB;
- bitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bih,
- DIB_RGB_COLORS, (void**)&data, NULL, 0);
+ bitmap = CreateDIBSection(nullptr, (BITMAPINFO*)&bih,
+ DIB_RGB_COLORS, (void**)&data, nullptr, 0);
if (!bitmap)
throw rdr::SystemException("CreateDIBSection", GetLastError());
}
{
Picture winPict;
- winPict = XRenderCreatePicture(fl_display, fl_window, visFormat, 0, NULL);
+ winPict = XRenderCreatePicture(fl_display, fl_window, visFormat, 0, nullptr);
XRenderComposite(fl_display, PictOpSrc, picture, None, winPict,
src_x, src_y, 0, 0, x, y, w, h);
XRenderFreePicture(fl_display, winPict);
{
Picture winPict, alpha;
- winPict = XRenderCreatePicture(fl_display, fl_window, visFormat, 0, NULL);
+ winPict = XRenderCreatePicture(fl_display, fl_window, visFormat, 0, nullptr);
alpha = alpha_mask(a);
XRenderComposite(fl_display, PictOpOver, picture, alpha, winPict,
src_x, src_y, 0, 0, x, y, w, h);
if (!format)
throw rdr::Exception("XRenderFindFormat");
- picture = XRenderCreatePicture(fl_display, pixmap, format, 0, NULL);
+ picture = XRenderCreatePicture(fl_display, pixmap, format, 0, nullptr);
visFormat = XRenderFindVisualFormat(fl_display, fl_visual->visual);
}
assert(image->w() == width());
assert(image->h() == height());
- img = XCreateImage(fl_display, CopyFromParent, 32,
- ZPixmap, 0, NULL, width(), height(),
+ img = XCreateImage(fl_display, (Visual*)CopyFromParent, 32,
+ ZPixmap, 0, nullptr, width(), height(),
32, 0);
if (!img)
throw rdr::Exception("XCreateImage");
in += image->ld() - image->w() * image->d();
}
- gc = XCreateGC(fl_display, pixmap, 0, NULL);
+ gc = XCreateGC(fl_display, pixmap, 0, nullptr);
XPutImage(fl_display, pixmap, gc, img,
0, 0, 0, 0, img->width, img->height);
XFreeGC(fl_display, gc);
static Fl_Pixmap secure_icon(secure);
static Fl_Pixmap insecure_icon(insecure);
-static int ret_val = 0;
+static long ret_val = 0;
-static void button_cb(Fl_Widget *widget, void *val) {
- ret_val = (fl_intptr_t)val;
+static void button_cb(Fl_Widget *widget, long val) {
+ ret_val = val;
widget->window()->hide();
}
int x, y;
win = new Fl_Window(410, 0, _("VNC authentication"));
- win->callback(button_cb,(void *)0);
+ win->callback(button_cb, 0);
banner = new Fl_Box(0, 0, win->w(), 20);
banner->align(FL_ALIGN_CENTER|FL_ALIGN_INSIDE|FL_ALIGN_IMAGE_NEXT_TO_TEXT);
* Compiler is not bright enough to understand that
* username won't be used further down...
*/
- username = NULL;
+ username = nullptr;
}
y += INPUT_LABEL_OFFSET;
x -= BUTTON_WIDTH;
button = new Fl_Return_Button(x, y, BUTTON_WIDTH,
BUTTON_HEIGHT, fl_ok);
- button->callback(button_cb, (void*)0);
+ button->callback(button_cb, 0);
x -= INNER_MARGIN;
x -= BUTTON_WIDTH;
button = new Fl_Button(x, y, BUTTON_WIDTH, BUTTON_HEIGHT, fl_cancel);
- button->callback(button_cb, (void*)1);
+ button->callback(button_cb, 1);
button->shortcut(FL_Escape);
x -= INNER_MARGIN;
switch (flags & 0xf) {
case M_OKCANCEL:
- return fl_choice("%s", NULL, fl_ok, fl_cancel, buffer) == 1;
+ return fl_choice("%s", nullptr, fl_ok, fl_cancel, buffer) == 1;
case M_YESNO:
- return fl_choice("%s", NULL, fl_yes, fl_no, buffer) == 1;
+ return fl_choice("%s", nullptr, fl_yes, fl_no, buffer) == 1;
case M_OK:
default:
if (((flags & 0xf0) == M_ICONERROR) ||
#endif
Viewport::Viewport(int w, int h, const rfb::PixelFormat& /*serverPF*/, CConn* cc_)
- : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(NULL),
+ : Fl_Widget(0, 0, w, h), cc(cc_), frameBuffer(nullptr),
lastPointerPos(0, 0), lastButtonMask(0),
#ifdef WIN32
altGrArmed(false),
#endif
firstLEDState(true), pendingClientClipboard(false),
- menuCtrlKey(false), menuAltKey(false), cursor(NULL)
+ menuCtrlKey(false), menuAltKey(false), cursor(nullptr)
{
#if !defined(WIN32) && !defined(__APPLE__)
XkbDescPtr xkb;
OptionsDialog::addCallback(handleOptions, this);
// Make sure we have an initial blank cursor set
- setCursor(0, 0, rfb::Point(0, 0), NULL);
+ setCursor(0, 0, rfb::Point(0, 0), nullptr);
}
mask = 0;
xkb = XkbGetMap(fl_display, XkbAllComponentsMask, XkbUseCoreKbd);
- if (xkb == NULL)
+ if (xkb == nullptr)
return 0;
for (keycode = xkb->min_key_code; keycode <= xkb->max_key_code; keycode++) {
goto out;
act = XkbKeyAction(xkb, keycode, 0);
- if (act == NULL)
+ if (act == nullptr)
goto out;
if (act->type != XkbSA_LockMods)
goto out;
if (keycode == 0)
keycode = 0x100 | xevent->xkey.keycode;
- XLookupString(&xevent->xkey, &str, 1, &keysym, NULL);
+ XLookupString(&xevent->xkey, &str, 1, &keysym, nullptr);
if (keysym == NoSymbol) {
vlog.error(_("No symbol for key code %d (in the current state)"),
(int)xevent->xkey.keycode);
contextMenu->clear();
fltk_menu_add(contextMenu, p_("ContextMenu|", "Disconn&ect"),
- 0, NULL, (void*)ID_DISCONNECT, FL_MENU_DIVIDER);
+ 0, nullptr, (void*)ID_DISCONNECT, FL_MENU_DIVIDER);
fltk_menu_add(contextMenu, p_("ContextMenu|", "&Full screen"),
- 0, NULL, (void*)ID_FULLSCREEN,
+ 0, nullptr, (void*)ID_FULLSCREEN,
FL_MENU_TOGGLE | (window()->fullscreen_active()?FL_MENU_VALUE:0));
fltk_menu_add(contextMenu, p_("ContextMenu|", "Minimi&ze"),
- 0, NULL, (void*)ID_MINIMIZE, 0);
+ 0, nullptr, (void*)ID_MINIMIZE, 0);
fltk_menu_add(contextMenu, p_("ContextMenu|", "Resize &window to session"),
- 0, NULL, (void*)ID_RESIZE,
+ 0, nullptr, (void*)ID_RESIZE,
(window()->fullscreen_active()?FL_MENU_INACTIVE:0) |
FL_MENU_DIVIDER);
fltk_menu_add(contextMenu, p_("ContextMenu|", "&Ctrl"),
- 0, NULL, (void*)ID_CTRL,
+ 0, nullptr, (void*)ID_CTRL,
FL_MENU_TOGGLE | (menuCtrlKey?FL_MENU_VALUE:0));
fltk_menu_add(contextMenu, p_("ContextMenu|", "&Alt"),
- 0, NULL, (void*)ID_ALT,
+ 0, nullptr, (void*)ID_ALT,
FL_MENU_TOGGLE | (menuAltKey?FL_MENU_VALUE:0));
if (menuKeySym) {
char sendMenuKey[64];
snprintf(sendMenuKey, 64, p_("ContextMenu|", "Send %s"), (const char *)menuKey);
- fltk_menu_add(contextMenu, sendMenuKey, 0, NULL, (void*)ID_MENUKEY, 0);
- fltk_menu_add(contextMenu, "Secret shortcut menu key", menuKeyFLTK, NULL,
+ fltk_menu_add(contextMenu, sendMenuKey, 0, nullptr, (void*)ID_MENUKEY, 0);
+ fltk_menu_add(contextMenu, "Secret shortcut menu key",
+ menuKeyFLTK, nullptr,
(void*)ID_MENUKEY, FL_MENU_INVISIBLE);
}
fltk_menu_add(contextMenu, p_("ContextMenu|", "Send Ctrl-Alt-&Del"),
- 0, NULL, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
+ 0, nullptr, (void*)ID_CTRLALTDEL, FL_MENU_DIVIDER);
fltk_menu_add(contextMenu, p_("ContextMenu|", "&Refresh screen"),
- 0, NULL, (void*)ID_REFRESH, FL_MENU_DIVIDER);
+ 0, nullptr, (void*)ID_REFRESH, FL_MENU_DIVIDER);
fltk_menu_add(contextMenu, p_("ContextMenu|", "&Options..."),
- 0, NULL, (void*)ID_OPTIONS, 0);
+ 0, nullptr, (void*)ID_OPTIONS, 0);
fltk_menu_add(contextMenu, p_("ContextMenu|", "Connection &info..."),
- 0, NULL, (void*)ID_INFO, 0);
+ 0, nullptr, (void*)ID_INFO, 0);
fltk_menu_add(contextMenu, p_("ContextMenu|", "About &TigerVNC viewer..."),
- 0, NULL, (void*)ID_ABOUT, 0);
+ 0, nullptr, (void*)ID_ABOUT, 0);
}
if (Fl::belowmouse())
window()->cursor(cursor, cursorHotspot.x, cursorHotspot.y);
- if (m == NULL)
+ if (m == nullptr)
return;
switch (m->argument()) {
{
// If window is registered as touch we can not receive gestures,
// this should not happen
- if (IsTouchWindow(hWnd, NULL))
+ if (IsTouchWindow(hWnd, nullptr))
throw rfb::Exception(_("Window is registered for touch instead of gestures"));
// We will not receive any touch/gesture events if this service
// We grab for the same events as the window is currently interested in
curmasks = XIGetSelectedEvents(fl_display, wnd, &num_masks);
- if (curmasks == NULL) {
+ if (curmasks == nullptr) {
if (num_masks == -1)
vlog.error(_("Unable to get X Input 2 event mask for window 0x%08lx"), wnd);
else
const UCKeyboardLayout *layout;
OSStatus err;
- layout = NULL;
+ layout = nullptr;
TISInputSourceRef keyboard;
CFDataRef uchr;
keyboard = TISCopyCurrentKeyboardLayoutInputSource();
uchr = (CFDataRef)TISGetInputSourceProperty(keyboard,
kTISPropertyUnicodeKeyLayoutData);
- if (uchr == NULL)
+ if (uchr == nullptr)
return nil;
layout = (const UCKeyboardLayout*)CFDataGetBytePtr(uchr);
- if (layout == NULL)
+ if (layout == nullptr)
return nil;
UInt32 dead_state;
Fl::screen_xywh(x, y, w, h, m);
- EnumDisplayMonitors(NULL, NULL, EnumDisplayMonitorsCallback,
+ EnumDisplayMonitors(nullptr, nullptr, EnumDisplayMonitorsCallback,
(LPARAM)&sys_monitors);
for (iter = sys_monitors.begin(); iter != sys_monitors.end(); ++iter) {
info = IODisplayCreateInfoDictionary(CGDisplayIOServicePort(displayID),
kIODisplayOnlyPreferredName);
- if (info == NULL)
+ if (info == nullptr)
return "";
dict = (CFDictionaryRef) CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
- if (dict == NULL) {
+ if (dict == nullptr) {
CFRelease(info);
return "";
}
if (dict_len > 0) {
CFTypeRef * names = new CFTypeRef[dict_len];
- CFDictionaryGetKeysAndValues(dict, NULL, (const void **) names);
+ CFDictionaryGetKeysAndValues(dict, nullptr, (const void **) names);
if (names[0]) {
std::string name;
fl_open_display();
- assert(fl_display != NULL);
+ assert(fl_display != nullptr);
Fl::screen_xywh(x, y, w, h, m);
if (!XQueryExtension(fl_display, "RANDR", &xi_major, &ev, &err))
return pages->child(i);
}
- return NULL;
+ return nullptr;
}
int Fl_Navigation::value(Fl_Widget *newpage)
int i, offset;
labels->clear();
- labels->resizable(NULL);
+ labels->resizable(nullptr);
if (!pages->children())
return;
CTFontRef font;
CFStringRef name;
- font = CTFontCreateUIFontForLanguage(kCTFontSystemFontType, 0.0, NULL);
- if (font != NULL) {
+ font = CTFontCreateUIFontForLanguage(kCTFontSystemFontType, 0.0, nullptr);
+ if (font != nullptr) {
name = CTFontCopyFullName(font);
- if (name != NULL) {
+ if (name != nullptr) {
CFStringGetCString(name, font_name, sizeof(font_name),
kCFStringEncodingUTF8);
/* Helper to add menu entries safely */
static inline void fltk_menu_add(Fl_Menu_ *menu, const char *text,
int shortcut, Fl_Callback *cb,
- void *data = 0, int flags = 0)
+ void *data=nullptr, int flags=0)
{
char buffer[1024];
pgettext_aux (DEFAULT_TEXT_DOMAIN, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES)
#else
# define pgettext(Msgctxt, Msgid) \
- pgettext_aux (NULL, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES)
+ pgettext_aux (nullptr, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES)
#endif
#define dpgettext(Domainname, Msgctxt, Msgid) \
pgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES)
npgettext_aux (DEFAULT_TEXT_DOMAIN, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES)
#else
# define npgettext(Msgctxt, Msgid, MsgidPlural, N) \
- npgettext_aux (NULL, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES)
+ npgettext_aux (nullptr, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES)
#endif
#define dnpgettext(Domainname, Msgctxt, Msgid, MsgidPlural, N) \
npgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES)
#endif
#define pgettext_expr(Msgctxt, Msgid) \
- dcpgettext_expr (NULL, Msgctxt, Msgid, LC_MESSAGES)
+ dcpgettext_expr (nullptr, Msgctxt, Msgid, LC_MESSAGES)
#define dpgettext_expr(Domainname, Msgctxt, Msgid) \
dcpgettext_expr (Domainname, Msgctxt, Msgid, LC_MESSAGES)
(msgctxt_len + msgid_len <= sizeof (buf)
? buf
: (char *) malloc (msgctxt_len + msgid_len));
- if (msg_ctxt_id != NULL)
+ if (msg_ctxt_id != nullptr)
#endif
{
int found_translation;
}
#define npgettext_expr(Msgctxt, Msgid, MsgidPlural, N) \
- dcnpgettext_expr (NULL, Msgctxt, Msgid, MsgidPlural, N, LC_MESSAGES)
+ dcnpgettext_expr (nullptr, Msgctxt, Msgid, MsgidPlural, N, LC_MESSAGES)
#define dnpgettext_expr(Domainname, Msgctxt, Msgid, MsgidPlural, N) \
dcnpgettext_expr (Domainname, Msgctxt, Msgid, MsgidPlural, N, LC_MESSAGES)
(msgctxt_len + msgid_len <= sizeof (buf)
? buf
: (char *) malloc (msgctxt_len + msgid_len));
- if (msg_ctxt_id != NULL)
+ if (msg_ctxt_id != nullptr)
#endif
{
int found_translation;
value = new WCHAR[destSize];
valuesize = destSize;
- LONG res = RegQueryValueExW(*hKey, name, 0, NULL, (LPBYTE)value, &valuesize);
+ LONG res = RegQueryValueExW(*hKey, name, nullptr, nullptr, (LPBYTE)value, &valuesize);
if (res != ERROR_SUCCESS){
delete [] value;
if (res != ERROR_FILE_NOT_FOUND)
if (size >= buffersize)
throw Exception(_("The name of the parameter is too large"));
- LONG res = RegQueryValueExW(*hKey, name, 0, NULL, (LPBYTE)&value, &dwordsize);
+ LONG res = RegQueryValueExW(*hKey, name, nullptr, nullptr, (LPBYTE)&value, &dwordsize);
if (res != ERROR_SUCCESS){
if (res != ERROR_FILE_NOT_FOUND)
throw rdr::SystemException("RegQueryValueExW", res);
void saveHistoryToRegKey(const vector<string>& serverHistory) {
HKEY hKey;
LONG res = RegCreateKeyExW(HKEY_CURRENT_USER,
- L"Software\\TigerVNC\\vncviewer\\history", 0, NULL,
- REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
- &hKey, NULL);
+ L"Software\\TigerVNC\\vncviewer\\history", 0, nullptr,
+ REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, nullptr,
+ &hKey, nullptr);
if (res != ERROR_SUCCESS)
throw rdr::SystemException(_("Failed to create registry key"), res);
HKEY hKey;
LONG res = RegCreateKeyExW(HKEY_CURRENT_USER,
- L"Software\\TigerVNC\\vncviewer", 0, NULL,
- REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
- &hKey, NULL);
+ L"Software\\TigerVNC\\vncviewer", 0, nullptr,
+ REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, nullptr,
+ &hKey, nullptr);
if (res != ERROR_SUCCESS)
throw rdr::SystemException(_("Failed to create registry key"), res);
for (size_t i = 0; i < sizeof(parameterArray)/sizeof(VoidParameter*); i++) {
try {
- if (dynamic_cast<StringParameter*>(parameterArray[i]) != NULL) {
+ if (dynamic_cast<StringParameter*>(parameterArray[i]) != nullptr) {
setKeyString(parameterArray[i]->getName(), *(StringParameter*)parameterArray[i], &hKey);
- } else if (dynamic_cast<IntParameter*>(parameterArray[i]) != NULL) {
+ } else if (dynamic_cast<IntParameter*>(parameterArray[i]) != nullptr) {
setKeyInt(parameterArray[i]->getName(), (int)*(IntParameter*)parameterArray[i], &hKey);
- } else if (dynamic_cast<BoolParameter*>(parameterArray[i]) != NULL) {
+ } else if (dynamic_cast<BoolParameter*>(parameterArray[i]) != nullptr) {
setKeyInt(parameterArray[i]->getName(), (int)*(BoolParameter*)parameterArray[i], &hKey);
} else {
throw Exception(_("Unknown parameter type"));
for (size_t i = 0; i < parameters_len/sizeof(VoidParameter*); i++) {
try {
- if (dynamic_cast<StringParameter*>(parameters[i]) != NULL) {
+ if (dynamic_cast<StringParameter*>(parameters[i]) != nullptr) {
if (getKeyString(parameters[i]->getName(), stringValue, buffersize, hKey))
parameters[i]->setParam(stringValue);
- } else if (dynamic_cast<IntParameter*>(parameters[i]) != NULL) {
+ } else if (dynamic_cast<IntParameter*>(parameters[i]) != nullptr) {
if (getKeyInt(parameters[i]->getName(), &intValue, hKey))
((IntParameter*)parameters[i])->setParam(intValue);
- } else if (dynamic_cast<BoolParameter*>(parameters[i]) != NULL) {
+ } else if (dynamic_cast<BoolParameter*>(parameters[i]) != nullptr) {
if (getKeyInt(parameters[i]->getName(), &intValue, hKey))
((BoolParameter*)parameters[i])->setParam(intValue);
} else {
if (res != ERROR_SUCCESS) {
if (res == ERROR_FILE_NOT_FOUND) {
// The key does not exist, defaults will be used.
- return NULL;
+ return nullptr;
}
throw rdr::SystemException(_("Failed to open registry key"), res);
char encodingBuffer[buffersize];
// Write to the registry or a predefined file if no filename was specified.
- if(filename == NULL) {
+ if(filename == nullptr) {
#ifdef _WIN32
saveToReg(servername);
#endif
const char* configDir = os::getvncconfigdir();
- if (configDir == NULL)
+ if (configDir == nullptr)
throw Exception(_("Could not obtain the config directory path"));
snprintf(filepath, sizeof(filepath), "%s/default.tigervnc", configDir);
fprintf(f, "ServerName=%s\n", encodingBuffer);
for (size_t i = 0; i < sizeof(parameterArray)/sizeof(VoidParameter*); i++) {
- if (dynamic_cast<StringParameter*>(parameterArray[i]) != NULL) {
+ if (dynamic_cast<StringParameter*>(parameterArray[i]) != nullptr) {
if (!encodeValue(*(StringParameter*)parameterArray[i],
encodingBuffer, buffersize)) {
fclose(f);
_("Could not encode parameter"));
}
fprintf(f, "%s=%s\n", ((StringParameter*)parameterArray[i])->getName(), encodingBuffer);
- } else if (dynamic_cast<IntParameter*>(parameterArray[i]) != NULL) {
+ } else if (dynamic_cast<IntParameter*>(parameterArray[i]) != nullptr) {
fprintf(f, "%s=%d\n", ((IntParameter*)parameterArray[i])->getName(), (int)*(IntParameter*)parameterArray[i]);
- } else if (dynamic_cast<BoolParameter*>(parameterArray[i]) != NULL) {
+ } else if (dynamic_cast<BoolParameter*>(parameterArray[i]) != nullptr) {
fprintf(f, "%s=%d\n", ((BoolParameter*)parameterArray[i])->getName(), (int)*(BoolParameter*)parameterArray[i]);
} else {
fclose(f);
// Find and set the correct parameter
for (size_t i = 0; i < parameters_len/sizeof(VoidParameter*); i++) {
- if (dynamic_cast<StringParameter*>(parameters[i]) != NULL) {
+ if (dynamic_cast<StringParameter*>(parameters[i]) != nullptr) {
if (strcasecmp(line, ((StringParameter*)parameters[i])->getName()) == 0) {
if(!decodeValue(value, decodingBuffer, sizeof(decodingBuffer)))
throw Exception(_("Invalid format or too large value"));
return false;
}
- } else if (dynamic_cast<IntParameter*>(parameters[i]) != NULL) {
+ } else if (dynamic_cast<IntParameter*>(parameters[i]) != nullptr) {
if (strcasecmp(line, ((IntParameter*)parameters[i])->getName()) == 0) {
((IntParameter*)parameters[i])->setParam(atoi(value));
return false;
}
- } else if (dynamic_cast<BoolParameter*>(parameters[i]) != NULL) {
+ } else if (dynamic_cast<BoolParameter*>(parameters[i]) != nullptr) {
if (strcasecmp(line, ((BoolParameter*)parameters[i])->getName()) == 0) {
((BoolParameter*)parameters[i])->setParam(atoi(value));
return false;
memset(servername, '\0', sizeof(servername));
// Load from the registry or a predefined file if no filename was specified.
- if(filename == NULL) {
+ if(filename == nullptr) {
#ifdef _WIN32
return loadFromReg();
#endif
const char* configDir = os::getvncconfigdir();
- if (configDir == NULL)
+ if (configDir == nullptr)
throw Exception(_("Could not obtain the config directory path"));
snprintf(filepath, sizeof(filepath), "%s/default.tigervnc", configDir);
FILE* f = fopen(filepath, "r");
if (!f) {
if (!filename)
- return NULL; // Use defaults.
+ return nullptr; // Use defaults.
throw Exception(_("Could not open \"%s\": %s"),
filepath, strerror(errno));
}
// Find the parameter value
char *value = strchr(line, '=');
- if (value == NULL) {
+ if (value == nullptr) {
vlog.error(_("Failed to read line %d in file %s: %s"),
lineNr, filepath, _("Invalid format"));
continue;
vlog.error(_("Failed to read line %d in file %s: %s"),
lineNr, filepath, _("Unknown parameter"));
}
- fclose(f); f=0;
-
+ fclose(f);
+ f = nullptr;
+
return servername;
}
extern rfb::StringParameter via;
#endif
-void saveViewerParameters(const char *filename, const char *servername=NULL);
+void saveViewerParameters(const char *filename, const char *servername=nullptr);
char* loadViewerParameters(const char *filename);
#ifdef _WIN32
for (iter = handlers.begin(); iter != handlers.end(); ++iter) {
curmasks = XIGetSelectedEvents(fl_display, iter->first, &num_masks);
- if (curmasks == NULL) {
+ if (curmasks == nullptr) {
if (num_masks == -1)
vlog.error(_("Unable to get X Input 2 event mask for window 0x%08lx"), iter->first);
continue;
vlog.error(_("X Input 2.2 (or newer) is not available. Touch gestures will not be supported."));
#endif
- Fl::add_system_handler(handleTouchEvent, NULL);
+ Fl::add_system_handler(handleTouchEvent, nullptr);
}
void disable_touch()
char vncServerName[VNCSERVERNAMELEN] = { '\0' };
-static const char *argv0 = NULL;
+static const char *argv0 = nullptr;
static bool inMainloop = false;
static bool exitMainloop = false;
-static char *exitError = NULL;
+static char *exitError = nullptr;
static bool fatalError = false;
static const char *about_text()
// Prioritise the first error we get as that is probably the most
// relevant one.
- if (exitError == NULL) {
+ if (exitError == nullptr) {
va_list ap;
va_start(ap, error);
exitMainloop = true;
else {
// We're early in the startup. Assume we can just exit().
- if (alertOnFatalError && (exitError != NULL))
+ if (alertOnFatalError && (exitError != nullptr))
fl_alert("%s", exitError);
exit(EXIT_FAILURE);
}
// Prioritise the first error we get as that is probably the most
// relevant one.
- if (exitError == NULL) {
+ if (exitError == nullptr) {
va_list ap;
va_start(ap, error);
delete cc;
if (fatalError) {
- assert(exitError != NULL);
+ assert(exitError != nullptr);
if (alertOnFatalError)
fl_alert("%s", exitError);
break;
}
- if (exitError == NULL)
+ if (exitError == nullptr)
break;
- if(reconnectOnError && (sock == NULL)) {
+ if(reconnectOnError && (sock == nullptr)) {
int ret;
ret = fl_choice(_("%s\n\n"
"Attempt to reconnect?"),
- NULL, fl_yes, fl_no, exitError);
+ nullptr, fl_yes, fl_no, exitError);
free(exitError);
- exitError = NULL;
+ exitError = nullptr;
if (ret == 1)
continue;
else
return;
argv[0] = argv0;
- argv[1] = NULL;
+ argv[1] = nullptr;
execvp(argv[0], (char * const *)argv);
static char localebuf[PATH_MAX];
char *slash;
- GetModuleFileName(NULL, localebuf, sizeof(localebuf));
+ GetModuleFileName(nullptr, localebuf, sizeof(localebuf));
slash = strrchr(localebuf, '\\');
- if (slash == NULL)
- return NULL;
+ if (slash == nullptr)
+ return nullptr;
*slash = '\0';
if ((strlen(localebuf) + strlen("\\locale")) >= sizeof(localebuf))
- return NULL;
+ return nullptr;
strcat(localebuf, "\\locale");
static char localebuf[PATH_MAX];
bundle = CFBundleGetMainBundle();
- if (bundle == NULL)
- return NULL;
+ if (bundle == nullptr)
+ return nullptr;
localeurl = CFBundleCopyResourceURL(bundle, CFSTR("locale"),
- NULL, NULL);
- if (localeurl == NULL)
- return NULL;
+ nullptr, nullptr);
+ if (localeurl == nullptr)
+ return nullptr;
localestr = CFURLCopyFileSystemPath(localeurl, kCFURLPOSIXPathStyle);
ret = CFStringGetCString(localestr, localebuf, sizeof(localebuf),
kCFStringEncodingUTF8);
if (!ret)
- return NULL;
+ return nullptr;
return localebuf;
#else
#ifdef WIN32
HICON lg, sm;
- lg = (HICON)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON),
+ lg = (HICON)LoadImage(GetModuleHandle(nullptr),
+ MAKEINTRESOURCE(IDI_ICON),
IMAGE_ICON, GetSystemMetrics(SM_CXICON),
GetSystemMetrics(SM_CYICON),
LR_DEFAULTCOLOR | LR_SHARED);
- sm = (HICON)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON),
+ sm = (HICON)LoadImage(GetModuleHandle(nullptr),
+ MAKEINTRESOURCE(IDI_ICON),
IMAGE_ICON, GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
LR_DEFAULTCOLOR | LR_SHARED);
Fl_Mac_App_Menu::hide_others = _("Hide Others");
Fl_Mac_App_Menu::show = _("Show All");
- fl_mac_set_about(about_callback, NULL);
+ fl_mac_set_about(about_callback, nullptr);
Fl_Sys_Menu_Bar *menubar;
char buffer[1024];
// which means we cannot use our generic Fl_Menu_ helpers.
if (fltk_menu_escape(p_("SysMenu|", "&File"),
buffer, sizeof(buffer)) < sizeof(buffer))
- menubar->add(buffer, 0, 0, 0, FL_SUBMENU);
+ menubar->add(buffer, 0, nullptr, nullptr, FL_SUBMENU);
if (fltk_menu_escape(p_("SysMenu|File|", "&New Connection"),
buffer, sizeof(buffer)) < sizeof(buffer))
menubar->insert(1, buffer, FL_COMMAND | 'n', new_connection_cb);
{
#ifdef WIN32
// If we don't have a console then we need to create one for output
- if (GetConsoleWindow() == NULL) {
+ if (GetConsoleWindow() == nullptr) {
HANDLE handle;
int fd;
static void
potentiallyLoadConfigurationFile(char *vncServerName)
{
- const bool hasPathSeparator = (strchr(vncServerName, '/') != NULL ||
- (strchr(vncServerName, '\\')) != NULL);
+ const bool hasPathSeparator = (strchr(vncServerName, '/') != nullptr ||
+ (strchr(vncServerName, '\\')) != nullptr);
if (hasPathSeparator) {
#ifndef WIN32
{
const int SERVER_PORT_OFFSET = 5900;
char *pos = strchr(vncServerName, ':');
- if (pos == NULL)
+ if (pos == nullptr)
*remotePort = SERVER_PORT_OFFSET;
else {
int portOffset = SERVER_PORT_OFFSET;
cmd = "/usr/bin/ssh -f -L \"$L\":\"$H\":\"$R\" \"$G\" sleep 20";
/* Compatibility with TigerVNC's method. */
cmd2 = strdup(cmd);
- while ((percent = strchr(cmd2, '%')) != NULL)
+ while ((percent = strchr(cmd2, '%')) != nullptr)
*percent = '$';
system(cmd2);
free(cmd2);
setlocale(LC_ALL, "");
localedir = getlocaledir();
- if (localedir == NULL)
+ if (localedir == nullptr)
fprintf(stderr, "Failed to determine locale directory\n");
else
bindtextdomain(PACKAGE_NAME, localedir);
char defaultServerName[VNCSERVERNAMELEN] = "";
try {
const char* configServerName;
- configServerName = loadViewerParameters(NULL);
- if (configServerName != NULL) {
+ configServerName = loadViewerParameters(nullptr);
+ if (configServerName != nullptr) {
strncpy(defaultServerName, configServerName, VNCSERVERNAMELEN-1);
defaultServerName[VNCSERVERNAMELEN-1] = '\0';
}
VoidParameter *param;
param = Configuration::getParam(&argv[i][1]);
- if ((param != NULL) &&
- (dynamic_cast<BoolParameter*>(param) != NULL)) {
+ if ((param != nullptr) &&
+ (dynamic_cast<BoolParameter*>(param) != nullptr)) {
if ((strcasecmp(argv[i+1], "0") == 0) ||
(strcasecmp(argv[i+1], "1") == 0) ||
(strcasecmp(argv[i+1], "true") == 0) ||
Fl::display(display);
}
fl_open_display();
- XkbSetDetectableAutoRepeat(fl_display, True, NULL);
+ XkbSetDetectableAutoRepeat(fl_display, True, nullptr);
#endif
init_fltk();
char *confdir = strdup(os::getvncconfigdir());
#ifndef WIN32
char *dotdir = strrchr(confdir, '.');
- if (dotdir != NULL && strcmp(dotdir, ".vnc") == 0)
+ if (dotdir != nullptr && strcmp(dotdir, ".vnc") == 0)
vlog.info(_("~/.vnc is deprecated, please consult 'man vncviewer' for paths to migrate to."));
#else
char *vncdir = strrchr(confdir, '\\');
- if (vncdir != NULL && strcmp(vncdir, "vnc") == 0)
+ if (vncdir != nullptr && strcmp(vncdir, "vnc") == 0)
vlog.info(_("%%APPDATA%%\\vnc is deprecated, please switch to the %%APPDATA%%\\TigerVNC location."));
#endif
CSecurity::msg = &dlg;
#endif
- Socket *sock = NULL;
+ Socket *sock = nullptr;
#ifndef WIN32
/* Specifying -via and -listen together is nonsense */
if (isdigit(vncServerName[0]))
port = atoi(vncServerName);
- createTcpListeners(&listeners, 0, port);
+ createTcpListeners(&listeners, nullptr, port);
if (listeners.empty())
throw Exception(_("Unable to listen for incoming connections"));
vlog.info(_("Listening on port %d"), port);
/* Wait for a connection */
- while (sock == NULL) {
+ while (sock == nullptr) {
fd_set rfds;
FD_ZERO(&rfds);
for (std::list<SocketListener*>::iterator i = listeners.begin();
i++)
FD_SET((*i)->getFd(), &rfds);
- int n = select(FD_SETSIZE, &rfds, 0, 0, 0);
+ int n = select(FD_SETSIZE, &rfds, nullptr, nullptr, nullptr);
if (n < 0) {
if (errno == EINTR) {
vlog.debug("Interrupted select() system call");
AboutDialog AboutDialog::instance;
-AboutDialog::AboutDialog() : Dialog(GetModuleHandle(0)) {
+AboutDialog::AboutDialog() : Dialog(GetModuleHandle(nullptr)) {
}
bool AboutDialog::showDialog() {
struct ActiveDesktop {
- ActiveDesktop() : handle(0) {
+ ActiveDesktop() : handle(nullptr) {
// - Contact Active Desktop
- HRESULT result = CoCreateInstance(CLSID_ActiveDesktop, NULL, CLSCTX_INPROC_SERVER,
+ HRESULT result = CoCreateInstance(CLSID_ActiveDesktop, nullptr, CLSCTX_INPROC_SERVER,
IID_IActiveDesktop, (PVOID*)&handle);
if (result != S_OK)
throw rdr::SystemException("failed to contact Active Desktop", result);
CleanDesktop::CleanDesktop() : restoreActiveDesktop(false),
restoreWallpaper(false),
restoreEffects(false) {
- CoInitialize(0);
+ CoInitialize(nullptr);
}
CleanDesktop::~CleanDesktop() {
vlog.debug("restore desktop wallpaper");
// -=- Then restore the standard wallpaper if required
- SysParamsInfo(SPI_SETDESKWALLPAPER, 0, NULL, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETDESKWALLPAPER, 0, nullptr, SPIF_SENDCHANGE);
restoreWallpaper = false;
}
vlog.debug("disable desktop effects");
- SysParamsInfo(SPI_SETFONTSMOOTHING, FALSE, 0, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETFONTSMOOTHING, FALSE, nullptr, SPIF_SENDCHANGE);
if (SysParamsInfo(SPI_GETUIEFFECTS, 0, &uiEffects, 0) == ERROR_CALL_NOT_IMPLEMENTED) {
SysParamsInfo(SPI_GETCOMBOBOXANIMATION, 0, &comboBoxAnim, 0);
SysParamsInfo(SPI_GETGRADIENTCAPTIONS, 0, &gradientCaptions, 0);
SysParamsInfo(SPI_GETHOTTRACKING, 0, &hotTracking, 0);
SysParamsInfo(SPI_GETLISTBOXSMOOTHSCROLLING, 0, &listBoxSmoothScroll, 0);
SysParamsInfo(SPI_GETMENUANIMATION, 0, &menuAnim, 0);
- SysParamsInfo(SPI_SETCOMBOBOXANIMATION, 0, FALSE, SPIF_SENDCHANGE);
- SysParamsInfo(SPI_SETGRADIENTCAPTIONS, 0, FALSE, SPIF_SENDCHANGE);
- SysParamsInfo(SPI_SETHOTTRACKING, 0, FALSE, SPIF_SENDCHANGE);
- SysParamsInfo(SPI_SETLISTBOXSMOOTHSCROLLING, 0, FALSE, SPIF_SENDCHANGE);
- SysParamsInfo(SPI_SETMENUANIMATION, 0, FALSE, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETCOMBOBOXANIMATION, 0, (PVOID)FALSE, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETGRADIENTCAPTIONS, 0, (PVOID)FALSE, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETHOTTRACKING, 0, (PVOID)FALSE, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETLISTBOXSMOOTHSCROLLING, 0, (PVOID)FALSE, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETMENUANIMATION, 0, (PVOID)FALSE, SPIF_SENDCHANGE);
} else {
- SysParamsInfo(SPI_SETUIEFFECTS, 0, FALSE, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETUIEFFECTS, 0, (PVOID)FALSE, SPIF_SENDCHANGE);
// We *always* restore UI effects overall, since there is no Windows GUI to do it
uiEffects = TRUE;
RegKey desktopCfg;
desktopCfg.openKey(HKEY_CURRENT_USER, "Control Panel\\Desktop");
- SysParamsInfo(SPI_SETFONTSMOOTHING, desktopCfg.getInt("FontSmoothing", 0) != 0, 0, SPIF_SENDCHANGE);
+ SysParamsInfo(SPI_SETFONTSMOOTHING, desktopCfg.getInt("FontSmoothing", 0) != 0, nullptr, SPIF_SENDCHANGE);
if (SysParamsInfo(SPI_SETUIEFFECTS, 0, (void*)(intptr_t)uiEffects, SPIF_SENDCHANGE) == ERROR_CALL_NOT_IMPLEMENTED) {
SysParamsInfo(SPI_SETCOMBOBOXANIMATION, 0, (void*)(intptr_t)comboBoxAnim, SPIF_SENDCHANGE);
SysParamsInfo(SPI_SETGRADIENTCAPTIONS, 0, (void*)(intptr_t)gradientCaptions, SPIF_SENDCHANGE);
//
Clipboard::Clipboard()
- : MsgWindow("Clipboard"), notifier(0), next_window(0) {
+ : MsgWindow("Clipboard"), notifier(nullptr), next_window(nullptr) {
next_window = SetClipboardViewer(getHandle());
vlog.debug("registered clipboard handler");
}
(long long)wParam, (long long)lParam);
if ((HWND) wParam == next_window)
next_window = (HWND) lParam;
- else if (next_window != 0)
+ else if (next_window != nullptr)
SendMessage(next_window, msg, wParam, lParam);
else
vlog.error("bad clipboard chain change!");
} else {
vlog.debug("local clipboard changed by %p", owner);
- if (notifier == NULL)
+ if (notifier == nullptr)
vlog.debug("no clipboard notifier registered");
else
notifier->notifyClipboardChanged(IsClipboardFormatAvailable(CF_UNICODETEXT));
// Open the clipboard
if (!OpenClipboard(getHandle()))
- return NULL;
+ return nullptr;
// Get the clipboard data
cliphandle = GetClipboardData(CF_UNICODETEXT);
if (!cliphandle) {
CloseClipboard();
- return NULL;
+ return nullptr;
}
clipdata = (wchar_t*) GlobalLock(cliphandle);
if (!clipdata) {
CloseClipboard();
- return NULL;
+ return nullptr;
}
// Convert it to UTF-8
void
Clipboard::setClipText(const char* text) {
- HANDLE clip_handle = 0;
+ HANDLE clip_handle = nullptr;
try {
// - Set the new clipboard data
if (!SetClipboardData(CF_UNICODETEXT, clip_handle))
throw rdr::SystemException("unable to set Win32 clipboard", GetLastError());
- clip_handle = 0;
+ clip_handle = nullptr;
vlog.debug("set clipboard");
} catch (rdr::Exception& e) {
DIBSectionBuffer::DIBSectionBuffer(HWND window_)
- : bitmap(0), window(window_), device(0) {
+ : bitmap(nullptr), window(window_), device(nullptr) {
}
DIBSectionBuffer::DIBSectionBuffer(HDC device_)
- : bitmap(0), window(0), device(device_) {
+ : bitmap(nullptr), window(nullptr), device(device_) {
}
DIBSectionBuffer::~DIBSectionBuffer() {
}
void DIBSectionBuffer::initBuffer(const PixelFormat& pf, int w, int h) {
- HBITMAP new_bitmap = 0;
- uint8_t* new_data = 0;
+ HBITMAP new_bitmap = nullptr;
+ uint8_t* new_data = nullptr;
if (!pf.trueColour)
throw rfb::Exception("palette format not supported");
// Create a DIBSection to draw into
if (device)
new_bitmap = ::CreateDIBSection(device, (BITMAPINFO*)&bi.bmiHeader, iUsage,
- (void**)&new_data, NULL, 0);
+ (void**)&new_data, nullptr, 0);
else
new_bitmap = ::CreateDIBSection(WindowDC(window), (BITMAPINFO*)&bi.bmiHeader, iUsage,
- (void**)&new_data, NULL, 0);
+ (void**)&new_data, nullptr, 0);
if (!new_bitmap) {
int err = GetLastError();
if (bitmap) {
// Delete the old bitmap
DeleteObject(bitmap);
- bitmap = 0;
- setBuffer(0, 0, NULL, 0);
+ bitmap = nullptr;
+ setBuffer(0, 0, nullptr, 0);
}
if (new_bitmap) {
memset(&bi, 0, sizeof(bi));
bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bi.bmiHeader.biBitCount = 0;
- if (!::GetDIBits(dc, bitmap, 0, 1, NULL, (BITMAPINFO*)&bi, DIB_RGB_COLORS)) {
+ if (!::GetDIBits(dc, bitmap, 0, 1, nullptr, (BITMAPINFO*)&bi, DIB_RGB_COLORS)) {
throw rdr::SystemException("unable to determine device pixel format", GetLastError());
}
- if (!::GetDIBits(dc, bitmap, 0, 1, NULL, (BITMAPINFO*)&bi, DIB_RGB_COLORS)) {
+ if (!::GetDIBits(dc, bitmap, 0, 1, nullptr, (BITMAPINFO*)&bi, DIB_RGB_COLORS)) {
throw rdr::SystemException("unable to determine pixel shifts/palette", GetLastError());
}
DeviceDC::DeviceDC(const char* deviceName) {
- dc = ::CreateDC("DISPLAY", deviceName, NULL, NULL);
+ dc = ::CreateDC("DISPLAY", deviceName, nullptr, nullptr);
if (!dc)
throw rdr::SystemException("failed to create DeviceDC", GetLastError());
}
// and the pixel format, and access to the HDC itself.
class DeviceContext {
public:
- DeviceContext() : dc(0) {}
+ DeviceContext() : dc(nullptr) {}
virtual ~DeviceContext() {}
operator HDC() const {return dc;}
PixelFormat getPF() const;
{
// - If hCursor is null then there is no cursor - clear the old one
- if (hCursor == 0) {
- server->setCursor(0, 0, Point(), NULL);
+ if (hCursor == nullptr) {
+ server->setCursor(0, 0, Point(), nullptr);
return;
}
Dialog::Dialog(HINSTANCE inst_)
-: inst(inst_), handle(0), alreadyShowing(false)
+: inst(inst_), handle(nullptr), alreadyShowing(false)
{
}
bool Dialog::showDialog(const char* resource, HWND owner)
{
if (alreadyShowing) return false;
- handle = 0;
+ handle = nullptr;
alreadyShowing = true;
INT_PTR result = DialogBoxParam(inst, resource, owner,
staticDialogProc, (LPARAM)this);
}
-PropSheetPage::PropSheetPage(HINSTANCE inst, const char* id) : Dialog(inst), propSheet(0) {
+PropSheetPage::PropSheetPage(HINSTANCE inst, const char* id) : Dialog(inst), propSheet(nullptr) {
page.dwSize = sizeof(page);
page.dwFlags = 0; // PSP_USECALLBACK;
page.hInstance = inst;
page.pszTemplate = id;
page.pfnDlgProc = staticPageProc;
page.lParam = (LPARAM)this;
- page.pfnCallback = 0; // staticPageProc;
+ page.pfnCallback = nullptr; // staticPageProc;
}
PropSheetPage::~PropSheetPage() {
PropSheet::PropSheet(HINSTANCE inst_, const char* title_, std::list<PropSheetPage*> pages_, HICON icon_)
-: icon(icon_), pages(pages_), inst(inst_), title(title_), handle(0), alreadyShowing(0) {
+: icon(icon_), pages(pages_), inst(inst_), title(title_), handle(nullptr), alreadyShowing(0) {
}
PropSheet::~PropSheet() {
}
handle = (HWND)PropertySheet(&header);
- if ((handle == 0) || (handle == (HWND)-1))
+ if ((handle == nullptr) || (handle == (HWND)-1))
throw rdr::SystemException("PropertySheet failed", GetLastError());
centerWindow(handle, owner);
plog.info("created %p", handle);
EnableWindow(owner, FALSE);
// Run the PropertySheet
MSG msg;
- while (GetMessage(&msg, 0, 0, 0)) {
+ while (GetMessage(&msg, nullptr, 0, 0)) {
if (!PropSheet_IsDialogMessage(handle, &msg))
DispatchMessage(&msg);
if (!PropSheet_GetCurrentPageHwnd(handle))
plog.info("finished %p", handle);
DestroyWindow(handle);
- handle = 0;
+ handle = nullptr;
alreadyShowing = false;
// Clear up the pages' GDI objects
for (pspi=pages.begin(); pspi!=pages.end(); pspi++)
- (*pspi)->setPropSheet(0);
- delete [] hpages; hpages = 0;
+ (*pspi)->setPropSheet(nullptr);
+ delete [] hpages; hpages = nullptr;
return true;
} catch (rdr::Exception&) {
std::list<PropSheetPage*>::iterator pspi;
for (pspi=pages.begin(); pspi!=pages.end(); pspi++)
- (*pspi)->setPropSheet(0);
- delete [] hpages; hpages = 0;
+ (*pspi)->setPropSheet(nullptr);
+ delete [] hpages; hpages = nullptr;
throw;
}
// expansion), and owner is an optional window handle - the corresponding
// window is disabled while the dialog box is displayed.
- bool showDialog(const char* resource, HWND owner=0);
+ bool showDialog(const char* resource, HWND owner=nullptr);
// initDialog() is called upon receipt of the WM_INITDIALOG message.
class PropSheet {
public:
- PropSheet(HINSTANCE inst, const char* title, std::list<PropSheetPage*> pages, HICON icon=0);
+ PropSheet(HINSTANCE inst, const char* title, std::list<PropSheetPage*> pages, HICON icon=nullptr);
virtual ~PropSheet();
// Display the PropertySheet
class Handle {
public:
- Handle(HANDLE h_=0) : h(h_) {}
+ Handle(HANDLE h_=nullptr) : h(h_) {}
~Handle() {
if (h) CloseHandle(h);
}
IntervalTimer(HWND hwnd_, int id_)
: hwnd(hwnd_), id(id_), active(false) {
}
- IntervalTimer() : hwnd(0), id(0), active(false) {
+ IntervalTimer() : hwnd(nullptr), id(0), active(false) {
}
~IntervalTimer() {
stop();
void start(int interval_) {
if (!active || interval_ != interval) {
interval = interval_;
- if (!SetTimer(hwnd, id, interval, 0))
+ if (!SetTimer(hwnd, id, interval, nullptr))
throw rdr::SystemException("SetTimer", GetLastError());
active = true;
}
BOOL success;
if (userToken != INVALID_HANDLE_VALUE)
success = CreateProcessAsUser(userToken, exePath.c_str(),
- (char*)cmdLine.c_str(), 0, 0, FALSE,
- flags, 0, 0, &sinfo, &procInfo);
+ (char*)cmdLine.c_str(),
+ nullptr, nullptr, FALSE,
+ flags, nullptr, nullptr,
+ &sinfo, &procInfo);
else
- success = CreateProcess(exePath.c_str(), (char*)cmdLine.c_str(), 0,
- 0, FALSE, flags, 0, 0, &sinfo, &procInfo);
+ success = CreateProcess(exePath.c_str(), (char*)cmdLine.c_str(),
+ nullptr, nullptr, FALSE,
+ flags, nullptr, nullptr,
+ &sinfo, &procInfo);
if (!success)
throw rdr::SystemException("unable to launch process", GetLastError());
~LocalMem() {LocalFree(ptr);}
operator void*() {return ptr;}
void* takePtr() {
- void* t = ptr; ptr = 0; return t;
+ void* t = ptr; ptr = nullptr; return t;
}
void* ptr;
};
namespace win32 {
struct ModuleFileName {
- ModuleFileName(HMODULE module=0) {
+ ModuleFileName(HMODULE module=nullptr) {
if (!module)
- module = GetModuleHandle(0);
+ module = GetModuleHandle(nullptr);
if (!GetModuleFileName(module, buf, MAX_PATH))
buf[0] = 0;
}
monitorByNameData data;
data.info = this;
data.monitorName = devName;
- EnumDisplayMonitors(0, 0, &monitorByNameEnumProc, (LPARAM)&data);
+ EnumDisplayMonitors(nullptr, nullptr, &monitorByNameEnumProc, (LPARAM)&data);
}
void MonitorInfo::moveTo(HWND handle) {
RECT r;
GetWindowRect(handle, &r);
clipTo(&r);
- SetWindowPos(handle, 0, r.left, r.top, r.right-r.left, r.bottom-r.top,
+ SetWindowPos(handle, nullptr, r.left, r.top, r.right-r.left, r.bottom-r.top,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
}
// Wrapper around Win32 MessageBox()
static int MsgBox(HWND parent, const char* msg, UINT flags) {
- const char* msgType = 0;
+ const char* msgType = nullptr;
UINT tflags = flags & 0x70;
if (tflags == MB_ICONHAND)
msgType = "Error";
wndClass.lpfnWndProc = MsgWindowProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
- wndClass.hInstance = instance = GetModuleHandle(0);
- wndClass.hIcon = 0;
- wndClass.hCursor = 0;
- wndClass.hbrBackground = 0;
- wndClass.lpszMenuName = 0;
+ wndClass.hInstance = instance = GetModuleHandle(nullptr);
+ wndClass.hIcon = nullptr;
+ wndClass.hCursor = nullptr;
+ wndClass.hbrBackground = nullptr;
+ wndClass.lpszMenuName = nullptr;
wndClass.lpszClassName = "rfb::win32::MsgWindowClass";
classAtom = RegisterClass(&wndClass);
if (!classAtom) {
// -=- MsgWindow
//
-MsgWindow::MsgWindow(const char* name_) : name(name_), handle(0) {
+MsgWindow::MsgWindow(const char* name_) : name(name_), handle(nullptr) {
vlog.debug("creating window \"%s\"", name.c_str());
handle = CreateWindow((const char*)(intptr_t)baseClass.classAtom,
- name.c_str(), WS_OVERLAPPED, 0, 0, 10, 10, 0, 0,
- baseClass.instance, this);
+ name.c_str(), WS_OVERLAPPED, 0, 0, 10, 10,
+ nullptr, nullptr, baseClass.instance, this);
if (!handle) {
throw rdr::SystemException("unable to create WMNotifier window instance", GetLastError());
}
static LogWriter vlog("RegConfig");
-RegConfig::RegConfig(EventManager* em) : eventMgr(em), event(CreateEvent(0, TRUE, FALSE, 0)), callback(0) {
+RegConfig::RegConfig(EventManager* em)
+ : eventMgr(em), event(CreateEvent(nullptr, TRUE, FALSE, nullptr)),
+ callback(nullptr)
+{
if (em->addEvent(event, this))
eventMgr = em;
}
BOOL result = 0;
MSG msg;
thread_id = GetCurrentThreadId();
- while ((result = eventMgr.getMessage(&msg, 0, 0, 0)) > 0) {}
+ while ((result = eventMgr.getMessage(&msg, nullptr, 0, 0)) > 0) {}
if (result < 0)
throw rdr::SystemException("RegConfigThread failed", GetLastError());
}
static LogWriter vlog("Registry");
-RegKey::RegKey() : key(0), freeKey(false), valueName(NULL), valueNameBufLen(0) {}
+RegKey::RegKey() : key(nullptr), freeKey(false), valueName(nullptr), valueNameBufLen(0) {}
-RegKey::RegKey(const HKEY k) : key(0), freeKey(false), valueName(NULL), valueNameBufLen(0) {
- LONG result = RegOpenKeyEx(k, 0, 0, KEY_ALL_ACCESS, &key);
+RegKey::RegKey(const HKEY k) : key(nullptr), freeKey(false), valueName(nullptr), valueNameBufLen(0) {
+ LONG result = RegOpenKeyEx(k, nullptr, 0, KEY_ALL_ACCESS, &key);
if (result != ERROR_SUCCESS)
throw rdr::SystemException("RegOpenKeyEx(HKEY)", result);
vlog.debug("duplicated %p to %p", k, key);
freeKey = true;
}
-RegKey::RegKey(const RegKey& k) : key(0), freeKey(false), valueName(NULL), valueNameBufLen(0) {
- LONG result = RegOpenKeyEx(k.key, 0, 0, KEY_ALL_ACCESS, &key);
+RegKey::RegKey(const RegKey& k) : key(nullptr), freeKey(false), valueName(nullptr), valueNameBufLen(0) {
+ LONG result = RegOpenKeyEx(k.key, nullptr, 0, KEY_ALL_ACCESS, &key);
if (result != ERROR_SUCCESS)
throw rdr::SystemException("RegOpenKeyEx(RegKey&)", result);
vlog.debug("duplicated %p to %p", k.key, key);
if ((result = SetSecurityInfo(key, SE_REGISTRY_KEY,
DACL_SECURITY_INFORMATION |
(inherit ? UNPROTECTED_DACL_SECURITY_INFORMATION : PROTECTED_DACL_SECURITY_INFORMATION),
- 0, 0, acl, 0)) != ERROR_SUCCESS)
+ nullptr, nullptr, acl, nullptr)) != ERROR_SUCCESS)
throw rdr::SystemException("RegKey::setDACL failed", result);
}
if (freeKey) {
vlog.debug("RegCloseKey(%p)", key);
RegCloseKey(key);
- key = 0;
+ key = nullptr;
}
}
}
void RegKey::awaitChange(bool watchSubTree, DWORD filter, HANDLE event) const {
- LONG result = RegNotifyChangeKeyValue(key, watchSubTree, filter, event, event != 0);
+ LONG result = RegNotifyChangeKeyValue(key, watchSubTree, filter, event, event != nullptr);
if (result != ERROR_SUCCESS)
throw rdr::SystemException("RegNotifyChangeKeyValue", result);
}
std::string RegKey::getRepresentation(const char* valname) const {
DWORD type, length;
- LONG result = RegQueryValueEx(key, valname, 0, &type, 0, &length);
+ LONG result = RegQueryValueEx(key, valname, nullptr, &type, nullptr, &length);
if (result != ERROR_SUCCESS)
throw rdr::SystemException("get registry value length", result);
std::vector<uint8_t> data(length);
- result = RegQueryValueEx(key, valname, 0, &type, (BYTE*)data.data(), &length);
+ result = RegQueryValueEx(key, valname, nullptr, &type, (BYTE*)data.data(), &length);
if (result != ERROR_SUCCESS)
throw rdr::SystemException("get registry value", result);
{
if (length) {
std::string str((char*)data.data(), length);
- DWORD required = ExpandEnvironmentStrings(str.c_str(), 0, 0);
+ DWORD required = ExpandEnvironmentStrings(str.c_str(), nullptr, 0);
if (required==0)
throw rdr::SystemException("ExpandEnvironmentStrings", GetLastError());
std::vector<char> result(required);
const char* RegKey::getValueName(int i) {
DWORD maxValueNameLen;
- LONG result = RegQueryInfoKey(key, 0, 0, 0, 0, 0, 0, 0, &maxValueNameLen, 0, 0, 0);
+ LONG result = RegQueryInfoKey(key, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, &maxValueNameLen, nullptr, nullptr, nullptr);
if (result != ERROR_SUCCESS)
throw rdr::SystemException("RegQueryInfoKey", result);
if (valueNameBufLen < maxValueNameLen + 1) {
valueName = new char[valueNameBufLen];
}
DWORD length = valueNameBufLen;
- result = RegEnumValue(key, i, valueName, &length, NULL, 0, 0, 0);
- if (result == ERROR_NO_MORE_ITEMS) return 0;
+ result = RegEnumValue(key, i, valueName, &length, nullptr, nullptr, nullptr, nullptr);
+ if (result == ERROR_NO_MORE_ITEMS) return nullptr;
if (result != ERROR_SUCCESS)
throw rdr::SystemException("RegEnumValue", result);
return valueName;
const char* RegKey::getKeyName(int i) {
DWORD maxValueNameLen;
- LONG result = RegQueryInfoKey(key, 0, 0, 0, 0, &maxValueNameLen, 0, 0, 0, 0, 0, 0);
+ LONG result = RegQueryInfoKey(key, nullptr, nullptr, nullptr, nullptr, &maxValueNameLen, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
if (result != ERROR_SUCCESS)
throw rdr::SystemException("RegQueryInfoKey", result);
if (valueNameBufLen < maxValueNameLen + 1) {
valueName = new char[valueNameBufLen];
}
DWORD length = valueNameBufLen;
- result = RegEnumKeyEx(key, i, valueName, &length, NULL, 0, 0, 0);
- if (result == ERROR_NO_MORE_ITEMS) return 0;
+ result = RegEnumKeyEx(key, i, valueName, &length, nullptr, nullptr, nullptr, nullptr);
+ if (result == ERROR_NO_MORE_ITEMS) return nullptr;
if (result != ERROR_SUCCESS)
throw rdr::SystemException("RegEnumKey", result);
return valueName;
// Block waiting for a registry change, OR return immediately and notify the
// event when there is a change, if specified
- void awaitChange(bool watchSubTree, DWORD filter, HANDLE event=0) const;
+ void awaitChange(bool watchSubTree, DWORD filter, HANDLE event=nullptr) const;
void setExpandString(const char* valname, const char* s) const;
void setString(const char* valname, const char* s) const;
// -=- Constructor/Destructor
SDisplay::SDisplay()
- : server(0), pb(0), device(0),
- core(0), ptr(0), kbd(0), clipboard(0),
- inputs(0), monitor(0), cleanDesktop(0), cursor(0),
- statusLocation(0), queryConnectionHandler(0), ledState(0)
+ : server(nullptr), pb(nullptr), device(nullptr),
+ core(nullptr), ptr(nullptr), kbd(nullptr), clipboard(nullptr),
+ inputs(nullptr), monitor(nullptr), cleanDesktop(nullptr), cursor(nullptr),
+ statusLocation(nullptr), queryConnectionHandler(nullptr), ledState(0)
{
- updateEvent.h = CreateEvent(0, TRUE, FALSE, 0);
- terminateEvent.h = CreateEvent(0, TRUE, FALSE, 0);
+ updateEvent.h = CreateEvent(nullptr, TRUE, FALSE, nullptr);
+ terminateEvent.h = CreateEvent(nullptr, TRUE, FALSE, nullptr);
}
SDisplay::~SDisplay()
// the VNCServer ought not to exist and therefore we shouldn't invoke any
// methods on it. Setting server to zero here ensures that stop() doesn't
// call setPixelBuffer(0) on the server.
- server = 0;
+ server = nullptr;
if (core) stop();
}
}
// Stop the SDisplayCore
- server->setPixelBuffer(0);
+ server->setPixelBuffer(nullptr);
stopCore();
vlog.debug("stopped");
void SDisplay::queryConnection(network::Socket* sock,
const char* userName)
{
- assert(server != NULL);
+ assert(server != nullptr);
if (queryConnectionHandler) {
queryConnectionHandler->queryConnection(sock, userName);
core = new SDisplayCorePolling(this, &updates);
core->setScreenRect(screenRect);
} catch (rdr::Exception& e) {
- delete core; core = 0;
+ delete core; core = nullptr;
if (tryMethod == 0)
throw rdr::Exception("unable to access desktop");
tryMethod--;
void SDisplay::stopCore() {
if (core)
vlog.info("Stopping %s", core->methodName());
- delete core; core = 0;
- delete pb; pb = 0;
- delete device; device = 0;
- delete monitor; monitor = 0;
- delete clipboard; clipboard = 0;
- delete inputs; inputs = 0;
- delete ptr; ptr = 0;
- delete kbd; kbd = 0;
- delete cleanDesktop; cleanDesktop = 0;
- delete cursor; cursor = 0;
+ delete core; core = nullptr;
+ delete pb; pb = nullptr;
+ delete device; device = nullptr;
+ delete monitor; monitor = nullptr;
+ delete clipboard; clipboard = nullptr;
+ delete inputs; inputs = nullptr;
+ delete ptr; ptr = nullptr;
+ delete kbd; kbd = nullptr;
+ delete cleanDesktop; cleanDesktop = nullptr;
+ delete cursor; cursor = nullptr;
ResetEvent(updateEvent);
}
// Update the cursor shape
if (set_cursor)
- pb->setCursor(info.visible ? info.cursor : 0, server);
+ pb->setCursor(info.visible ? info.cursor : nullptr, server);
// Update the cursor position
// NB: First translate from Screen coordinates to Desktop
// If no device is specified, open entire screen using GetDC().
// Opening the whole display with CreateDC doesn't work on multi-monitor
// systems for some reason.
- DeviceContext* new_device = 0;
+ DeviceContext* new_device = nullptr;
if (strlen(displayDevice) > 0) {
vlog.info("Attaching to device %s", (const char*)displayDevice);
new_device = new DeviceDC(displayDevice);
}
if (!new_device) {
vlog.info("Attaching to virtual desktop");
- new_device = new WindowDC(0);
+ new_device = new WindowDC(nullptr);
}
// Get the coordinates of the specified dispay device
Trustee::Trustee(const char* name,
TRUSTEE_FORM form,
TRUSTEE_TYPE type) {
- pMultipleTrustee = 0;
+ pMultipleTrustee = nullptr;
MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
TrusteeForm = form;
TrusteeType = type;
}
-AccessEntries::AccessEntries() : entries(0), entry_count(0) {}
+AccessEntries::AccessEntries() : entries(nullptr), entry_count(0) {}
AccessEntries::~AccessEntries() {
delete [] entries;
DWORD nameLen = 0;
DWORD domainLen = 0;
SID_NAME_USE use;
- LookupAccountSid(0, (PSID)*this, 0, &nameLen, 0, &domainLen, &use);
+ LookupAccountSid(nullptr, (PSID)*this, nullptr, &nameLen, nullptr, &domainLen, &use);
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
throw rdr::SystemException("Unable to determine SID name lengths", GetLastError());
vlog.info("nameLen=%lu, domainLen=%lu, use=%d", nameLen, domainLen, use);
*name = new char[nameLen];
*domain = new char[domainLen];
- if (!LookupAccountSid(0, (PSID)*this, *name, &nameLen, *domain, &domainLen, &use))
+ if (!LookupAccountSid(nullptr, (PSID)*this, *name, &nameLen, *domain, &domainLen, &use))
throw rdr::SystemException("Unable to lookup account SID", GetLastError());
}
Sid::Administrators::Administrators() {
- PSID sid = 0;
+ PSID sid = nullptr;
SID_IDENTIFIER_AUTHORITY ntAuth = { SECURITY_NT_AUTHORITY };
if (!AllocateAndInitializeSid(&ntAuth, 2,
SECURITY_BUILTIN_DOMAIN_RID,
}
Sid::SYSTEM::SYSTEM() {
- PSID sid = 0;
+ PSID sid = nullptr;
SID_IDENTIFIER_AUTHORITY ntAuth = { SECURITY_NT_AUTHORITY };
if (!AllocateAndInitializeSid(&ntAuth, 1,
SECURITY_LOCAL_SYSTEM_RID,
Sid::FromToken::FromToken(HANDLE h) {
DWORD required = 0;
- GetTokenInformation(h, TokenUser, 0, 0, &required);
+ GetTokenInformation(h, TokenUser, nullptr, 0, &required);
std::vector<uint8_t> tmp(required);
if (!GetTokenInformation(h, TokenUser, tmp.data(), tmp.size(), &required))
throw rdr::SystemException("GetTokenInformation", GetLastError());
// Helper class for handling & freeing ACLs
struct AccessControlList : public LocalMem {
AccessControlList(int size) : LocalMem(size) {}
- AccessControlList(PACL acl_=0) : LocalMem(acl_) {}
+ AccessControlList(PACL acl_=nullptr) : LocalMem(acl_) {}
operator PACL() {return (PACL)ptr;}
};
// Create a new ACL based on supplied entries and, if supplied, existing ACL
- PACL CreateACL(const AccessEntries& ae, PACL existing_acl=0);
+ PACL CreateACL(const AccessEntries& ae, PACL existing_acl=nullptr);
// Helper class for memory-management of self-relative SecurityDescriptors
struct SecurityDescriptorPtr : LocalMem {
SecurityDescriptorPtr(int size) : LocalMem(size) {}
- SecurityDescriptorPtr(PSECURITY_DESCRIPTOR sd_=0) : LocalMem(sd_) {}
+ SecurityDescriptorPtr(PSECURITY_DESCRIPTOR sd_=nullptr) : LocalMem(sd_) {}
PSECURITY_DESCRIPTOR takeSD() {return (PSECURITY_DESCRIPTOR)takePtr();}
};
/* XXX: This class contains bunch of similar code to unix/vncviewer/CConn.cxx */
SecurityPage::SecurityPage(Security *security_)
- : PropSheetPage(GetModuleHandle(0), MAKEINTRESOURCE(IDD_SECURITY)),
+ : PropSheetPage(GetModuleHandle(nullptr), MAKEINTRESOURCE(IDD_SECURITY)),
security(security_) {
}
// - Internal service implementation functions
-Service* service = 0;
+Service* service = nullptr;
bool runAsService = false;
VOID WINAPI serviceHandler(DWORD control) {
Service::Service(const char* name_) : name(name_) {
vlog.debug("Service");
- status_handle = 0;
+ status_handle = nullptr;
status.dwControlsAccepted = SERVICE_CONTROL_INTERROGATE | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_STOP;
status.dwServiceType = SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS;
status.dwWin32ExitCode = NO_ERROR;
SERVICE_TABLE_ENTRY entry[2];
entry[0].lpServiceName = (char*)name;
entry[0].lpServiceProc = serviceProc;
- entry[1].lpServiceName = NULL;
- entry[1].lpServiceProc = NULL;
+ entry[1].lpServiceName = nullptr;
+ entry[1].lpServiceProc = nullptr;
vlog.debug("entering dispatcher");
if (!SetProcessShutdownParameters(0x100, 0))
vlog.error("unable to set shutdown parameters: %lu", GetLastError());
void
Service::setStatus(DWORD state) {
- if (status_handle == 0) {
+ if (status_handle == nullptr) {
vlog.debug("warning - cannot setStatus");
return;
}
Service::~Service() {
vlog.debug("~Service");
- service = 0;
+ service = nullptr;
}
bool
rfb::win32::emulateCtrlAltDel() {
rfb::win32::Handle sessionEventCad =
- CreateEvent(0, FALSE, FALSE, "Global\\SessionEventTigerVNCCad");
+ CreateEvent(nullptr, FALSE, FALSE, "Global\\SessionEventTigerVNCCad");
SetEvent(sessionEventCad);
return true;
}
class Logger_EventLog : public Logger {
public:
Logger_EventLog(const char* srcname) : Logger("EventLog") {
- eventlog = RegisterEventSource(NULL, srcname);
+ eventlog = RegisterEventSource(nullptr, srcname);
if (!eventlog)
printf("Unable to open event log:%ld\n", GetLastError());
}
const char* strings[] = {logname, message};
WORD type = EVENTLOG_INFORMATION_TYPE;
if (level == 0) type = EVENTLOG_ERROR_TYPE;
- if (!ReportEvent(eventlog, type, 0, VNC4LogMessage, NULL, 2, 0, strings, NULL)) {
+ if (!ReportEvent(eventlog, type, 0, VNC4LogMessage, nullptr, 2, 0, strings, nullptr)) {
// *** It's not at all clear what is the correct behaviour if this fails...
printf("ReportEvent failed:%ld\n", GetLastError());
}
HANDLE eventlog;
};
-static Logger_EventLog* logger = 0;
+static Logger_EventLog* logger = nullptr;
bool rfb::win32::initEventLogLogger(const char* srcname) {
if (logger)
// - Register the service
// - Open the SCM
- ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
+ ServiceHandle scm = OpenSCManager(nullptr, nullptr, SC_MANAGER_CREATE_SERVICE);
if (!scm)
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
name, display, SC_MANAGER_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_IGNORE,
- cmdline.c_str(), NULL, NULL, NULL, NULL, NULL);
+ cmdline.c_str(), nullptr, nullptr, nullptr, nullptr, nullptr);
if (!service)
throw rdr::SystemException("unable to create service", GetLastError());
bool rfb::win32::unregisterService(const char* name) {
// - Open the SCM
- ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
+ ServiceHandle scm = OpenSCManager(nullptr, nullptr, SC_MANAGER_CREATE_SERVICE);
if (!scm)
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
bool rfb::win32::startService(const char* name) {
// - Open the SCM
- ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
+ ServiceHandle scm = OpenSCManager(nullptr, nullptr, SC_MANAGER_CONNECT);
if (!scm)
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
throw rdr::SystemException("unable to open the service", GetLastError());
// - Start the service
- if (!StartService(service, 0, NULL))
+ if (!StartService(service, 0, nullptr))
throw rdr::SystemException("unable to start the service", GetLastError());
Sleep(500);
bool rfb::win32::stopService(const char* name) {
// - Open the SCM
- ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
+ ServiceHandle scm = OpenSCManager(nullptr, nullptr, SC_MANAGER_CONNECT);
if (!scm)
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
DWORD rfb::win32::getServiceState(const char* name) {
// - Open the SCM
- ServiceHandle scm = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
+ ServiceHandle scm = OpenSCManager(nullptr, nullptr, SC_MANAGER_CONNECT);
if (!scm)
throw rdr::SystemException("unable to open Service Control Manager", GetLastError());
static void requestAddressChangeEvents(network::SocketListener* sock_) {
DWORD dummy = 0;
- if (WSAIoctl(sock_->getFd(), SIO_ADDRESS_LIST_CHANGE, 0, 0, 0, 0, &dummy, 0, 0) == SOCKET_ERROR) {
+ if (WSAIoctl(sock_->getFd(), SIO_ADDRESS_LIST_CHANGE, nullptr, 0, nullptr, 0, &dummy, nullptr, nullptr) == SOCKET_ERROR) {
DWORD err = WSAGetLastError();
if (err != WSAEWOULDBLOCK)
vlog.error("Unable to track address changes: 0x%08x", (unsigned)err);
network::Socket* new_sock = li.sock->accept();
if (new_sock && li.disable) {
delete new_sock;
- new_sock = 0;
+ new_sock = nullptr;
}
if (new_sock)
addSocket(new_sock, li.server, false);
// VNCServer.
void addListener(network::SocketListener* sock_,
VNCServer* srvr,
- AddressChangeNotifier* acn = 0);
+ AddressChangeNotifier* acn = nullptr);
// Remove and delete a listening socket.
void remListener(network::SocketListener* sock);
nid.hWnd = getHandle();
nid.uID = 0;
- nid.hIcon = 0;
+ nid.hIcon = nullptr;
nid.uFlags = NIF_ICON | NIF_MESSAGE;
nid.uCallbackMessage = WM_USER;
}
if (icon == 0) {
return remove();
} else {
- nid.hIcon = (HICON)LoadImage(GetModuleHandle(0), MAKEINTRESOURCE(icon),
+ nid.hIcon = (HICON)LoadImage(GetModuleHandle(nullptr), MAKEINTRESOURCE(icon),
IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
return refresh();
}
}
bool setToolTip(const char* text) {
- if (text == 0) {
+ if (text == nullptr) {
nid.uFlags &= ~NIF_TIP;
} else {
const int tipLen = sizeof(nid.szTip)/sizeof(char);
static LogWriter vlog("WMCursor");
-WMCursor::WMCursor() : cursor(0) {
- cursor = (HCURSOR)LoadImage(0, IDC_ARROW, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
+WMCursor::WMCursor() : cursor(nullptr) {
+ cursor = (HCURSOR)LoadImage(nullptr, IDC_ARROW, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE | LR_SHARED);
}
WMCursor::~WMCursor() {
HCURSOR cursor;
Point position;
bool visible;
- Info() : cursor(0), visible(false) {}
+ Info() : cursor(nullptr), visible(false) {}
bool operator!=(const Info& info) {
return ((cursor != info.cursor) ||
(position != info.position) ||
static void LoadHooks()
{
- if (hooksLibrary != NULL)
+ if (hooksLibrary != nullptr)
return;
hooksLibrary = LoadLibrary("wm_hooks.dll");
- if (hooksLibrary == NULL)
+ if (hooksLibrary == nullptr)
return;
WM_Hooks_WindowChanged = (WM_Hooks_WMVAL_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_WindowChanged");
- if (WM_Hooks_WindowChanged == NULL)
+ if (WM_Hooks_WindowChanged == nullptr)
goto error;
WM_Hooks_WindowBorderChanged = (WM_Hooks_WMVAL_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_WindowBorderChanged");
- if (WM_Hooks_WindowBorderChanged == NULL)
+ if (WM_Hooks_WindowBorderChanged == nullptr)
goto error;
WM_Hooks_WindowClientAreaChanged = (WM_Hooks_WMVAL_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_WindowClientAreaChanged");
- if (WM_Hooks_WindowClientAreaChanged == NULL)
+ if (WM_Hooks_WindowClientAreaChanged == nullptr)
goto error;
WM_Hooks_RectangleChanged = (WM_Hooks_WMVAL_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_RectangleChanged");
- if (WM_Hooks_RectangleChanged == NULL)
+ if (WM_Hooks_RectangleChanged == nullptr)
goto error;
#ifdef _DEBUG
WM_Hooks_Diagnostic = (WM_Hooks_WMVAL_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_Diagnostic");
- if (WM_Hooks_Diagnostic == NULL)
+ if (WM_Hooks_Diagnostic == nullptr)
goto error;
#endif
WM_Hooks_Install = (WM_Hooks_Install_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_Install");
- if (WM_Hooks_Install == NULL)
+ if (WM_Hooks_Install == nullptr)
goto error;
WM_Hooks_Remove = (WM_Hooks_Remove_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_Remove");
- if (WM_Hooks_Remove == NULL)
+ if (WM_Hooks_Remove == nullptr)
goto error;
#ifdef _DEBUG
WM_Hooks_SetDiagnosticRange = (WM_Hooks_SetDiagnosticRange_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_SetDiagnosticRange");
- if (WM_Hooks_SetDiagnosticRange == NULL)
+ if (WM_Hooks_SetDiagnosticRange == nullptr)
goto error;
#endif
WM_Hooks_EnableRealInputs = (WM_Hooks_EnableRealInputs_proto)(void*)GetProcAddress(hooksLibrary, "WM_Hooks_EnableRealInputs");
- if (WM_Hooks_EnableRealInputs == NULL)
+ if (WM_Hooks_EnableRealInputs == nullptr)
goto error;
return;
error:
FreeLibrary(hooksLibrary);
- hooksLibrary = NULL;
+ hooksLibrary = nullptr;
}
DWORD thread_id;
};
-static WMHooksThread* hook_mgr = 0;
+static WMHooksThread* hook_mgr = nullptr;
static std::list<WMHooks*> hooks;
static os::Mutex hook_mgr_lock;
static bool StartHookThread() {
if (hook_mgr)
return true;
- if (hooksLibrary == NULL)
+ if (hooksLibrary == nullptr)
return false;
vlog.debug("creating thread");
hook_mgr = new WMHooksThread();
vlog.error("failed to initialise hooks");
hook_mgr->stop();
delete hook_mgr;
- hook_mgr = 0;
+ hook_mgr = nullptr;
return false;
}
return true;
vlog.debug("closing thread");
hook_mgr->stop();
delete hook_mgr;
- hook_mgr = 0;
+ hook_mgr = nullptr;
}
thread_id = GetCurrentThreadId();
- while (active && GetMessage(&msg, NULL, 0, 0)) {
+ while (active && GetMessage(&msg, nullptr, 0, 0)) {
count++;
if (msg.message == WM_TIMER) {
// -=- WMHooks class
-rfb::win32::WMHooks::WMHooks() : updateEvent(0) {
+rfb::win32::WMHooks::WMHooks() : updateEvent(nullptr) {
LoadHooks();
}
static bool blocking = false;
static bool blockRealInputs(bool block_) {
// NB: Requires blockMutex to be held!
- if (hooksLibrary == NULL)
+ if (hooksLibrary == nullptr)
return false;
if (block_) {
if (blocking)
static LogWriter vlog("WMMonitor");
-WMMonitor::WMMonitor() : MsgWindow("WMMonitor"), notifier(0) {
+WMMonitor::WMMonitor() : MsgWindow("WMMonitor"), notifier(nullptr) {
}
WMMonitor::~WMMonitor() {
class WMPoller {
public:
- WMPoller() : ut(0) {}
+ WMPoller() : ut(nullptr) {}
bool processEvent();
bool setUpdateTracker(UpdateTracker* ut);
// -=- WMHooks class
-rfb::win32::WMCopyRect::WMCopyRect() : ut(0), fg_window(0) {
+rfb::win32::WMCopyRect::WMCopyRect() : ut(nullptr), fg_window(nullptr) {
}
bool
fg_window = window;
fg_window_rect = winrect;
} else {
- fg_window = 0;
+ fg_window = nullptr;
}
} else {
- fg_window = 0;
+ fg_window = nullptr;
}
return false;
}
// Attempt to open the file, to cause Access Denied, etc, errors
// to be correctly reported, since the GetFileVersionInfoXXX calls lie...
{
- Handle file(CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0));
+ Handle file(CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
if (file.h == INVALID_HANDLE_VALUE)
throw rdr::SystemException("Failed to open file", GetLastError());
}
infoName = format("\\StringFileInfo\\%s\\%s", langIdStr.c_str(), name);
// Locate the required version string within the version info
- char* buffer = 0;
+ char* buffer = nullptr;
UINT length = 0;
if (!VerQueryValue(buf, infoName.c_str(), (void**)&buffer, &length)) {
printf("unable to find %s version string", infoName.c_str());
int x = (r.left + r.right - w)/2;
int y = (r.top + r.bottom - h)/2;
UINT flags = SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOSIZE;
- SetWindowPos(handle, 0, x, y, 0, 0, flags);
+ SetWindowPos(handle, nullptr, x, y, 0, 0, flags);
}
void resizeWindow(HWND handle, int width, int height) {
RECT r;
GetWindowRect(handle, &r);
- SetWindowPos(handle, 0, 0, 0, width, height, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOMOVE);
+ SetWindowPos(handle, nullptr, 0, 0, width, height, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_NOMOVE);
centerWindow(handle, r);
}
namespace win32 {
struct FileVersionInfo {
- FileVersionInfo(const char* filename=0);
+ FileVersionInfo(const char* filename=nullptr);
~FileVersionInfo();
const char* getVerString(const char* name, DWORD langId = 0x080904b0);
private:
class SecPage : public SecurityPage {
public:
SecPage(const RegKey& rk)
- : SecurityPage(NULL), regKey(rk) {
+ : SecurityPage(nullptr), regKey(rk) {
security = new SecurityServer();
}
if (isItemChecked(IDC_AUTH_VNC))
verifyVncPassword(regKey);
else if (haveVncPassword() &&
- MsgBox(0, "The VNC authentication method is disabled, but a password is still stored for it.\n"
+ MsgBox(nullptr, "The VNC authentication method is disabled, but a password is still stored for it.\n"
"Do you want to remove the VNC authentication password from the registry?",
MB_ICONWARNING | MB_YESNO) == IDYES) {
- regKey.setBinary("Password", 0, 0);
+ regKey.setBinary("Password", nullptr, 0);
}
#ifdef HAVE_GNUTLS
static void verifyVncPassword(const RegKey& regKey) {
if (!haveVncPassword()) {
- MsgBox(0, "The VNC authentication method is enabled, but no password is specified.\n"
+ MsgBox(nullptr, "The VNC authentication method is enabled, but no password is specified.\n"
"The password dialog will now be shown.", MB_ICONINFORMATION | MB_OK);
PasswordDialog passwd(regKey, registryInsecure);
passwd.showDialog();
ofn.nMaxFile = sizeof(filename);
ofn.lpstrFilter = (char*)filter;
ofn.nFilterIndex = 1;
- ofn.lpstrFileTitle = NULL;
+ ofn.lpstrFileTitle = nullptr;
ofn.nMaxFileTitle = 0;
ofn.lpstrTitle = (char*)title;
- ofn.lpstrInitialDir = NULL;
+ ofn.lpstrInitialDir = nullptr;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
if (GetOpenFileName(&ofn)==TRUE) {
class ConnHostDialog : public Dialog {
public:
- ConnHostDialog() : Dialog(GetModuleHandle(0)) {}
+ ConnHostDialog() : Dialog(GetModuleHandle(nullptr)) {}
bool showDialog(const char* pat) {
pattern = pat;
return Dialog::showDialog(MAKEINTRESOURCE(IDD_CONN_HOST));
network::TcpFilter::Pattern pat(network::TcpFilter::parsePattern(newPat.c_str()));
pattern = network::TcpFilter::patternToStr(pat);
} catch(rdr::Exception& e) {
- MsgBox(NULL, e.str(), MB_ICONEXCLAMATION | MB_OK);
+ MsgBox(nullptr, e.str(), MB_ICONEXCLAMATION | MB_OK);
return false;
}
return true;
class ConnectionsPage : public PropSheetPage {
public:
ConnectionsPage(const RegKey& rk)
- : PropSheetPage(GetModuleHandle(0), MAKEINTRESOURCE(IDD_CONNECTIONS)), regKey(rk) {}
+ : PropSheetPage(GetModuleHandle(nullptr), MAKEINTRESOURCE(IDD_CONNECTIONS)), regKey(rk) {}
void initDialog() {
vlog.debug("set IDC_PORT %d", (int)port_number);
setItemInt(IDC_PORT, port_number ? port_number : 5900);
class DesktopPage : public PropSheetPage {
public:
DesktopPage(const RegKey& rk)
- : PropSheetPage(GetModuleHandle(0), MAKEINTRESOURCE(IDD_DESKTOP)), regKey(rk) {}
+ : PropSheetPage(GetModuleHandle(nullptr), MAKEINTRESOURCE(IDD_DESKTOP)), regKey(rk) {}
void initDialog() {
const char *action(rfb::win32::SDisplay::disconnectAction);
bool disconnectLock = stricmp(action, "Lock") == 0;
class HookingPage : public PropSheetPage {
public:
HookingPage(const RegKey& rk)
- : PropSheetPage(GetModuleHandle(0), MAKEINTRESOURCE(IDD_HOOKING)), regKey(rk) {}
+ : PropSheetPage(GetModuleHandle(nullptr), MAKEINTRESOURCE(IDD_HOOKING)), regKey(rk) {}
void initDialog() {
setItemChecked(IDC_USEPOLLING, rfb::win32::SDisplay::updateMethod == 0);
setItemChecked(IDC_USEHOOKS, (rfb::win32::SDisplay::updateMethod == 1));
class InputsPage : public PropSheetPage {
public:
InputsPage(const RegKey& rk)
- : PropSheetPage(GetModuleHandle(0), MAKEINTRESOURCE(IDD_INPUTS)),
+ : PropSheetPage(GetModuleHandle(nullptr), MAKEINTRESOURCE(IDD_INPUTS)),
regKey(rk), enableAffectSSaver(true) {}
void initDialog() {
setItemChecked(IDC_ACCEPT_KEYS, rfb::Server::acceptKeyEvents);
regKey.setBool("DisableLocalInputs", isItemChecked(IDC_DISABLE_LOCAL_INPUTS));
if (enableAffectSSaver) {
BOOL blocked = !isItemChecked(IDC_AFFECT_SCREENSAVER);
- SystemParametersInfo(SPI_SETBLOCKSENDINPUTRESETS, blocked, 0, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
+ SystemParametersInfo(SPI_SETBLOCKSENDINPUTRESETS, blocked, nullptr, SPIF_UPDATEINIFILE | SPIF_SENDCHANGE);
}
return true;
}
try {
winvnc3.openKey(HKEY_LOCAL_MACHINE, "Software\\ORL\\WinVNC3");
int debugMode = winvnc3.getInt("DebugMode", 0);
- const char* debugTarget = 0;
+ const char* debugTarget = nullptr;
if (debugMode & 2) debugTarget = "file";
if (debugMode & 4) debugTarget = "stderr";
if (debugTarget) {
// Finally, save the Hosts value
regKey.setString("Hosts", newHosts.c_str());
} catch (rdr::Exception&) {
- MsgBox(0, "Unable to convert AuthHosts setting to Hosts format.",
+ MsgBox(nullptr, "Unable to convert AuthHosts setting to Hosts format.",
MB_ICONWARNING | MB_OK);
}
} else {
{
regKey.setInt("PortNumber", key.getBool("SocketConnect") ? key.getInt("PortNumber", 5900) : 0);
if (key.getBool("AutoPortSelect", false)) {
- MsgBox(0, "The AutoPortSelect setting is not supported by this release."
+ MsgBox(nullptr, "The AutoPortSelect setting is not supported by this release."
"The port number will default to 5900.",
MB_ICONWARNING | MB_OK);
regKey.setInt("PortNumber", 5900);
if (key.getInt("QuerySetting", 2) != 2) {
regKey.setBool("QueryConnect", key.getInt("QuerySetting") > 2);
- MsgBox(0, "The QuerySetting option has been replaced by QueryConnect."
+ MsgBox(nullptr, "The QuerySetting option has been replaced by QueryConnect."
"Please see the documentation for details of the QueryConnect option.",
MB_ICONWARNING | MB_OK);
}
regKey.setBool("UseHooks", !key.getBool("PollFullScreen", false));
if (key.isValue("AllowShutdown"))
- MsgBox(0, "The AllowShutdown option is not supported by this release.", MB_ICONWARNING | MB_OK);
+ MsgBox(nullptr, "The AllowShutdown option is not supported by this release.", MB_ICONWARNING | MB_OK);
if (key.isValue("AllowEditClients"))
- MsgBox(0, "The AllowEditClients option is not supported by this release.", MB_ICONWARNING | MB_OK);
+ MsgBox(nullptr, "The AllowEditClients option is not supported by this release.", MB_ICONWARNING | MB_OK);
allowProperties = key.getBool("AllowProperties", allowProperties);
}
class LegacyPage : public PropSheetPage {
public:
LegacyPage(const RegKey& rk, bool userSettings_)
- : PropSheetPage(GetModuleHandle(0), MAKEINTRESOURCE(IDD_LEGACY)), regKey(rk), userSettings(userSettings_) {}
+ : PropSheetPage(GetModuleHandle(nullptr), MAKEINTRESOURCE(IDD_LEGACY)), regKey(rk), userSettings(userSettings_) {}
void initDialog() {
setItemChecked(IDC_PROTOCOL_3_3, rfb::Server::protocol3_3);
}
switch (id) {
case IDC_LEGACY_IMPORT:
{
- DWORD result = MsgBox(0,
+ DWORD result = MsgBox(nullptr,
"Importing your legacy VNC 3.3 settings will overwrite your existing settings.\n"
"Are you sure you wish to continue?",
MB_ICONWARNING | MB_YESNO);
if (result == IDYES) {
LoadPrefs();
- MsgBox(0, "Imported VNC 3.3 settings successfully.",
+ MsgBox(nullptr, "Imported VNC 3.3 settings successfully.",
MB_ICONINFORMATION | MB_OK);
// Sleep to allow RegConfig thread to reload settings
using namespace win32;
PasswordDialog::PasswordDialog(const RegKey& rk, bool registryInsecure_)
- : Dialog(GetModuleHandle(0)), regKey(rk), registryInsecure(registryInsecure_) {
+ : Dialog(GetModuleHandle(nullptr)), regKey(rk), registryInsecure(registryInsecure_) {
}
bool PasswordDialog::showDialog(HWND owner) {
std::string password1(getItemString(IDC_PASSWORD1));
std::string password2(getItemString(IDC_PASSWORD2));
if (password1 != password2) {
- MsgBox(0, "The supplied passwords do not match",
+ MsgBox(nullptr, "The supplied passwords do not match",
MB_ICONEXCLAMATION | MB_OK);
return false;
}
if (registryInsecure &&
- (MsgBox(0, "Please note that your password cannot be stored securely on this system. "
+ (MsgBox(nullptr, "Please note that your password cannot be stored securely on this system. "
"Are you sure you wish to continue?",
MB_YESNO | MB_ICONWARNING) == IDNO))
return false;
class PasswordDialog : public Dialog {
public:
PasswordDialog(const RegKey& rk, bool registryInsecure_);
- bool showDialog(HWND owner=0);
+ bool showDialog(HWND owner=nullptr);
bool onOk();
protected:
const RegKey& regKey;
class SharingPage : public PropSheetPage {
public:
SharingPage(const RegKey& rk)
- : PropSheetPage(GetModuleHandle(0), MAKEINTRESOURCE(IDD_SHARING)), regKey(rk) {}
+ : PropSheetPage(GetModuleHandle(nullptr), MAKEINTRESOURCE(IDD_SHARING)), regKey(rk) {}
void initDialog() {
setItemChecked(IDC_DISCONNECT_CLIENTS, rfb::Server::disconnectClients);
setItemChecked(IDC_SHARE_NEVER, rfb::Server::neverShared);
freopen("CONIN$","rb",stdin);
freopen("CONOUT$","wb",stdout);
freopen("CONOUT$","wb",stderr);
- setbuf(stderr, 0);
+ setbuf(stderr, nullptr);
initStdIOLoggers();
LogWriter vlog("main");
logParams.setParam("*:stderr:100");
// Something weird happens on NT 4.0 SP5 but I can't reproduce it on other
// NT 4.0 service pack revisions.
if (e.err == ERROR_INVALID_PARAMETER) {
- MsgBox(0, "Windows reported an error trying to secure the VNC Server settings for this user. "
+ MsgBox(nullptr, "Windows reported an error trying to secure the VNC Server settings for this user. "
"Your settings may not be secure!", MB_ICONWARNING | MB_OK);
} else if (e.err != ERROR_CALL_NOT_IMPLEMENTED &&
e.err != ERROR_NOT_LOGGED_ON) {
#ifdef _DEBUG
vlog.debug("capture dialogs=%s", captureDialogs ? "true" : "false");
- sheet.showPropSheet(0, true, false, captureDialogs);
+ sheet.showPropSheet(nullptr, true, false, captureDialogs);
#else
- sheet.showPropSheet(0, true, false);
+ sheet.showPropSheet(nullptr, true, false);
#endif
} catch (rdr::SystemException& e) {
switch (e.err) {
case ERROR_ACCESS_DENIED:
- MsgBox(0, "You do not have sufficient access rights to run the VNC Configuration applet",
+ MsgBox(nullptr, "You do not have sufficient access rights to run the VNC Configuration applet",
MB_ICONSTOP | MB_OK);
return 1;
};
}
} catch (rdr::Exception& e) {
- MsgBox(NULL, e.str(), MB_ICONEXCLAMATION | MB_OK);
+ MsgBox(nullptr, e.str(), MB_ICONEXCLAMATION | MB_OK);
return 1;
}
class AddNewClientDialog : public rfb::win32::Dialog {
public:
- AddNewClientDialog() : Dialog(GetModuleHandle(0)) {}
+ AddNewClientDialog() : Dialog(GetModuleHandle(nullptr)) {}
// - Show the dialog and return true if OK was clicked,
// false in case of error or Cancel
virtual bool showDialog() {
bool ControlPanel::showDialog()
{
- return Dialog::showDialog(MAKEINTRESOURCE(IDD_CONTROL_PANEL), NULL);
+ return Dialog::showDialog(MAKEINTRESOURCE(IDD_CONTROL_PANEL), nullptr);
}
void ControlPanel::initDialog()
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCANCEL:
- handle = NULL;
+ handle = nullptr;
EndDialog(hwnd, 0);
return TRUE;
default:
COPYDATASTRUCT copyData;
copyData.dwData = command;
copyData.cbData = 0;
- copyData.lpData = 0;
+ copyData.lpData = nullptr;
getSelConnInfo();
if (data != -1) {
ListConnStatus.Copy(&ListSelConn);
class ControlPanel : rfb::win32::Dialog, rfb::win32::ListViewControl {
public:
- ControlPanel(HWND hSTIcon) : Dialog(GetModuleHandle(0)), ListViewControl(){
+ ControlPanel(HWND hSTIcon) : Dialog(GetModuleHandle(nullptr)), ListViewControl(){
m_hSTIcon = hSTIcon;
stop_updating = false;
};
ManagedListener::ManagedListener(SocketManager* mgr)
-: filter(0), manager(mgr), addrChangeNotifier(0), server(0), port(0), localOnly(false) {
+: filter(nullptr), manager(mgr), addrChangeNotifier(nullptr), server(nullptr), port(0), localOnly(false) {
}
ManagedListener::~ManagedListener() {
if (localOnly)
network::createLocalTcpListeners(&sockets, port);
else
- network::createTcpListeners(&sockets, NULL, port);
+ network::createTcpListeners(&sockets, nullptr, port);
}
} catch (rdr::Exception& e) {
vlog.error("%s", e.str());
QueryConnectDialog::QueryConnectDialog(network::Socket* sock_,
const char* userName_,
VNCServerWin32* s)
-: Dialog(GetModuleHandle(0)),
+: Dialog(GetModuleHandle(nullptr)),
sock(sock_), peerIp(sock->getPeerAddress()), userName(userName_),
approve(false), server(s) {
}
// - Dialog overrides
void QueryConnectDialog::initDialog() {
- if (!SetTimer(handle, 1, 1000, 0))
+ if (!SetTimer(handle, 1, 1000, nullptr))
throw rdr::SystemException("SetTimer", GetLastError());
setItemString(IDC_QUERY_HOST, peerIp.c_str());
if (userName.empty())
SetWindowText(getHandle(), "winvnc::IPC_Interface");
// ***
- SetTimer(getHandle(), 1, 3000, 0);
+ SetTimer(getHandle(), 1, 3000, nullptr);
PostMessage(getHandle(), WM_TIMER, 1, 0);
PostMessage(getHandle(), WM_SET_TOOLTIP, 0, 0);
CPanel = new ControlPanel(getHandle());
SendMessage(getHandle(), WM_COMMAND, ID_CONTR0L_PANEL, 0);
break;
case WM_RBUTTONUP:
- HMENU menu = LoadMenu(GetModuleHandle(0), MAKEINTRESOURCE(thread.menu));
+ HMENU menu = LoadMenu(GetModuleHandle(nullptr), MAKEINTRESOURCE(thread.menu));
HMENU trayMenu = GetSubMenu(menu, 0);
// Display the menu
POINT pos;
GetCursorPos(&pos);
- TrackPopupMenu(trayMenu, 0, pos.x, pos.y, 0, getHandle(), 0);
+ TrackPopupMenu(trayMenu, 0, pos.x, pos.y, 0, getHandle(), nullptr);
break;
}
thread.server.disconnectClients("tray menu disconnect");
break;
case ID_CLOSE:
- if (MsgBox(0, "Are you sure you want to close the server?",
+ if (MsgBox(nullptr, "Are you sure you want to close the server?",
MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2) == IDYES) {
if (isServiceProcess()) {
try {
rfb::win32::stopService(VNCServerService::Name);
} catch (rdr::Exception& e) {
- MsgBox(0, e.str(), MB_ICONERROR | MB_OK);
+ MsgBox(nullptr, e.str(), MB_ICONERROR | MB_OK);
}
} else {
thread.server.stop();
STrayIconThread::STrayIconThread(VNCServerWin32& sm, UINT inactiveIcon_, UINT activeIcon_,
UINT dis_inactiveIcon_, UINT dis_activeIcon_, UINT menu_)
-: thread_id(-1), windowHandle(0), server(sm),
+: thread_id(-1), windowHandle(nullptr), server(sm),
inactiveIcon(inactiveIcon_), activeIcon(activeIcon_),
dis_inactiveIcon(dis_inactiveIcon_), dis_activeIcon(dis_activeIcon_),
menu(menu_), runTrayIcon(true) {
windowHandle = icon.getHandle();
MSG msg;
- while (runTrayIcon && ::GetMessage(&msg, 0, 0, 0) > 0) {
+ while (runTrayIcon && ::GetMessage(&msg, nullptr, 0, 0) > 0) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
- windowHandle = 0;
+ windowHandle = nullptr;
}
}
const char* winvnc::VNCServerService::Name = "TigerVNC";
// SendSAS is not available until Windows 7, and missing from MinGW
-static HMODULE sasLibrary = NULL;
+static HMODULE sasLibrary = nullptr;
typedef void WINAPI (*SendSAS_proto)(BOOL AsUser);
-static SendSAS_proto _SendSAS = NULL;
+static SendSAS_proto _SendSAS = nullptr;
VNCServerService::VNCServerService()
: Service(Name)
- , stopServiceEvent(CreateEvent(0, FALSE, FALSE, 0))
- , sessionEvent(CreateEvent(0, FALSE, FALSE, "Global\\SessionEventTigerVNC"))
- , sessionEventCad(CreateEvent(0, FALSE, FALSE, "Global\\SessionEventTigerVNCCad")) {
- if (sasLibrary == NULL) {
+ , stopServiceEvent(CreateEvent(nullptr, FALSE, FALSE, nullptr))
+ , sessionEvent(CreateEvent(nullptr, FALSE, FALSE, "Global\\SessionEventTigerVNC"))
+ , sessionEventCad(CreateEvent(nullptr, FALSE, FALSE, "Global\\SessionEventTigerVNCCad")) {
+ if (sasLibrary == nullptr) {
sasLibrary = LoadLibrary("sas.dll");
- if (sasLibrary != NULL)
+ if (sasLibrary != nullptr)
_SendSAS = (SendSAS_proto)(void*)GetProcAddress(sasLibrary, "SendSAS");
}
// - Set the service-mode logging defaults
// START the app as system
HANDLE LaunchProcessWin(DWORD /*dwSessionId*/)
{
- HANDLE hProcess = NULL;
- HANDLE hToken = NULL;
+ HANDLE hProcess = nullptr;
+ HANDLE hToken = nullptr;
if (GetSessionUserTokenWin(&hToken))
{
ModuleFileName filename;
si.cb = sizeof si;
si.dwFlags = STARTF_USESHOWWINDOW;
PROCESS_INFORMATION pi;
- if (CreateProcessAsUser(hToken, NULL, (char*)cmdLine.c_str(),
- NULL, NULL, FALSE, DETACHED_PROCESS,
- NULL, NULL, &si, &pi))
+ if (CreateProcessAsUser(hToken, nullptr, (char*)cmdLine.c_str(),
+ nullptr, nullptr, FALSE, DETACHED_PROCESS,
+ nullptr, nullptr, &si, &pi))
{
CloseHandle(pi.hThread);
hProcess = pi.hProcess;
{
ConsoleSessionId OlddwSessionId;
- HANDLE hProcess = NULL;
+ HANDLE hProcess = nullptr;
//We use this event to notify the program that the session has changed
//The program need to end so the service can restart the program in the correct session
//wait_for_existing_process();
//cad request
case WAIT_OBJECT_0 + 1:
- if (_SendSAS != NULL)
+ if (_SendSAS != nullptr)
_SendSAS(FALSE);
break;
SetEvent(sessionEvent);
}
DWORD dwExitCode = 0;
- if (hProcess == NULL ||
+ if (hProcess == nullptr ||
(GetExitCodeProcess(hProcess, &dwExitCode) &&
dwExitCode != STILL_ACTIVE &&
CloseHandle(hProcess)))
VNCServerWin32::VNCServerWin32()
: command(NoCommand),
- commandEvent(CreateEvent(0, TRUE, FALSE, 0)),
+ commandEvent(CreateEvent(nullptr, TRUE, FALSE, nullptr)),
sessionEvent(isServiceProcess() ?
- CreateEvent(0, FALSE, FALSE, "Global\\SessionEventTigerVNC") : 0),
+ CreateEvent(nullptr, FALSE, FALSE, "Global\\SessionEventTigerVNC") : nullptr),
vncServer(ComputerName().buf, &desktop),
thread_id(-1), runServer(false), isDesktopStarted(false),
- config(&sockMgr), rfbSock(&sockMgr), trayIcon(0),
- queryConnectDialog(0)
+ config(&sockMgr), rfbSock(&sockMgr), trayIcon(nullptr),
+ queryConnectDialog(nullptr)
{
commandLock = new os::Mutex;
commandSig = new os::Condition(commandLock);
delete trayIcon;
// Stop the SDisplay from updating our state
- desktop.setStatusLocation(0);
+ desktop.setStatusLocation(nullptr);
// Join the Accept/Reject dialog thread
if (queryConnectDialog) {
MSG msg;
int result = 0;
while (runServer) {
- result = sockMgr.getMessage(&msg, NULL, 0, 0);
+ result = sockMgr.getMessage(&msg, nullptr, 0, 0);
if (result < 0)
throw rdr::SystemException("getMessage", GetLastError());
if (!isServiceProcess() && (result == 0))
}
bool VNCServerWin32::addNewClient(const char* client) {
- TcpSocket* sock = 0;
+ TcpSocket* sock = nullptr;
try {
std::string hostname;
int port;
const char* userName)
{
if (queryOnlyIfLoggedOn && CurrentUserToken().noUserLoggedOn()) {
- vncServer.approveConnection(sock, true, NULL);
+ vncServer.approveConnection(sock, true, nullptr);
return;
}
if (queryConnectDialog) {
}
void VNCServerWin32::queryConnectionComplete() {
- queueCommand(QueryConnectionComplete, 0, 0, false);
+ queueCommand(QueryConnectionComplete, nullptr, 0, false);
}
"Connection rejected by user");
queryConnectDialog->wait();
delete queryConnectDialog;
- queryConnectDialog = 0;
+ queryConnectDialog = nullptr;
break;
default:
status = listConn->iGetStatus();
if (status == 3) {
- conn->close(0);
+ conn->close(nullptr);
} else {
rfb::AccessRights ar;
// Disconnect all connected clients
// THREAD-SAFE
- bool disconnectClients(const char* reason=0);
+ bool disconnectClients(const char* reason=nullptr);
// Call used to notify VNCServerST of user accept/reject query completion
// CALLED FROM AcceptConnectDialog THREAD
static void MsgBoxOrLog(const char* msg, bool isError=false) {
if (close_console) {
- MsgBox(0, msg, (isError ? MB_ICONERROR : MB_ICONINFORMATION) | MB_OK);
+ MsgBox(nullptr, msg, (isError ? MB_ICONERROR : MB_ICONINFORMATION) | MB_OK);
} else {
if (isError) {
try {
if (ancd.showDialog())
host = ancd.getHostName();
}
- if (host != NULL) {
- HWND hwnd = FindWindow(0, "winvnc::IPC_Interface");
+ if (host != nullptr) {
+ HWND hwnd = FindWindow(nullptr, "winvnc::IPC_Interface");
if (!hwnd)
throw rdr::Exception("Unable to locate existing VNC Server.");
COPYDATASTRUCT copyData;
}
} else if (strcasecmp(argv[i], "-disconnect") == 0) {
runServer = false;
- HWND hwnd = FindWindow(0, "winvnc::IPC_Interface");
+ HWND hwnd = FindWindow(nullptr, "winvnc::IPC_Interface");
if (!hwnd)
throw rdr::Exception("Unable to locate existing VNC Server.");
COPYDATASTRUCT copyData;
copyData.dwData = 2; // *** DisconnectClients
- copyData.lpData = 0;
+ copyData.lpData = nullptr;
copyData.cbData = 0;
printf("Sending disconnect request to VNC Server...\n");
if (!SendMessage(hwnd, WM_COPYDATA, 0, (LPARAM)©Data))
freopen("CONIN$", "rb", stdin);
freopen("CONOUT$", "wb", stdout);
freopen("CONOUT$", "wb", stderr);
- setbuf(stderr, 0);
+ setbuf(stderr, nullptr);
initStdIOLoggers();
initFileLogger("C:\\temp\\WinVNC4.log");
logParams.setParam("*:stderr:100");
// -=- DLL entry point
//
-HINSTANCE dll_instance = 0;
+HINSTANCE dll_instance = nullptr;
BOOL WINAPI DllMain(HANDLE instance, ULONG reason, LPVOID /*reserved*/) {
switch (reason) {
DWORD hook_owner SHARED = 0;
DWORD hook_target SHARED = 0;
-HHOOK hook_CallWndProc SHARED = 0;
-HHOOK hook_CallWndProcRet SHARED = 0;
-HHOOK hook_GetMessage SHARED = 0;
-HHOOK hook_DialogMessage SHARED = 0;
+HHOOK hook_CallWndProc SHARED = nullptr;
+HHOOK hook_CallWndProcRet SHARED = nullptr;
+HHOOK hook_GetMessage SHARED = nullptr;
+HHOOK hook_DialogMessage SHARED = nullptr;
BOOL enable_cursor_shape SHARED = FALSE;
-HCURSOR cursor SHARED = 0;
+HCURSOR cursor SHARED = nullptr;
#ifdef _DEBUG
UINT diagnostic_min SHARED =1;
UINT diagnostic_max SHARED =0;
if (buffsize != 0)
{
buff = (RGNDATA *) new BYTE [buffsize];
- if (buff == NULL)
+ if (buff == nullptr)
break;
// Now get the region data
}
// Now free the region
- if (region != NULL)
+ if (region != nullptr)
DeleteObject(region);
}
*/
if (owner != hook_owner) return FALSE;
if (hook_CallWndProc) {
UnhookWindowsHookEx(hook_CallWndProc);
- hook_CallWndProc = 0;
+ hook_CallWndProc = nullptr;
}
if (hook_CallWndProcRet) {
UnhookWindowsHookEx(hook_CallWndProcRet);
- hook_CallWndProcRet = 0;
+ hook_CallWndProcRet = nullptr;
}
if (hook_GetMessage) {
UnhookWindowsHookEx(hook_GetMessage);
- hook_GetMessage = 0;
+ hook_GetMessage = nullptr;
}
if (hook_DialogMessage) {
UnhookWindowsHookEx(hook_DialogMessage);
- hook_DialogMessage = 0;
+ hook_DialogMessage = nullptr;
}
hook_owner = 0;
hook_target = 0;
// -=- User input hooks
//
-HHOOK hook_keyboard SHARED = 0;
-HHOOK hook_pointer SHARED = 0;
+HHOOK hook_keyboard SHARED = nullptr;
+HHOOK hook_pointer SHARED = nullptr;
bool enable_real_ptr SHARED = true;
bool enable_synth_ptr SHARED = true;
bool enable_real_kbd SHARED = true;
bool set_kbd_hook = !enable_real_kbd || !enable_synth_kbd;
if (hook_keyboard && !set_kbd_hook) {
UnhookWindowsHookEx(hook_keyboard);
- hook_keyboard = 0;
+ hook_keyboard = nullptr;
}
if (hook_pointer && !set_ptr_hook) {
UnhookWindowsHookEx(hook_pointer);
- hook_pointer = 0;
+ hook_pointer = nullptr;
}
if (!hook_keyboard && set_kbd_hook) {
hook_keyboard = SetWindowsHookEx(WH_KEYBOARD_LL, HookKeyboardHook, dll_instance, 0);
projects / tigervnc.git / commitdiff