static void MAMACALLTYPE dqPublisherImplMsgCb (mamaSubscription subsc, mamaMsg msg, void* closure, void* itemClosure) { mama_i32_t msgType = 0; mama_i32_t subType = 0; const char* symbol = NULL; mama_status status = MAMA_STATUS_NOT_FOUND; mamaPublishTopic* info = NULL; mamaDQPublisherManagerImpl* impl = (mamaDQPublisherManagerImpl*) (closure); if (mamaMsg_getI32 (msg, MamaFieldSubscriptionType.mName, MamaFieldSubscriptionType.mFid, &subType) == MAMA_STATUS_OK) { if (mamaMsg_getString (msg, MamaFieldSubscSymbol.mName, MamaFieldSubscSymbol.mFid, &symbol) != MAMA_STATUS_OK) { if (mamaMsg_getSendSubject (msg, &symbol) != MAMA_STATUS_OK) { impl->mUserCallbacks.onError ((mamaDQPublisherManager)impl, status, "No symbol", msg); return; } } if (mamaMsg_getI32 (msg, MamaFieldSubscMsgType.mName, MamaFieldSubscMsgType.mFid, &msgType) != MAMA_STATUS_OK) { impl->mUserCallbacks.onError ((mamaDQPublisherManager)impl, status, "NO msg type", msg); return; } if ((info = wtable_lookup (impl->mPublisherMap, (symbol)))) { switch (msgType) { case MAMA_SUBSC_REFRESH: if (!impl->mRefreshResponseMsg) { mamaMsg_create(&impl->mRefreshResponseMsg); mamaMsg_addU8(impl->mRefreshResponseMsg, NULL, MamaFieldMsgStatus.mFid, MAMA_MSG_STATUS_MISC); mamaMsg_addU8(impl->mRefreshResponseMsg, NULL, MamaFieldMsgType.mFid, MAMA_MSG_TYPE_REFRESH); } mamaDQPublisher_send(info->pub, impl->mRefreshResponseMsg); impl->mUserCallbacks.onRefresh((mamaDQPublisherManager)impl, info, subType, msgType, msg ); break; default: impl->mUserCallbacks.onRequest ((mamaDQPublisherManager)impl, info, subType, msgType, msg); break; } } else { impl->mUserCallbacks.onNewRequest ((mamaDQPublisherManager)impl, symbol, subType, msgType, msg); } } else { if (impl->mUserCallbacks.onMsg) impl->mUserCallbacks.onMsg ((mamaDQPublisherManager)impl, msg); } }
mama_status msgUtils_createEndOfInitialsMsg (mamaMsg *msg) { mamaMsg_create (msg); mamaMsg_addU8 (*msg, MamaFieldMsgType.mName, MamaFieldMsgType.mFid, MAMA_MSG_TYPE_END_OF_INITIALS); mamaMsg_addI32 (*msg, MamaFieldMsgStatus.mName, MamaFieldMsgStatus.mFid, MAMA_MSG_STATUS_OK); return MAMA_STATUS_OK; }
mama_status msgUtils_createTimeoutMsg (mamaMsg *msg) { mamaMsg_create (msg); mamaMsg_addU8 (*msg, MamaFieldMsgType.mName, MamaFieldMsgType.mFid, MAMA_MSG_TYPE_INITIAL); mamaMsg_addI32 (*msg, MamaFieldMsgStatus.mName, MamaFieldMsgStatus.mFid, MAMA_MSG_STATUS_TIMEOUT); return MAMA_STATUS_OK; }
/* Description: Create a mamaMsg, add strings to fields in the message, * and iterate through the fields printing values via * callback method. * * Expected Result: MAMA_STATUS_OK */ TEST_F (MsgIterateTestC, IteratorCallback) { /* create a mama message. */ mamaMsg msg = NULL; mamaMsg_create (&msg); /* add a fields to the message. */ mamaMsg_addString (msg, "string", 101, "This is an iteration test."); mamaMsg_addU8 (msg, "u8", 102, 8); mamaMsg_addU16 (msg, "u16", 103, 16); mamaMsg_addU32 (msg, "u32", 104, 32); mamaMsg_addU64 (msg, "u64", 105, 64); /* iterate through the msg's fields */ ASSERT_EQ (MAMA_STATUS_OK, mamaMsg_iterateFields (msg, msgOnField, NULL, (void*) 2)); /* destroy the message. */ mamaMsg_destroy (msg); }
void MsgNewIteratorTestC::SetUp(void) { mama_loadBridge (&mBridge, getMiddleware()); mama_open(); /* add a fields to the message. */ mamaMsg_create (&msg); mamaMsg_addU8 (msg, "u8", 101, 8); mamaMsg_addString (msg, "string", 102, "This is an iteration test."); mamaMsg_addU16 (msg, "u16", 103, 16); mamaMsg_addU32 (msg, "u32", 104, 32); mamaMsg_addU64 (msg, "u64", 105, 64); /* Build the MAMA Dictionary from our test message. */ mamaDictionary_create (&dict); mamaDictionary_buildDictionaryFromMessage (dict, msg); /* Create the message iterator */ mamaMsgIterator_create (&iterator, dict); mamaMsgIterator_associate (iterator, msg); }
mama_status mamaFieldCache_updateMsgField(mamaFieldCache fieldCache, mamaFieldCacheField field, mamaMsg message, mama_bool_t useUpdate) { mama_status status = MAMA_STATUS_OK; mama_fid_t fid; mamaFieldType type; const char* name = NULL; mamaFieldCacheField_getFid(field, &fid); mamaFieldCacheField_getType(field, &type); if (fieldCache->mUseFieldNames) { mamaFieldCacheField_getName(field, &name); } switch (type) { case MAMA_FIELD_TYPE_BOOL: { mama_bool_t value; mamaFieldCacheField_getBool(field, &value); status = useUpdate ? mamaMsg_updateBool(message, name, fid, value) : mamaMsg_addBool(message, name, fid, value); break; } case MAMA_FIELD_TYPE_CHAR: { char value; mamaFieldCacheField_getChar(field, &value); status = useUpdate ? mamaMsg_updateChar(message, name, fid, value) : mamaMsg_addChar(message, name, fid, value); break; } case MAMA_FIELD_TYPE_I8: { mama_i8_t value; mamaFieldCacheField_getI8(field, &value); status = useUpdate ? mamaMsg_updateI8(message, name, fid, value) : mamaMsg_addI8(message, name, fid, value); break; } case MAMA_FIELD_TYPE_U8: { mama_u8_t value; mamaFieldCacheField_getU8(field, &value); status = useUpdate ? mamaMsg_updateU8(message, name, fid, value) : mamaMsg_addU8(message, name, fid, value); break; } case MAMA_FIELD_TYPE_I16: { mama_i16_t value; mamaFieldCacheField_getI16(field, &value); status = useUpdate ? mamaMsg_updateI16(message, name, fid, value) : mamaMsg_addI16(message, name, fid, value); break; } case MAMA_FIELD_TYPE_U16: { mama_u16_t value; mamaFieldCacheField_getU16(field, &value); status = useUpdate ? mamaMsg_updateU16(message, name, fid, value) : mamaMsg_addU16(message, name, fid, value); break; } case MAMA_FIELD_TYPE_I32: { mama_i32_t value; mamaFieldCacheField_getI32(field, &value); status = useUpdate ? mamaMsg_updateI32(message, name, fid, value) : mamaMsg_addI32(message, name, fid, value); break; } case MAMA_FIELD_TYPE_U32: { mama_u32_t value; mamaFieldCacheField_getU32(field, &value); status = useUpdate ? mamaMsg_updateU32(message, name, fid, value) : mamaMsg_addU32(message, name, fid, value); break; } case MAMA_FIELD_TYPE_I64: { mama_i64_t value; mamaFieldCacheField_getI64(field, &value); status = useUpdate ? mamaMsg_updateI64(message, name, fid, value) : mamaMsg_addI64(message, name, fid, value); break; } case MAMA_FIELD_TYPE_U64: { mama_u64_t value; mamaFieldCacheField_getU64(field, &value); status = useUpdate ? mamaMsg_updateU64(message, name, fid, value) : mamaMsg_addU64(message, name, fid, value); break; } case MAMA_FIELD_TYPE_F32: { mama_f32_t value; mamaFieldCacheField_getF32(field, &value); status = useUpdate ? mamaMsg_updateF32(message, name, fid, value) : mamaMsg_addF32(message, name, fid, value); break; } case MAMA_FIELD_TYPE_QUANTITY: case MAMA_FIELD_TYPE_F64: { mama_f64_t value; mamaFieldCacheField_getF64(field, &value); status = useUpdate ? mamaMsg_updateF64(message, name, fid, value) : mamaMsg_addF64(message, name, fid, value); break; } case MAMA_FIELD_TYPE_STRING: { const char* value = NULL; mama_size_t len; mamaFieldCacheField_getString(field, &value, &len); if (!value) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateString(message, name, fid, value) : mamaMsg_addString(message, name, fid, value); break; } case MAMA_FIELD_TYPE_PRICE: { const mamaPrice value = NULL; mamaFieldCacheField_getPrice(field, &value); if (!value) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updatePrice(message, name, fid, value) : mamaMsg_addPrice(message, name, fid, value); break; } case MAMA_FIELD_TYPE_TIME: { const mamaDateTime value = NULL; mamaFieldCacheField_getDateTime(field, &value); if (!value) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateDateTime(message, name, fid, value) : mamaMsg_addDateTime(message, name, fid, value); break; } case MAMA_FIELD_TYPE_VECTOR_I8: { const mama_i8_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getI8Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorI8(message, name, fid, values, size) : mamaMsg_addVectorI8(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_U8: { const mama_u8_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getU8Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorU8(message, name, fid, values, size) : mamaMsg_addVectorU8(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_I16: { const mama_i16_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getI16Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorI16(message, name, fid, values, size) : mamaMsg_addVectorI16(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_U16: { const mama_u16_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getU16Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorU16(message, name, fid, values, size) : mamaMsg_addVectorU16(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_I32: { const mama_i32_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getI32Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorI32(message, name, fid, values, size) : mamaMsg_addVectorI32(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_U32: { const mama_u32_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getU32Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorU32(message, name, fid, values, size) : mamaMsg_addVectorU32(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_I64: { const mama_i64_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getI64Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorI64(message, name, fid, values, size) : mamaMsg_addVectorI64(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_U64: { const mama_u64_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getU64Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorU64(message, name, fid, values, size) : mamaMsg_addVectorU64(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_F32: { const mama_f32_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getF32Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorF32(message, name, fid, values, size) : mamaMsg_addVectorF32(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_F64: { const mama_f64_t* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getF64Vector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorF64(message, name, fid, values, size) : mamaMsg_addVectorF64(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_STRING: { const char** values = NULL; mama_size_t size = 0; mamaFieldCacheField_getStringVector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = useUpdate ? mamaMsg_updateVectorString(message, name, fid, values, size) : mamaMsg_addVectorString(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_PRICE: { const mamaPrice* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getPriceVector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = /*useUpdate ? mamaMsg_updateVectorPrice(message, name, fid, values, size) : */mamaMsg_addVectorPrice(message, name, fid, values, size); break; } case MAMA_FIELD_TYPE_VECTOR_TIME: { const mamaDateTime* values = NULL; mama_size_t size = 0; mamaFieldCacheField_getDateTimeVector(field, &values, &size); if (!values) { return MAMA_STATUS_INVALID_ARG; } status = /*useUpdate ? mamaMsg_updateVectorTime(message, name, fid, values, size) : */mamaMsg_addVectorDateTime(message, name, fid, values, size); break; } default: status = MAMA_STATUS_NOT_FOUND; break; } return status; }
int main (int argc, const char **argv) { mamaPlaybackFileParser fileParser = NULL; mamaPlaybackCapture fileCapture = NULL; char* headerString = NULL; mamaMsg sourceMsg = NULL; mamaMsg targetMsg = NULL; mamaMsgField aField = NULL; mamaBridge gMamaBridge = NULL; mamaMsgIterator iterator = NULL; mamaFieldType fieldType = MAMA_FIELD_TYPE_UNKNOWN; parseCommandLine (argc, argv); mama_loadBridge (&gMamaBridge, "wmw"); mama_loadBridge (&gMamaBridge, "avis"); mama_open (); mamaPlaybackFileParser_allocate (&fileParser); mamaPlaybackFileParser_openFile(fileParser, (char*)gInputFilename); mamaCapture_allocate(&fileCapture); mamaCapture_openFile (&fileCapture, gOutputFilename); mamaMsgIterator_create(&iterator, NULL); mamaMsg_createForPayload(&targetMsg, 'A'); while (mamaPlaybackFileParser_getNextHeader(fileParser, &headerString)) { if (mamaPlaybackFileParser_getNextMsg (fileParser, &sourceMsg)) { char temp[64]; char* start = headerString; char* end = strchr (headerString,':'); strncpy (temp,start, end-start); temp[end-start]='\0'; mamaCapture_setFeedSource (&fileCapture, temp); end++; start=end; end = strchr (start,':'); strncpy (temp,start, end-start);temp[end-start]='\0'; mamaCapture_setTransportName (&fileCapture, temp); end++; start=end; end = strchr (start,'\0'); strncpy (temp,start, end-start);temp[end-start]='\0'; mamaCapture_setSymbol (&fileCapture, temp); mamaMsgIterator_associate(iterator, sourceMsg); mamaMsg_clear(targetMsg); while ((aField = mamaMsgIterator_next(iterator)) != NULL) { uint16_t fid = 0; mamaMsgField_getFid(aField, &fid); mamaMsgField_getType(aField, &fieldType); switch (fieldType) { case MAMA_FIELD_TYPE_BOOL: { mama_bool_t result; mamaMsgField_getBool (aField, &result); mamaMsg_addBool(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_CHAR: {char result; mamaMsgField_getChar (aField, &result); mamaMsg_addChar(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_I8: {mama_i8_t result; mamaMsgField_getI8 (aField, &result); mamaMsg_addI8(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_U8: {mama_u8_t result; mamaMsgField_getU8 (aField, &result); mamaMsg_addU8(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_I16: {mama_i16_t result; mamaMsgField_getI16 (aField, &result); mamaMsg_addI16(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_U16: {mama_u16_t result; mamaMsgField_getU16 (aField, &result); mamaMsg_addU16(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_I32: {mama_i32_t result; mamaMsgField_getI32 (aField, &result); mamaMsg_addI32(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_U32: {mama_u32_t result; mamaMsgField_getU32 (aField, &result); mamaMsg_addU32(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_I64: {mama_i64_t result; mamaMsgField_getI64 (aField, &result); mamaMsg_addI64(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_U64: {mama_u64_t result; mamaMsgField_getU64 (aField, &result); mamaMsg_addU64(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_F32: {mama_f32_t result; mamaMsgField_getF32 (aField, &result); mamaMsg_addF32(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_F64: {mama_f64_t result; mamaMsgField_getF64 (aField, &result); mamaMsg_addF64(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_STRING: {const char* result; mamaMsgField_getString (aField, &result); mamaMsg_addString(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_TIME: { mamaDateTime result; mamaMsgField_getDateTime (aField, result); mamaMsg_addDateTime(targetMsg, NULL, fid, result); }break; case MAMA_FIELD_TYPE_PRICE: { mamaPrice result; mamaMsgField_getPrice(aField, result); mamaMsg_addPrice(targetMsg, NULL, fid, result); }break; default: case MAMA_FIELD_TYPE_VECTOR_I8: case MAMA_FIELD_TYPE_VECTOR_U8: case MAMA_FIELD_TYPE_VECTOR_I16: case MAMA_FIELD_TYPE_VECTOR_U16: case MAMA_FIELD_TYPE_VECTOR_I32: case MAMA_FIELD_TYPE_VECTOR_U32: case MAMA_FIELD_TYPE_VECTOR_I64: case MAMA_FIELD_TYPE_VECTOR_U64: case MAMA_FIELD_TYPE_VECTOR_F32: case MAMA_FIELD_TYPE_VECTOR_F64: case MAMA_FIELD_TYPE_VECTOR_STRING: case MAMA_FIELD_TYPE_VECTOR_MSG: case MAMA_FIELD_TYPE_VECTOR_TIME: case MAMA_FIELD_TYPE_VECTOR_PRICE: case MAMA_FIELD_TYPE_QUANTITY: case MAMA_FIELD_TYPE_COLLECTION : case MAMA_FIELD_TYPE_UNKNOWN: case MAMA_FIELD_TYPE_OPAQUE: case MAMA_FIELD_TYPE_MSG: break; } } mamaCapture_saveMamaMsg (&fileCapture, &targetMsg); } } mamaMsgIterator_destroy(iterator); mamaCapture_closeFile(fileCapture); mamaCapture_deallocate (fileCapture); mamaPlaybackFileParser_closeFile(fileParser); mamaPlaybackFileParser_deallocate (fileParser); return (0); }
TEST_F (MsgIterateTestC, CreateIterator) { mama_fid_t fid = 0; mamaMsgIterator iterator = NULL; mamaMsgField field = NULL; mamaFieldType type = MAMA_FIELD_TYPE_UNKNOWN; /* Create a mama message. */ mamaMsg msg = NULL; mamaMsg_create (&msg); /* add a fields to the message. */ mamaMsg_addString (msg, "string", 101, "This is an iteration test."); mamaMsg_addU8 (msg, "u8", 102, 8); mamaMsg_addU16 (msg, "u16", 103, 16); mamaMsg_addU32 (msg, "u32", 104, 32); mamaMsg_addU64 (msg, "u64", 105, 64); /* Create iterator and message field required.*/ ASSERT_EQ (MAMA_STATUS_OK, mamaMsgIterator_create (&iterator,NULL)); mamaMsgIterator_associate (iterator,msg); while ((field = mamaMsgIterator_next(iterator)) != NULL) { /* Operate on contents of each field. */ mamaMsgField_getFid (field, &fid); mamaMsgField_getType (field, &type); switch(type) { case MAMA_FIELD_TYPE_STRING: { char buffer[MAX_FIELD_STR_LEN]; ASSERT_EQ (101, fid); mamaMsgField_getAsString (field, buffer, MAX_FIELD_STR_LEN); ASSERT_STREQ ("This is an iteration test.", buffer); break; } case MAMA_FIELD_TYPE_U8: { mama_u8_t buffer = 0; ASSERT_EQ (102, fid); mamaMsgField_getU8 (field, &buffer); ASSERT_EQ (8, buffer); break; } case MAMA_FIELD_TYPE_U16: { mama_u16_t buffer = 0; ASSERT_EQ (103, fid); mamaMsgField_getU16 (field, &buffer); ASSERT_EQ (16, buffer); break; } case MAMA_FIELD_TYPE_U32: { mama_u32_t buffer = 0; ASSERT_EQ (104, fid); mamaMsgField_getU32 (field, &buffer); ASSERT_EQ (32, buffer); break; } case MAMA_FIELD_TYPE_U64: { mama_u64_t buffer = 0; ASSERT_EQ (105, fid); mamaMsgField_getU64 (field, &buffer); ASSERT_EQ (64, buffer); break; } default: break; } } /* destroy the message. */ mamaMsg_destroy (msg); }
mama_status msgUtils_createSubscriptionMessage( mamaSubscription subscription, mamaSubscMsgType subscMsgType, mamaMsg* msg, const char* issueSymbol) { uint8_t appDataType = 0; char* ipaddr; mama_status status = mamaMsg_create (msg); if (status != MAMA_STATUS_OK) { return status; } if (subscription != NULL) { mamaBridgeImpl* bridge = mamaSubscription_getBridgeImpl (subscription); const char* source = NULL; const char* symbol = NULL; mamaSubscriptionType type = MAMA_SUBSC_TYPE_NORMAL; mamaMsgImpl_useBridgePayload (*msg, bridge); mamaSubscription_getSource (subscription, &source); /* For group subs the issue symbol needs to be passed in as it is not the same as the subscribe symbol */ if (issueSymbol) { symbol = issueSymbol; } else { mamaSubscription_getSubscSymbol (subscription, &symbol); } mamaSubscription_getSubscriptionType (subscription, &type); mamaSubscription_getAppDataType (subscription, &appDataType); status = mamaMsgImpl_setSubscInfo ( *msg, mamaSubscription_getSubscRoot (subscription), source, symbol, 1); if (status != MAMA_STATUS_OK) return status; status = mamaMsg_addI32 ( *msg, MamaFieldSubscriptionType.mName, MamaFieldSubscriptionType.mFid, type); if (status != MAMA_STATUS_OK) return status; } status = mamaMsg_addI32 ( *msg, MamaFieldSubscMsgType.mName, MamaFieldSubscMsgType.mFid, subscMsgType); if (status != MAMA_STATUS_OK) { return status; } status = mamaMsg_addU8 ( *msg, MamaFieldAppDataType.mName, MamaFieldAppDataType.mFid, appDataType); if (status != MAMA_STATUS_OK) { return status; } #ifndef IGNORE_DEPRECATED_FIELDS status = mamaMsg_addI32 ( *msg, MamaFieldSubscMsgTypeOld.mName, MamaFieldSubscMsgTypeOld.mFid, subscMsgType); if (status != MAMA_STATUS_OK) return status; #endif mama_getIpAddress ((const char**)&ipaddr); if (ipaddr != NULL && strlen( ipaddr ) > 0) { status = mamaMsg_addString ( *msg, MamaFieldSubscSourceHost.mName, MamaFieldSubscSourceHost.mFid, ipaddr); if (status != MAMA_STATUS_OK) return status; } return MAMA_STATUS_OK; }