XPC Error: Underlying connection interrupted

Im using the low-level C xpc api <xpc/xpc.h> and i get this error when I run it: Underlying connection interrupted. I know this error stems from the call to xpc_session_send_message_with_reply_sync(session, message, &reply_err);. I have no previous experience with xpc or dispatch and I find the xpc docs very limited and I also found next to no code examples online. Can somebody take a look at my code and tell me what I did wrong and how to fix it? Thank you in advance.

Main code:

#include <stdio.h>
#include <xpc/xpc.h>
#include <dispatch/dispatch.h>

// the context passed to mainf()
struct context {
    char* text;
    xpc_session_t sess;
};

// This is for later implementation and the name is also rudimentary
void mainf(void* c) {
    //char * text = ((struct context*)c)->text;
    xpc_session_t session = ((struct context*)c)->sess;

    dispatch_queue_t messageq = dispatch_queue_create("y.ddd.main",
                                                     DISPATCH_QUEUE_SERIAL);

    xpc_object_t message = xpc_dictionary_create(NULL, NULL, 0);

    xpc_dictionary_set_string(message, "test", "eeeee");

    if (session == NULL) {
        printf("Session is NULL\n");
        exit(1);
    }
    __block xpc_rich_error_t reply_err = NULL;

    __block xpc_object_t reply;
    dispatch_sync(messageq, ^{
        reply = xpc_session_send_message_with_reply_sync(session,
                                                         message,
                                                         &reply_err);
        if (reply_err != NULL) printf("Reply Error: %s\n",
                                      xpc_rich_error_copy_description(reply_err));
    });


    if (reply != NULL)
    printf("Reply: %s\n", xpc_dictionary_get_string(reply, "test"));
    else printf("Reply is NULL\n");
}

int main(int argc, char* argv[]) {

    // Create seperate queue for mainf()
    dispatch_queue_t mainq = dispatch_queue_create("y.ddd.main",
                                                   DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t xpcq = dispatch_queue_create("y.ddd.xpc",
                                                   NULL);
    // Create the context being sent to mainf
    struct context* c = malloc(sizeof(struct context));

    c->text = malloc(sizeof("Hello"));
    strcpy(c->text, "Hello");

    xpc_rich_error_t sess_err = NULL;
    xpc_session_t session = xpc_session_create_xpc_service("y.getFilec",
                                             xpcq,
                                             XPC_SESSION_CREATE_INACTIVE,
                                                           &sess_err);

    if (sess_err != NULL) {
        printf("Session Create Error: %s\n",
               xpc_rich_error_copy_description(sess_err));
        xpc_release(sess_err);
        exit(1);
    }
    xpc_release(sess_err);

    xpc_session_set_incoming_message_handler(session, ^(xpc_object_t message) {
        printf("message recieved\n");
    });

    c->sess = session;

    xpc_rich_error_t sess_ac_err = NULL;
    xpc_session_activate(session, &sess_ac_err);
    if (sess_err != NULL) {
        printf("Session Activate Error: %s\n",
               xpc_rich_error_copy_description(sess_ac_err));
        xpc_release(sess_ac_err);
        exit(1);
    }
    xpc_release(sess_ac_err);

    xpc_retain(session);
    dispatch_async_f(mainq, (void*)c, mainf);

    xpc_release(session);

    dispatch_main();
}

XPC Service code:

#include <stdio.h>
#include <xpc/xpc.h>
#include <dispatch/dispatch.h>

int main(void) {

    xpc_rich_error_t lis_err = NULL;

    xpc_listener_t listener = xpc_listener_create("y.getFilec",
                                                  NULL,
                                                  XPC_LISTENER_CREATE_INACTIVE,
                                                  ^(xpc_session_t sess){
        printf("Incoming Session: %s\n", xpc_session_copy_description(sess));
                xpc_session_set_incoming_message_handler(sess,
 ^(xpc_object_t mess) {

            xpc_object_t repl = xpc_dictionary_create_empty();

            xpc_dictionary_set_string(repl, "test", "test");

            xpc_rich_error_t send_repl_err = xpc_session_send_message(sess, repl);

            if (send_repl_err != NULL) printf("Send Reply Error: %s\n",
                                              xpc_rich_error_copy_description(send_repl_err));

        });
        xpc_rich_error_t sess_ac_err = NULL;
        xpc_session_activate(sess, &sess_ac_err);
        if (sess_ac_err != NULL) printf("Session Activate: %s\n",
                                        xpc_rich_error_copy_description(sess_ac_err));

    },
 &lis_err);

    if (lis_err != NULL) {
        printf("Listener Error: %s\n", xpc_rich_error_copy_description(lis_err));
        xpc_release(lis_err);
    }

    xpc_rich_error_t lis_ac_err = NULL;
    xpc_listener_activate(listener, &lis_ac_err);

    if (lis_ac_err != NULL) {
        printf("Listener Activate Error: %s\n", xpc_rich_error_copy_description(lis_ac_err));
        xpc_release(lis_ac_err);
    }

    dispatch_main();

}