ex/ios/Example.m

/*
 *  Copyright 2014-2024 Solace Corporation. All rights reserved.
 */

#import "Example.h"

@implementation Example

@synthesize name;
@synthesize description;
@synthesize parameters;
@synthesize nullBridge_p;

- (id)initWithExampleInterface:(ExampleInterface *)exampleInterface {
    self = [super init];

    self.parameters = [[ParameterInterface alloc] init];

    self.exampleInterface = exampleInterface;

    self.nullBridge_p = malloc(sizeof(callbackBridge_t));
    self.nullBridge_p->example_p = (__bridge void *)self;
    self.nullBridge_p->user_p = NULL;

    // Set up flags
    self.running = NO;

    self.requestRun = NO;
    [self addObserver:self forKeyPath:@"requestRun" options:0 context:NULL];

    self.requestCancel = NO;
    [self addObserver:self forKeyPath:@"requestCancel" options:0 context:NULL];

    return self;
}

- (void)start {
    // Inform the UI that the example is now running
    self.running = YES;

    // Inform the example interface that this example is currently running
    self.exampleInterface.runningExample = self;

    // Run the example in a separate thread, to allow the UI to update
    // immediately after receiving a log callback
    [self performSelectorInBackground:@selector(run) withObject:nil];
}

- (void)run {
    solClient_returnCode_t rc;
    if ((rc = solClient_log_setCallback(logCallback, nullBridge_p) !=
              SOLCLIENT_OK)) {
        [self handleErrorWithReturnCode:rc
                            errorString:"solClient_log_setCallback()"];
    }
}

- (void)cancel {
    // Inform the example that cancellation is requested
    self.requestCancel = YES;
    
    // Force a cleanup, to ensure that example stops more or less immediately
    solClient_cleanup();
}

- (void)cleanup {
    [self printToTextView:@"Example complete."];

    // Inform the UI that the example has been cancelled
    self.requestCancel = NO;
    self.running = NO;

    // Inform the example interface that no example is currently running
    self.exampleInterface.runningExample = nil;
}

- (void)printToTextView:(NSString *)str {
    // Send a notification to the UI to print to text view
    [[NSNotificationCenter defaultCenter]
        postNotificationName:@"output"
                      object:self
                    userInfo:[NSDictionary
                                 dictionaryWithObjectsAndKeys:str, @"string",
                                                              nil]];
}

- (void)logCCSMPVersion {
    solClient_version_info_pt version_p;

    if (solClient_version_get(&version_p) != SOLCLIENT_OK) {
        solClient_log(
            SOLCLIENT_LOG_WARNING,
            "Unknown library version, solClient_version_get returns FAIL\n");
    } else {
        solClient_log(SOLCLIENT_LOG_NOTICE, "CCSMP Version %s (%s)",
                      version_p->version_p, version_p->dateTime_p);
        solClient_log(SOLCLIENT_LOG_NOTICE, "CCSMP Variant: %s\n",
                      version_p->variant_p);
    }
}

- (void)setLoggingLevel {
    // Standard logging levels can be set independently for the API and the
    // application. In this case, the ALL category is used to set the log level
    // for both at the same time.

    if ([[self.parameters parameterWithId:PARAMETER_LOGGING_LEVEL].value
            isEqualToString:@"critical"]) {
        solClient_log_setFilterLevel(SOLCLIENT_LOG_CATEGORY_ALL,
                                     SOLCLIENT_LOG_CRITICAL);
        return;
    } else if ([[self.parameters parameterWithId:PARAMETER_LOGGING_LEVEL].value
                   isEqualToString:@"error"]) {
        solClient_log_setFilterLevel(SOLCLIENT_LOG_CATEGORY_ALL,
                                     SOLCLIENT_LOG_ERROR);
        return;
    } else if ([[self.parameters parameterWithId:PARAMETER_LOGGING_LEVEL].value
                   isEqualToString:@"warning"]) {
        solClient_log_setFilterLevel(SOLCLIENT_LOG_CATEGORY_ALL,
                                     SOLCLIENT_LOG_WARNING);
        return;
    } else if ([[self.parameters parameterWithId:PARAMETER_LOGGING_LEVEL].value
                   isEqualToString:@"notice"]) {
        solClient_log_setFilterLevel(SOLCLIENT_LOG_CATEGORY_ALL,
                                     SOLCLIENT_LOG_NOTICE);
        return;
    } else if ([[self.parameters parameterWithId:PARAMETER_LOGGING_LEVEL].value
                   isEqualToString:@"info"]) {
        solClient_log_setFilterLevel(SOLCLIENT_LOG_CATEGORY_ALL,
                                     SOLCLIENT_LOG_INFO);
        return;
    } else if ([[self.parameters parameterWithId:PARAMETER_LOGGING_LEVEL].value
                   isEqualToString:@"debug"]) {
        solClient_log_setFilterLevel(SOLCLIENT_LOG_CATEGORY_ALL,
                                     SOLCLIENT_LOG_DEBUG);
        return;
    }
}

