How to open named pipe when process is started using uri scheme - c

Question

I am developing a uri scheme registering library in C. I need to redirect the second call of the application to the first one so that only one is opened at a time. I decided to use windows named pipes for that. When I start the second instance like start testuri://example it works fine and the first instance receives the value testuri://example. However, when I start it like explorer testuri://example it fails to open the pipe to write.
This is my code for pipes (it is a wrapper for the winapi since I want the code to be cross platform and a Linux version also exists)
#include <windows.h>
#define READONLY GENERIC_READ
#define WRITEONLY GENERIC_WRITE
#define READWRITE GENERIC_WRITE | GENERIC_READ
#define CREATE_EXCLUSIVE CREATE_NEW
#define CREATE CREATE_ALWAYS
typedef struct file_desc {
char* name;
HANDLE hPipe;
int isReadPipe;
} file_desc;
void pipe_create(file_desc* pipe, const char* name) {
pipe->name = (char*) malloc(strlen(name) + 10);
memcpy(pipe->name, "\\\\.\\pipe\\", 10);
strcat(pipe->name, name);
pipe->hPipe = CreateNamedPipe(
TEXT(pipe->name),
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
1,
1024 * 16,
1024 * 16,
NMPWAIT_USE_DEFAULT_WAIT,
NULL
);
}
int pipe_open(file_desc* pipe, int mode) {
if (mode == READONLY) {
pipe->isReadPipe = TRUE;
return ConnectNamedPipe(pipe->hPipe, NULL);
} return file_open(pipe, pipe->name, mode, 1);
}
void pipe_close(file_desc* pipe) {
if (pipe->isReadPipe) {
DisconnectNamedPipe(pipe->hPipe);
} else file_close(pipe);
}
int file_open(file_desc* pipe, const char* name, int mode, int lock) {
if (!lock) pipe->hPipe = CreateFile(TEXT(name), mode, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, OPEN_ALWAYS, 0, NULL);
else pipe->hPipe = CreateFile(TEXT(name), mode, 0, NULL, OPEN_ALWAYS, 0, NULL);
return pipe->hPipe != INVALID_HANDLE_VALUE;
}
char* file_read(file_desc* pipe, char buf[], unsigned int size) {
DWORD dwRead;
ReadFile(pipe->hPipe, buf, size, &dwRead, NULL);
}
void file_write(file_desc* pipe, const char* str) {
DWORD dwWritten;
WriteFile(pipe->hPipe,str, strlen(str) + 1, &dwWritten, NULL);
}
void file_close(file_desc* pipe) {
CloseHandle(pipe->hPipe);
}
The way I create the pipes is something like this
file_desc* pipe;
pipe_create(pipe, "mypipe");
if (firstInstance) {
pipe_open(pipe, READONLY);
char buf[200];
file_read(pipe, buf, 200);
pipe_close(pipe);
} else {
pipe_open(pipe, WRITEONLY);
file_write(pipe, "test");
pipe_close(pipe);
}
Full code is at https://github.com/germaniuss/libschemehandler just create an obj folder and execute make in MinGW. Then run myapp.exe

Answer 1

I found a solution!
I tried looking at the error code at it returned error 5, access is denied. I found the problem. When opening the first instance I did that with elevated privileges, however, when opening an app using explorer testuri://example a new terminal window without elevated privileges pops up. This causes a problem since the pipe was created as administrator and is being accessed without.
I looked for info on this topic and found this forum exchange https://forums.codeguru.com/showthread.php?548311-RESOLVED-Writing-to-a-named-pipe-coming-from-a-service-(session-0)-without-admin-rights which was exactly what I needed. I just needed to create an all access security descriptor for the named pipe.
I feel like the fact that the pipe is created by default as with admin only access should be more clearly stated, since it says full access is granted by default
A pointer to a SECURITY_ATTRIBUTES structure that specifies a security
descriptor for the new named pipe and determines whether child
processes can inherit the returned handle. If lpSecurityAttributes is
NULL, the named pipe gets a default security descriptor and the handle
cannot be inherited. The ACLs in the default security descriptor for a
named pipe grant full control to the LocalSystem account,
administrators, and the creator owner. They also grant read access to
members of the Everyone group and the anonymous account.
Source MSDN
In the end my pipe_open functions ended up like so
void pipe_create(file_desc* pipe, const char* name) {
// all access secutrity descriptor
PSECURITY_DESCRIPTOR psd = NULL;
BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH];
psd = (PSECURITY_DESCRIPTOR)sd;
InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(psd, TRUE, (PACL)NULL, FALSE);
SECURITY_ATTRIBUTES sa = {sizeof(sa), psd, FALSE};
pipe->name = (char*) malloc(strlen(name) + 10);
memcpy(pipe->name, "\\\\.\\pipe\\", 10);
strcat(pipe->name, name);
pipe->hPipe = CreateNamedPipe(
TEXT(pipe->name),
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
1,
1024 * 16,
1024 * 16,
NMPWAIT_USE_DEFAULT_WAIT,
&sa
);
}