- (void)handleErrorWithReturnCode:(solClient_returnCode_t)rc
                      errorString:(const char *)errorStr {
    solClient_errorInfo_pt errorInfo = solClient_getLastErrorInfo();
    solClient_log(
        SOLCLIENT_LOG_ERROR,
        "%s - ReturnCode=\"%s\", SubCode=\"%s\", ResponseCode=%d, Info=\"%s\"",
        errorStr, solClient_returnCodeToString(rc),
        solClient_subCodeToString(errorInfo->subCode), errorInfo->responseCode,
        errorInfo->errorStr);
    solClient_resetLastErrorInfo();
}

- (solClient_returnCode_t)
    createAndConnectSessionWithContext:(solClient_opaqueContext_pt)context_p
                               session:(solClient_opaqueSession_pt *)session_p
                       messageCallback:
                           (solClient_session_rxMsgCallbackFunc_t)msgCallback_p
                         eventCallback:(solClient_session_eventCallbackFunc_t)
                         eventCallback_p {
    return [self createAndConnectSessionWithContext:context_p
                                            session:session_p
                                    messageCallback:msgCallback_p
                                      eventCallback:eventCallback_p
                                           userData:self.nullBridge_p];
}

- (solClient_returnCode_t)
    createAndConnectSessionWithContext:(solClient_opaqueContext_pt)context_p
                               session:(solClient_opaqueSession_pt *)session_p
                       messageCallback:
                           (solClient_session_rxMsgCallbackFunc_t)msgCallback_p
                         eventCallback:(solClient_session_eventCallbackFunc_t)
                         eventCallback_p
                              userData:(callbackBridge_t *)user_p {
    // Return code
    solClient_returnCode_t rc = SOLCLIENT_OK;

    // Session Function Info
    solClient_session_createFuncInfo_t sessionFuncInfo =
        SOLCLIENT_SESSION_CREATEFUNC_INITIALIZER;

    // Session properties
    const char *sessionProps[50];
    int propIndex = 0;

    sessionFuncInfo.rxMsgInfo.callback_p = msgCallback_p;
    sessionFuncInfo.rxMsgInfo.user_p = user_p;
    sessionFuncInfo.eventInfo.callback_p = eventCallback_p;
    sessionFuncInfo.eventInfo.user_p = user_p;

    propIndex = 0;

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_HOST;
    sessionProps[propIndex++] =
        [[self.parameters parameterWithId:PARAMETER_HOST].value
            cStringUsingEncoding:NSASCIIStringEncoding];

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_COMPRESSION_LEVEL;
    sessionProps[propIndex++] =
        [self.parameters parameterWithId:PARAMETER_COMPRESSION].value.boolValue
            ? "9"
            : "0";

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_CONNECT_RETRIES;
    sessionProps[propIndex++] = "3";

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_RECONNECT_RETRIES;
    sessionProps[propIndex++] = "3";

    // Note: Reapplying subscriptions allows Sessions to reconnect after failure
    // and have all their subscriptions automatically restored. For Sessions
    // with many subscriptions, this can increase the amount of time required
    // for a successful reconnect.

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_REAPPLY_SUBSCRIPTIONS;
    sessionProps[propIndex++] = SOLCLIENT_PROP_ENABLE_VAL;

    // Note: Including meta data fields such as sender timestamp, sender ID, and
    // sequence number can reduce the maximum attainable throughput as
    // significant extra encoding/decoding is required. This is true whether the
    // fields are autogenerated or manually added.
    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_GENERATE_SEND_TIMESTAMPS;
    sessionProps[propIndex++] = SOLCLIENT_PROP_ENABLE_VAL;

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_GENERATE_SENDER_ID;
    sessionProps[propIndex++] = SOLCLIENT_PROP_ENABLE_VAL;

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_GENERATE_SEQUENCE_NUMBER;
    sessionProps[propIndex++] = SOLCLIENT_PROP_ENABLE_VAL;

    if (![[self.parameters parameterWithId:PARAMETER_HOST].value
            isEqualToString:@""]) {
        sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_VPN_NAME;
        sessionProps[propIndex++] =
            [[self.parameters parameterWithId:PARAMETER_VPN].value
                cStringUsingEncoding:NSASCIIStringEncoding];
    }

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_SSL_VALIDATE_CERTIFICATE;
    sessionProps[propIndex++] = SOLCLIENT_PROP_DISABLE_VAL;

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_USERNAME;
    sessionProps[propIndex++] =
        [[self.parameters parameterWithId:PARAMETER_USERNAME].value
            cStringUsingEncoding:NSASCIIStringEncoding];

    sessionProps[propIndex++] = SOLCLIENT_SESSION_PROP_PASSWORD;
    sessionProps[propIndex++] =
        [[self.parameters parameterWithId:PARAMETER_PASSWORD].value
            cStringUsingEncoding:NSASCIIStringEncoding];

    sessionProps[propIndex] = NULL;

    if ((rc = solClient_session_create(
             (char **)sessionProps, context_p, session_p, &sessionFuncInfo,
             sizeof(sessionFuncInfo))) != SOLCLIENT_OK) {
        [self handleErrorWithReturnCode:rc
                            errorString:"solClient_session_create()"];
        return rc;
    }

    if ((rc = solClient_session_connect(*session_p)) != SOLCLIENT_OK) {
        [self handleErrorWithReturnCode:rc
                            errorString:"solClient_session_connect()"];
        return rc;
    }

    return SOLCLIENT_OK;
}

- (solClient_returnCode_t)
    publishMessageWithSession:(solClient_opaqueSession_pt)session_p
                        topic:(char *)topic_p
                 deliveryMode:(solClient_uint32_t)deliveryMode {
    // Return code
    solClient_returnCode_t rc = SOLCLIENT_OK;
    solClient_returnCode_t rcFreeMsg = SOLCLIENT_OK;
    solClient_opaqueMsg_pt msg_p = NULL;
    solClient_destination_t destination;

    solClient_log(SOLCLIENT_LOG_DEBUG,
                  "publishMessageWithSession:topic:deliveryMode called.\n");

    // Allocate memory for the message to be sent.
    if ((rc = solClient_msg_alloc(&msg_p)) != SOLCLIENT_OK) {
        [self handleErrorWithReturnCode:rc errorString:"solClient_msg_alloc()"];
        return rc;
    }

    // Set the message delivery mode
    if ((rc = solClient_msg_setDeliveryMode(msg_p, deliveryMode)) !=
        SOLCLIENT_OK) {
        [self handleErrorWithReturnCode:rc
                            errorString:"solClient_msg_setDeliveryMode()"];
        goto freeMessage;
    }

    // Set the destination
    destination.destType = SOLCLIENT_TOPIC_DESTINATION;
    destination.dest = topic_p;
    if ((rc = solClient_msg_setDestination(
             msg_p, &destination, sizeof(destination))) != SOLCLIENT_OK) {
        [self handleErrorWithReturnCode:rc
                            errorString:"solClient_msg_setDestination()"];
        goto freeMessage;
    }

    // Send the message
    if ((rc = solClient_session_sendMsg(session_p, msg_p)) != SOLCLIENT_OK) {
        [self handleErrorWithReturnCode:rc
                            errorString:"solClient_session_sendMsg()"];
        goto freeMessage;
    }

freeMessage:
    if ((rcFreeMsg = solClient_msg_free(&msg_p)) != SOLCLIENT_OK) {
        [self handleErrorWithReturnCode:rcFreeMsg
                            errorString:"solClient_msg_free()"];
    }

    return rc;
}

- (pthread_t)startThreadWithFP:(FP)fp argument:(void *)arg {
    pthread_t th = _NULL_THREAD_ID;

    if (pthread_create(&th, NULL, fp, arg)) {
    }
    if (th == _NULL_THREAD_ID) {
        return _NULL_THREAD_ID;
    } else {
        return th;
    }
}

- (void)waitOnThread:(pthread_t)handle {
    void *value_p;
    pthread_join(handle, &value_p);
}

threadRetType contextThread(void *user_p) {
    // The use of autoreleasepools in CCSMP callbacks is necessary to avoid
    // memory leaks, to ensure that ARC works properly when in C scope (i.e.
    // outside of Objective-C scope)
    @autoreleasepool {
        callbackBridge_t *bridge = (callbackBridge_t *)user_p;
        Example *example = (__bridge Example *)bridge->example_p;
        contextThreadInfo_t *contextInfo_p =
            (contextThreadInfo_t *)bridge->user_p;

        free(bridge);

        return [example contextThread:contextInfo_p];
    }
}

- (threadRetType)contextThread:(void *)contextInfo_p {
    solClient_returnCode_t rc = SOLCLIENT_OK;
    contextThreadInfo_t *info_p = (contextThreadInfo_t *)contextInfo_p;

    solClient_log(SOLCLIENT_LOG_DEBUG, "Context thread initialized");
    info_p->rc = 0;
    // Loop until common_stopContextThread has been set to 1.
    while (!info_p->stopContextThread) {
        if ((rc = solClient_context_processEvents(info_p->context_p)) !=
            SOLCLIENT_OK) {
            [self handleErrorWithReturnCode:rc
                                errorString:"solClient_context_processEvents"];
            break;
        }
    }
    return NULL;
}

- (int)startContextThread:(contextThreadInfo_t *)info_p {
    int rc = 1;

    solClient_log(SOLCLIENT_LOG_DEBUG, "Starting Context thread");
    info_p->stopContextThread = 0;

    callbackBridge_t *bridge = malloc(sizeof(callbackBridge_t));
    bridge->user_p = info_p;
    bridge->example_p = (__bridge void *)self;

    // Create the thread.
    if (pthread_create(&(info_p->handle), NULL, contextThread, (void *)bridge) <
        0) {
        solClient_log(SOLCLIENT_LOG_ERROR, "Could not create context thread");
        rc = 0;
    } else {
        info_p->contextThreadStarted = 1;
    }
    return rc;
}

- (void)stopContextThread:(contextThreadInfo_t *)info_p {
    solClient_log(SOLCLIENT_LOG_DEBUG, "Stopping Context thread");
    info_p->stopContextThread = 1;

    void *value_p;
    pthread_join(info_p->handle, &value_p);
}

- (UInt64)getTimeInUs {
    struct timespec tv;

    // timespec uses long; mach timespec uses unsigned int
    mach_timespec_t mtv;
    clock_serv_t cclock;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mtv);
    mach_port_deallocate(mach_task_self(), cclock);

    tv.tv_sec = mtv.tv_sec;
    tv.tv_nsec = mtv.tv_nsec;

    return ((UInt64)tv.tv_sec * (UInt64)1000000) +
           ((UInt64)tv.tv_nsec / (UInt64)1000);
}

- (void)getUsageTimeWithUserTime:(long long *)userTime_p
                      systemTime:(long long *)systemTime_p {
    struct rusage usage;

    getrusage(RUSAGE_SELF, &usage);
    *userTime_p = (long long)usage.ru_utime.tv_sec * (long long)1000000 +
                  (long long)usage.ru_utime.tv_usec;
    *systemTime_p = (long long)usage.ru_stime.tv_sec * (long long)1000000 +
                    (long long)usage.ru_stime.tv_usec;
}

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context {
    // Run an example when requested by the UI
    if ([keyPath isEqualToString:@"requestRun"]) {
        if (self.requestRun) {
            self.requestRun = NO;
            [self start];
        }
    }
    // Ignore cancellation requests when the example is not running
    else if ([keyPath isEqualToString:@"requestCancel"]) {
        if (self.requestCancel && !self.running) {
            self.requestCancel = NO;
        }
    }
}

void eventCallback(solClient_opaqueSession_pt opaqueSession_p,
                   solClient_session_eventCallbackInfo_pt eventInfo_p,
                   void *user_p) {
    // The use of autoreleasepools in CCSMP callbacks is necessary to avoid
    // memory leaks, to ensure that ARC works properly when in C scope (i.e.
    // outside of Objective-C scope)
    @autoreleasepool {
        callbackBridge_t *bridge = (callbackBridge_t *)user_p;
        id<EventCallbackProtocol> callbackProtocol =
            (__bridge id<EventCallbackProtocol>)bridge->example_p;
        [callbackProtocol eventCallbackWithSession:opaqueSession_p
                                         eventInfo:eventInfo_p
                                          userData:bridge->user_p];
    }
}

- (void)eventCallbackWithSession:(solClient_opaqueSession_pt)opaqueSession_p
                       eventInfo:
                           (solClient_session_eventCallbackInfo_pt)eventInfo_p
                        userData:(void *)user_p {
    solClient_errorInfo_pt errorInfo_p;

    switch (eventInfo_p->sessionEvent) {
    case SOLCLIENT_SESSION_EVENT_UP_NOTICE:
    case SOLCLIENT_SESSION_EVENT_ACKNOWLEDGEMENT:
    case SOLCLIENT_SESSION_EVENT_TE_UNSUBSCRIBE_OK:
    case SOLCLIENT_SESSION_EVENT_CAN_SEND:
    case SOLCLIENT_SESSION_EVENT_RECONNECTING_NOTICE:
    case SOLCLIENT_SESSION_EVENT_RECONNECTED_NOTICE:
    case SOLCLIENT_SESSION_EVENT_PROVISION_OK:
    case SOLCLIENT_SESSION_EVENT_SUBSCRIPTION_OK:

        // Non-error events are logged at the INFO level
        solClient_log(
            SOLCLIENT_LOG_INFO,
            "eventCallbackWithSession:eventInfo: called - %s\n",
            solClient_session_eventToString(eventInfo_p->sessionEvent));
        break;

    case SOLCLIENT_SESSION_EVENT_DOWN_ERROR:
    case SOLCLIENT_SESSION_EVENT_CONNECT_FAILED_ERROR:
    case SOLCLIENT_SESSION_EVENT_REJECTED_MSG_ERROR:
    case SOLCLIENT_SESSION_EVENT_SUBSCRIPTION_ERROR:
    case SOLCLIENT_SESSION_EVENT_RX_MSG_TOO_BIG_ERROR:
    case SOLCLIENT_SESSION_EVENT_TE_UNSUBSCRIBE_ERROR:
    case SOLCLIENT_SESSION_EVENT_PROVISION_ERROR:

        // Extra error information is available on error events
        errorInfo_p = solClient_getLastErrorInfo();
        // Error events are logged at the ERROR level
        solClient_log(
            SOLCLIENT_LOG_ERROR, "eventCallbackWithSession:eventInfo: called - "
                                 "%s; subCode %s, responseCode %d, "
                                 "reason %s\n",
            solClient_session_eventToString(eventInfo_p->sessionEvent),
            solClient_subCodeToString(errorInfo_p->subCode),
            errorInfo_p->responseCode, errorInfo_p->errorStr);
        break;

    default:
        // Unrecognized or deprecated events are logged at the NOTICE level.
        solClient_log(
            SOLCLIENT_LOG_NOTICE, "eventCallbackWithSession:eventInfo: called "
                                  "- %s.  Unrecognized or deprecated "
                                  "event.\n",
            solClient_session_eventToString(eventInfo_p->sessionEvent));
        break;
    }
}

void cacheEventCallback(solClient_opaqueSession_pt opaqueSession_p,
                        solCache_eventCallbackInfo_pt eventInfo_p,
                        void *user_p) {
    // The use of autoreleasepools in CCSMP callbacks is necessary to avoid
    // memory leaks, to ensure that ARC works properly when in C scope (i.e.
    // outside of Objective-C scope)
    @autoreleasepool {
        callbackBridge_t *bridge = (callbackBridge_t *)user_p;
        id<EventCallbackProtocol> callbackProtocol =
            (__bridge id<EventCallbackProtocol>)bridge->example_p;
        [callbackProtocol cacheEventCallbackWithSession:opaqueSession_p
                                              eventInfo:eventInfo_p
                                               userData:bridge->user_p];
    }
}

- (void)cacheEventCallbackWithSession:
            (solClient_opaqueSession_pt)opaqueSession_p
                            eventInfo:(solCache_eventCallbackInfo_pt)eventInfo_p
                             userData:(void *)user_p {
    solClient_log(SOLCLIENT_LOG_NOTICE,
                  "cacheEventCallbackWithSession:eventInfo called - %s\n"
                  "topic: %s\n"
                  "responseCode: (%d) %s\n"
                  "subCode: (%d) %s\n"
                  "cacheRequestId: %llu\n\n",
                  solClient_cacheSession_eventToString(eventInfo_p->cacheEvent),
                  eventInfo_p->topic, eventInfo_p->rc,
                  solClient_returnCodeToString(eventInfo_p->rc),
                  eventInfo_p->subCode,
                  solClient_subCodeToString(eventInfo_p->subCode),
                  eventInfo_p->cacheRequestId);
}

void eventPerfCallback(solClient_opaqueSession_pt opaqueSession_p,
                       solClient_session_eventCallbackInfo_pt eventInfo_p,
                       void *user_p) {
    // The use of autoreleasepools in CCSMP callbacks is necessary to avoid
    // memory leaks, to ensure that ARC works properly when in C scope (i.e.
    // outside of Objective-C scope)
    @autoreleasepool {
        callbackBridge_t *bridge = (callbackBridge_t *)user_p;
        id<EventCallbackProtocol> callbackProtocol =
            (__bridge id<EventCallbackProtocol>)bridge->example_p;
        [callbackProtocol eventPerfCallbackWithSession:opaqueSession_p
                                             eventInfo:eventInfo_p
                                              userData:bridge->user_p];
    }
}

- (void)eventPerfCallbackWithSession:(solClient_opaqueSession_pt)opaqueSession_p
                           eventInfo:(solClient_session_eventCallbackInfo_pt)
                           eventInfo_p
                            userData:(void *)user_p {
}

void logCallback(solClient_log_callbackInfo_pt logInfo_p, void *user_p) {
    // The use of autoreleasepools in CCSMP callbacks is necessary to avoid
    // memory leaks, to ensure that ARC works properly when in C scope (i.e.
    // outside of Objective-C scope)
    @autoreleasepool {
        callbackBridge_t *bridge = (callbackBridge_t *)user_p;
        id<LogCallbackProtocol> callbackProtocol =
            (__bridge id<LogCallbackProtocol>)bridge->example_p;
        [callbackProtocol logCallbackWithLogInfo:logInfo_p
                                        userData:bridge->user_p];
    }
}

- (void)logCallbackWithLogInfo:(solClient_log_callbackInfo_pt)logInfo_p
                      userData:(void *)user_p {
    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
    [formatter setDateFormat:@"hh:mm:ss"];

    NSString *str = [NSString
        stringWithFormat:@"%s %s %@ : %s",
                         solClient_log_categoryToString(logInfo_p->category),
                         solClient_log_levelToString(logInfo_p->level),
                         [formatter stringFromDate:[NSDate date]],
                         logInfo_p->msg_p];

    [self printToTextView:str];
}

solClient_rxMsgCallback_returnCode_t
messageReceiveCallback(solClient_opaqueSession_pt opaqueSession_p,
                       solClient_opaqueMsg_pt msg_p, void *user_p) {
    // The use of autoreleasepools in CCSMP callbacks is necessary to avoid
    // memory leaks, to ensure that ARC works properly when in C scope (i.e.
    // outside of Objective-C scope)
    @autoreleasepool {
        callbackBridge_t *bridge = (callbackBridge_t *)user_p;
        id<MessageReceiveCallbackProtocol> callbackProtocol =
            (__bridge id<MessageReceiveCallbackProtocol>)bridge->example_p;
        return
            [callbackProtocol messageReceiveCallbackWithSession:opaqueSession_p
                                                        message:msg_p
                                                       userData:bridge->user_p];
    }
}

- (solClient_rxMsgCallback_returnCode_t)
    messageReceiveCallbackWithSession:
        (solClient_opaqueSession_pt)opaqueSession_p
                              message:(solClient_opaqueMsg_pt)msg_p
                             userData:(void *)user_p {
    solClient_returnCode_t rc = SOLCLIENT_OK;

    solClient_int64_t rxSeqNum;
    const char *senderId_p;

    /*
     * Get the message sequence number and sender ID. Check to see if the
     * fields exist, and use a default value if the field is not found.
     */

    if ((rc = solClient_msg_getSequenceNumber(msg_p, &rxSeqNum)) !=
        SOLCLIENT_OK) {
        if (rc == SOLCLIENT_NOT_FOUND) {
            rxSeqNum = 0;
        } else {
            [self
                handleErrorWithReturnCode:rc
                              errorString:"solClient_msg_getSequenceNumber()"];
            return SOLCLIENT_CALLBACK_OK;
        }
    }

    if ((rc = solClient_msg_getSenderId(msg_p, &senderId_p)) != SOLCLIENT_OK) {
        if (rc == SOLCLIENT_NOT_FOUND) {
            senderId_p = "";
        } else {
            [self handleErrorWithReturnCode:rc
                                errorString:"solClient_msg_getSenderId()"];
            return SOLCLIENT_CALLBACK_OK;
        }
    }

    if (user_p != NULL) {
        solClient_log(SOLCLIENT_LOG_NOTICE,
                      "%s received message from '%s' (seq# %llu)\n",
                      (char *)user_p, senderId_p, rxSeqNum);
    } else {
        solClient_log(SOLCLIENT_LOG_NOTICE,
                      "Received message from '%s' (seq# %llu)\n", senderId_p,
                      rxSeqNum);
    }

    /*
     * Returning SOLCLIENT_CALLBACK_OK causes the API to free the memory
     * used by the message. This is important to avoid leaks.
     */
    return SOLCLIENT_CALLBACK_OK;
}

solClient_rxMsgCallback_returnCode_t
messageReceivePrintMsgCallback(solClient_opaqueSession_pt opaqueSession_p,
                               solClient_opaqueMsg_pt msg_p, void *user_p) {
    // The use of autoreleasepools in CCSMP callbacks is necessary to avoid
    // memory leaks, to ensure that ARC works properly when in C scope (i.e.
    // outside of Objective-C scope)
    @autoreleasepool {
        callbackBridge_t *bridge = (callbackBridge_t *)user_p;
        id<MessageReceiveCallbackProtocol> callbackProtocol =
            (__bridge id<MessageReceiveCallbackProtocol>)bridge->example_p;
        return [callbackProtocol
            messageReceivePrintMsgCallbackWithSession:opaqueSession_p
                                              message:msg_p
                                             userData:bridge->user_p];
    }
}

- (solClient_rxMsgCallback_returnCode_t)
    messageReceivePrintMsgCallbackWithSession:
        (solClient_opaqueSession_pt)opaqueSession_p
                                      message:(solClient_opaqueMsg_pt)msg_p
                                     userData:(void *)user_p {
    solClient_returnCode_t rc = SOLCLIENT_OK;

    if (user_p != NULL) {
        solClient_log(SOLCLIENT_LOG_NOTICE, "%s received message:\n",
                      (char *)user_p);

    } else {
        solClient_log(SOLCLIENT_LOG_NOTICE, "Received message:\n");
    }

    char buffer[5000];
    if ((rc = solClient_msg_dump(msg_p, buffer, 5000)) != SOLCLIENT_OK) {
        [self handleErrorWithReturnCode:rc errorString:"solClient_msg_dump()"];
        return SOLCLIENT_CALLBACK_OK;
    }
    solClient_log(SOLCLIENT_LOG_NOTICE, buffer);

    /*
     * Returning SOLCLIENT_CALLBACK_OK causes the API to free the memory
     * used by the message. This is important to avoid leaks.
     */
    return SOLCLIENT_CALLBACK_OK;
}

solClient_rxMsgCallback_returnCode_t
messageReceivePerfCallback(solClient_opaqueSession_pt opaqueSession_p,
                           solClient_opaqueMsg_pt msg_p, void *user_p) {
    // The use of autoreleasepools in CCSMP callbacks is necessary to avoid
    // memory leaks, to ensure that ARC works properly when in C scope (i.e.
    // outside of Objective-C scope)
    @autoreleasepool {
        callbackBridge_t *bridge = (callbackBridge_t *)user_p;
        id<MessageReceiveCallbackProtocol> callbackProtocol =
            (__bridge id<MessageReceiveCallbackProtocol>)bridge->example_p;
        return [callbackProtocol
            messageReceivePerfCallbackWithSession:opaqueSession_p
                                          message:msg_p
                                         userData:bridge->user_p];
    }
}

- (solClient_rxMsgCallback_returnCode_t)
    messageReceivePerfCallbackWithSession:
        (solClient_opaqueSession_pt)opaqueSession_p
                                  message:(solClient_opaqueMsg_pt)msg_p
                                 userData:(void *)user_p {
    /*
     * Returning SOLCLIENT_CALLBACK_OK causes the API to free the memory
     * used by the message. This is important to avoid leaks.
     */
    return SOLCLIENT_CALLBACK_OK;
}

@end