cosmetic cleanups, add some inline documentation and todos

src/server/ua_services_subscription.c

@@ -18,65 +18,89 @@ void Service_CreateSubscription(UA_Server *server, UA_Session *session,
     response->subscriptionId = SubscriptionManager_getUniqueUIntID(&session->subscriptionManager);
     UA_Subscription *newSubscription = UA_Subscription_new(response->subscriptionId);
     
-    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.GlobalPublishingInterval,
+    /* set the publishing interval */
+    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.globalPublishingInterval,
                                request->requestedPublishingInterval, response->revisedPublishingInterval);
-    newSubscription->PublishingInterval = response->revisedPublishingInterval;
+    newSubscription->publishingInterval = response->revisedPublishingInterval;
     
-    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.GlobalLifeTimeCount,
+    /* set the subscription lifetime (deleted when no publish requests arrive within this time) */
+    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.globalLifeTimeCount,
                                request->requestedLifetimeCount, response->revisedLifetimeCount);
-    newSubscription->LifeTime = (UA_UInt32_BoundedValue)  {
-        .minValue=session->subscriptionManager.GlobalLifeTimeCount.minValue,
-        .maxValue=session->subscriptionManager.GlobalLifeTimeCount.maxValue,
+    newSubscription->lifeTime = (UA_UInt32_BoundedValue)  {
+        .minValue=session->subscriptionManager.globalLifeTimeCount.minValue,
+        .maxValue=session->subscriptionManager.globalLifeTimeCount.maxValue,
         .currentValue=response->revisedLifetimeCount};
     
-    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.GlobalKeepAliveCount,
+    /* set the keepalive count. the server sends an empty notification when
+       nothin has happened for n publishing intervals */
+    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.globalKeepAliveCount,
                                request->requestedMaxKeepAliveCount, response->revisedMaxKeepAliveCount);
-    newSubscription->KeepAliveCount = (UA_Int32_BoundedValue)  {
-        .minValue=session->subscriptionManager.GlobalKeepAliveCount.minValue,
-        .maxValue=session->subscriptionManager.GlobalKeepAliveCount.maxValue,
+    newSubscription->keepAliveCount = (UA_Int32_BoundedValue)  {
+        .minValue=session->subscriptionManager.globalKeepAliveCount.minValue,
+        .maxValue=session->subscriptionManager.globalKeepAliveCount.maxValue,
         .currentValue=response->revisedMaxKeepAliveCount};
     
-    newSubscription->NotificationsPerPublish = request->maxNotificationsPerPublish;
-    newSubscription->PublishingMode          = request->publishingEnabled;
-    newSubscription->Priority                = request->priority;
+    newSubscription->notificationsPerPublish = request->maxNotificationsPerPublish;
+    newSubscription->publishingMode          = request->publishingEnabled;
+    newSubscription->priority                = request->priority;
     
+    /* add the update job */
     UA_Guid jobId = SubscriptionManager_getUniqueGUID(&session->subscriptionManager);
     Subscription_createdUpdateJob(server, jobId, newSubscription);
     Subscription_registerUpdateJob(server, newSubscription);
     SubscriptionManager_addSubscription(&session->subscriptionManager, newSubscription);    
 }
 
-static void createMonitoredItems(UA_Server *server, UA_Session *session,
-                                 UA_Subscription *sub, const UA_MonitoredItemCreateRequest *request,
+static void createMonitoredItems(UA_Server *server, UA_Session *session, UA_Subscription *sub,
+                                 const UA_MonitoredItemCreateRequest *request,
                                  UA_MonitoredItemCreateResult *result) {
     const UA_Node *target = UA_NodeStore_get(server->nodestore, &request->itemToMonitor.nodeId);
     if(!target) {
         result->statusCode = UA_STATUSCODE_BADNODEIDINVALID;
-        result->monitoredItemId = 0;
-        result->revisedSamplingInterval = 0;
-        result->revisedQueueSize = 0;
         return;
     }
 
     UA_MonitoredItem *newMon = UA_MonitoredItem_new();
-    UA_NodeId_copy(&target->nodeId, &newMon->monitoredNodeId);
-    newMon->ItemId = ++(session->subscriptionManager.LastSessionID);
-    result->monitoredItemId = newMon->ItemId;
-    newMon->ClientHandle = request->requestedParameters.clientHandle;
-    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.GlobalSamplingInterval,
+    if(!newMon) {
+        result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
+        UA_NodeStore_release(target);
+        return;
+    }
+
+    UA_StatusCode retval = UA_NodeId_copy(&target->nodeId, &newMon->monitoredNodeId);
+    if(retval != UA_STATUSCODE_GOOD) {
+        result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY;
+        MonitoredItem_delete(newMon);
+        UA_NodeStore_release(target);
+        return;
+    }
+
+    newMon->itemId = ++(session->subscriptionManager.lastSessionID);
+    result->monitoredItemId = newMon->itemId;
+    newMon->clientHandle = request->requestedParameters.clientHandle;
+
+    /* set the sampling interval */
+    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.globalSamplingInterval,
                                request->requestedParameters.samplingInterval,
                                result->revisedSamplingInterval);
-    newMon->SamplingInterval = result->revisedSamplingInterval;
-    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.GlobalQueueSize,
+    newMon->samplingInterval = result->revisedSamplingInterval;
+
+    /* set the queue size */
+    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.globalQueueSize,
                                request->requestedParameters.queueSize,
                                result->revisedQueueSize);
-    newMon->QueueSize = (UA_UInt32_BoundedValue) {
+    newMon->queueSize = (UA_UInt32_BoundedValue) {
         .maxValue=(result->revisedQueueSize) + 1,
         .minValue=0, .currentValue=0 };
-    newMon->AttributeID = request->itemToMonitor.attributeId;
-    newMon->MonitoredItemType = MONITOREDITEM_TYPE_CHANGENOTIFY;
-    newMon->DiscardOldest = request->requestedParameters.discardOldest;
+
+    newMon->attributeID = request->itemToMonitor.attributeId;
+    newMon->monitoredItemType = MONITOREDITEM_TYPE_CHANGENOTIFY;
+    newMon->discardOldest = request->requestedParameters.discardOldest;
     LIST_INSERT_HEAD(&sub->MonitoredItems, newMon, listEntry);
+
+    // todo: add a job that samples the value (for fixed intervals)
+    // todo: add a pointer to the monitoreditem to the variable, so that events get propagated
+    
     UA_NodeStore_release(target);
 }
 
@@ -106,11 +130,6 @@ void Service_CreateMonitoredItems(UA_Server *server, UA_Session *session,
         createMonitoredItems(server, session, sub, &request->itemsToCreate[i], &response->results[i]);
 }
 
-static void publish(UA_Server *server, UA_Session *session, UA_Subscription *sub,
-                    const UA_PublishRequest *request, UA_PublishResponse *response) {
-
-}
-
 void Service_Publish(UA_Server *server, UA_Session *session, const UA_PublishRequest *request,
                      UA_PublishResponse *response) {
     UA_SubscriptionManager *manager= &session->subscriptionManager;
@@ -129,14 +148,13 @@ void Service_Publish(UA_Server *server, UA_Session *session, const UA_PublishReq
             response->results[i] = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID;
             continue;
         }
-        if(Subscription_deleteUnpublishedNotification(request->subscriptionAcknowledgements[i].sequenceNumber,
-                                                      sub) == 0)
+        if(Subscription_deleteUnpublishedNotification(request->subscriptionAcknowledgements[i].sequenceNumber, sub) == 0)
             response->results[i] = UA_STATUSCODE_BADSEQUENCENUMBERINVALID;
     }
     
     // See if any new data is available
     UA_Subscription *sub;
-    LIST_FOREACH(sub, &manager->ServerSubscriptions, listEntry) {
+    LIST_FOREACH(sub, &manager->serverSubscriptions, listEntry) {
         if(sub->timedUpdateIsRegistered == UA_FALSE) {
             // FIXME: We are forcing a value update for monitored items. This should be done by the event system.
             // NOTE:  There is a clone of this functionality in the Subscription_timedUpdateNotificationsJob
@@ -152,13 +170,13 @@ void Service_Publish(UA_Server *server, UA_Session *session, const UA_PublishReq
         if(Subscription_queuedNotifications(sub) <= 0)
             continue;
         
-        response->subscriptionId = sub->SubscriptionID;
+        response->subscriptionId = sub->subscriptionID;
         Subscription_copyTopNotificationMessage(&response->notificationMessage, sub);
-        if(sub->unpublishedNotifications.lh_first->notification->sequenceNumber > sub->SequenceNumber) {
+        if(sub->unpublishedNotifications.lh_first->notification->sequenceNumber > sub->sequenceNumber) {
             // If this is a keepalive message, its seqNo is the next seqNo to be used for an actual msg.
             response->availableSequenceNumbersSize = 0;
             // .. and must be deleted
-            Subscription_deleteUnpublishedNotification(sub->SequenceNumber + 1, sub);
+            Subscription_deleteUnpublishedNotification(sub->sequenceNumber + 1, sub);
         } else {
             response->availableSequenceNumbersSize = Subscription_queuedNotifications(sub);
             response->availableSequenceNumbers = Subscription_getAvailableSequenceNumbers(sub);
@@ -172,13 +190,13 @@ void Service_Publish(UA_Server *server, UA_Session *session, const UA_PublishReq
     // request, but currently we need to return something to the client. If no
     // subscriptions have notifications, force one to generate a keepalive so we
     // don't return an empty message
-    sub = LIST_FIRST(&manager->ServerSubscriptions);
+    sub = LIST_FIRST(&manager->serverSubscriptions);
     if(!sub) {
-        response->subscriptionId = sub->SubscriptionID;
-        sub->KeepAliveCount.currentValue=sub->KeepAliveCount.minValue;
+        response->subscriptionId = sub->subscriptionID;
+        sub->keepAliveCount.currentValue=sub->keepAliveCount.minValue;
         Subscription_generateKeepAlive(sub);
         Subscription_copyTopNotificationMessage(&response->notificationMessage, sub);
-        Subscription_deleteUnpublishedNotification(sub->SequenceNumber + 1, sub);
+        Subscription_deleteUnpublishedNotification(sub->sequenceNumber + 1, sub);
     }
     
     // FIXME: This should be in processMSG();
@@ -195,26 +213,26 @@ void Service_ModifySubscription(UA_Server *server, UA_Session *session,
         return;
     }
     
-    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.GlobalPublishingInterval,
+    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.globalPublishingInterval,
                                request->requestedPublishingInterval, response->revisedPublishingInterval);
-    sub->PublishingInterval = response->revisedPublishingInterval;
+    sub->publishingInterval = response->revisedPublishingInterval;
     
-    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.GlobalLifeTimeCount,
+    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.globalLifeTimeCount,
                                request->requestedLifetimeCount, response->revisedLifetimeCount);
-    sub->LifeTime = (UA_UInt32_BoundedValue)  {
-        .minValue=session->subscriptionManager.GlobalLifeTimeCount.minValue,
-        .maxValue=session->subscriptionManager.GlobalLifeTimeCount.maxValue,
+    sub->lifeTime = (UA_UInt32_BoundedValue)  {
+        .minValue=session->subscriptionManager.globalLifeTimeCount.minValue,
+        .maxValue=session->subscriptionManager.globalLifeTimeCount.maxValue,
         .currentValue=response->revisedLifetimeCount};
         
-    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.GlobalKeepAliveCount,
+    UA_BOUNDEDVALUE_SETWBOUNDS(session->subscriptionManager.globalKeepAliveCount,
                                 request->requestedMaxKeepAliveCount, response->revisedMaxKeepAliveCount);
-    sub->KeepAliveCount = (UA_Int32_BoundedValue)  {
-        .minValue=session->subscriptionManager.GlobalKeepAliveCount.minValue,
-        .maxValue=session->subscriptionManager.GlobalKeepAliveCount.maxValue,
+    sub->keepAliveCount = (UA_Int32_BoundedValue)  {
+        .minValue=session->subscriptionManager.globalKeepAliveCount.minValue,
+        .maxValue=session->subscriptionManager.globalKeepAliveCount.maxValue,
         .currentValue=response->revisedMaxKeepAliveCount};
         
-    sub->NotificationsPerPublish = request->maxNotificationsPerPublish;
-    sub->Priority                = request->priority;
+    sub->notificationsPerPublish = request->maxNotificationsPerPublish;
+    sub->priority                = request->priority;
     
     Subscription_registerUpdateJob(server, sub);
     return;
@@ -253,6 +271,6 @@ void Service_DeleteMonitoredItems(UA_Server *server, UA_Session *session,
     response->resultsSize = request->monitoredItemIdsSize;
 
     for(UA_Int32 i = 0; i < request->monitoredItemIdsSize; i++)
-        response->results[i] = SubscriptionManager_deleteMonitoredItem(manager, sub->SubscriptionID,
+        response->results[i] = SubscriptionManager_deleteMonitoredItem(manager, sub->subscriptionID,
                                                                        request->monitoredItemIds[i]);
 }

src/server/ua_subscription.c

@@ -6,13 +6,13 @@
 /* Subscription */
 /****************/
 
-UA_Subscription *UA_Subscription_new(UA_Int32 SubscriptionID) {
+UA_Subscription *UA_Subscription_new(UA_Int32 subscriptionID) {
     UA_Subscription *new = UA_malloc(sizeof(UA_Subscription));
     if(!new)
         return UA_NULL;
-    new->SubscriptionID = SubscriptionID;
-    new->LastPublished  = 0;
-    new->SequenceNumber = 0;
+    new->subscriptionID = subscriptionID;
+    new->lastPublished  = 0;
+    new->sequenceNumber = 0;
     memset(&new->timedUpdateJobGuid, 0, sizeof(UA_Guid));
     new->timedUpdateJob          = UA_NULL;
     new->timedUpdateIsRegistered = UA_FALSE;
@@ -27,7 +27,7 @@ void UA_Subscription_deleteMembers(UA_Subscription *subscription, UA_Server *ser
     
     // Just in case any parallel process attempts to access this subscription
     // while we are deleting it... make it vanish.
-    subscription->SubscriptionID = 0;
+    subscription->subscriptionID = 0;
     
     // Delete monitored Items
     LIST_FOREACH_SAFE(mon, &subscription->MonitoredItems, listEntry, tmp_mon) {
@@ -60,8 +60,8 @@ UA_UInt32 Subscription_queuedNotifications(UA_Subscription *subscription) {
 }
 
 void Subscription_generateKeepAlive(UA_Subscription *subscription) {
-    if(subscription->KeepAliveCount.currentValue > subscription->KeepAliveCount.minValue &&
-       subscription->KeepAliveCount.currentValue <= subscription->KeepAliveCount.maxValue)
+    if(subscription->keepAliveCount.currentValue > subscription->keepAliveCount.minValue &&
+       subscription->keepAliveCount.currentValue <= subscription->keepAliveCount.maxValue)
         return;
 
     UA_unpublishedNotification *msg = UA_malloc(sizeof(UA_unpublishedNotification));
@@ -71,11 +71,11 @@ void Subscription_generateKeepAlive(UA_Subscription *subscription) {
     msg->notification = UA_malloc(sizeof(UA_NotificationMessage));
     msg->notification->notificationData = UA_NULL;
     // KeepAlive uses next message, but does not increment counter
-    msg->notification->sequenceNumber = subscription->SequenceNumber + 1;
+    msg->notification->sequenceNumber = subscription->sequenceNumber + 1;
     msg->notification->publishTime    = UA_DateTime_now();
     msg->notification->notificationDataSize = 0;
     LIST_INSERT_HEAD(&subscription->unpublishedNotifications, msg, listEntry);
-    subscription->KeepAliveCount.currentValue = subscription->KeepAliveCount.maxValue;
+    subscription->keepAliveCount.currentValue = subscription->keepAliveCount.maxValue;
 }
 
 void Subscription_updateNotifications(UA_Subscription *subscription) {
@@ -86,7 +86,7 @@ void Subscription_updateNotifications(UA_Subscription *subscription) {
     UA_DataChangeNotification *changeNotification;
     size_t notificationOffset;
     
-    if(!subscription || subscription->LastPublished + subscription->PublishingInterval > UA_DateTime_now())
+    if(!subscription || subscription->lastPublished + subscription->publishingInterval > UA_DateTime_now())
         return;
     
     // Make sure there is data to be published and establish which message types
@@ -95,12 +95,12 @@ void Subscription_updateNotifications(UA_Subscription *subscription) {
         // Check if this MonitoredItems Queue holds data and how much data is held in total
         if(!TAILQ_FIRST(&mon->queue))
             continue;
-        if((mon->MonitoredItemType & MONITOREDITEM_TYPE_CHANGENOTIFY) != 0)
-            monItemsChangeT+=mon->QueueSize.currentValue;
-	    else if((mon->MonitoredItemType & MONITOREDITEM_TYPE_STATUSNOTIFY) != 0)
-            monItemsStatusT+=mon->QueueSize.currentValue;
-	    else if((mon->MonitoredItemType & MONITOREDITEM_TYPE_EVENTNOTIFY)  != 0)
-            monItemsEventT+=mon->QueueSize.currentValue;
+        if((mon->monitoredItemType & MONITOREDITEM_TYPE_CHANGENOTIFY) != 0)
+            monItemsChangeT+=mon->queueSize.currentValue;
+	    else if((mon->monitoredItemType & MONITOREDITEM_TYPE_STATUSNOTIFY) != 0)
+            monItemsStatusT+=mon->queueSize.currentValue;
+	    else if((mon->monitoredItemType & MONITOREDITEM_TYPE_EVENTNOTIFY)  != 0)
+            monItemsEventT+=mon->queueSize.currentValue;
     }
     
     // FIXME: This is hardcoded to 100 because it is not covered by the spec but we need to protect the server!
@@ -113,7 +113,7 @@ void Subscription_updateNotifications(UA_Subscription *subscription) {
     
     if(monItemsChangeT == 0 && monItemsEventT == 0 && monItemsStatusT == 0) {
         // Decrement KeepAlive
-        subscription->KeepAliveCount.currentValue--;
+        subscription->keepAliveCount.currentValue--;
         // +- Generate KeepAlive msg if counter overruns
         Subscription_generateKeepAlive(subscription);
         return;
@@ -122,7 +122,7 @@ void Subscription_updateNotifications(UA_Subscription *subscription) {
     msg = (UA_unpublishedNotification *) UA_malloc(sizeof(UA_unpublishedNotification));
     msg->notification = UA_malloc(sizeof(UA_NotificationMessage));
     INITPOINTER(msg->notification->notificationData);
-    msg->notification->sequenceNumber = subscription->SequenceNumber++;
+    msg->notification->sequenceNumber = subscription->sequenceNumber++;
     msg->notification->publishTime    = UA_DateTime_now();
     
     // NotificationData is an array of Change, Status and Event messages, each containing the appropriate
@@ -150,7 +150,7 @@ void Subscription_updateNotifications(UA_Subscription *subscription) {
             // the propper NotificationMessageType (Status, Change, Event)
             monItemsChangeT = 0;
             LIST_FOREACH(mon, &subscription->MonitoredItems, listEntry) {
-                if(mon->MonitoredItemType != MONITOREDITEM_TYPE_CHANGENOTIFY || !TAILQ_FIRST(&mon->queue))
+                if(mon->monitoredItemType != MONITOREDITEM_TYPE_CHANGENOTIFY || !TAILQ_FIRST(&mon->queue))
                     continue;
                 // Note: Monitored Items might not return a queuedValue if there is a problem encoding it.
                 monItemsChangeT += MonitoredItem_QueueToDataChangeNotifications(&changeNotification->monitoredItems[monItemsChangeT], mon);
@@ -201,8 +201,6 @@ UA_UInt32 *Subscription_getAvailableSequenceNumbers(UA_Subscription *sub) {
 }
 
 void Subscription_copyTopNotificationMessage(UA_NotificationMessage *dst, UA_Subscription *sub) {
-    UA_NotificationMessage *latest;
-    
     if(!dst)
         return;
     
@@ -213,7 +211,7 @@ void Subscription_copyTopNotificationMessage(UA_NotificationMessage *dst, UA_Sub
       return;
     }
     
-    latest = LIST_FIRST(&sub->unpublishedNotifications)->notification;
+    UA_NotificationMessage *latest = LIST_FIRST(&sub->unpublishedNotifications)->notification;
     dst->notificationDataSize = latest->notificationDataSize;
     dst->publishTime = latest->publishTime;
     dst->sequenceNumber = latest->sequenceNumber;
@@ -261,7 +259,7 @@ static void Subscription_timedUpdateNotificationsJob(UA_Server *server, void *da
     // This is set by the Subscription_delete function to detere us from fiddling with
     // this subscription if it is being deleted (not technically thread save, but better
     // then nothing at all)
-    if(sub->SubscriptionID == 0)
+    if(sub->subscriptionID == 0)
         return;
     
     // FIXME: This should be done by the event system
@@ -294,15 +292,15 @@ UA_StatusCode Subscription_registerUpdateJob(UA_Server *server, UA_Subscription
     if(server == UA_NULL || sub == UA_NULL)
         return UA_STATUSCODE_BADSERVERINDEXINVALID;
     
-    if(sub->PublishingInterval <= 5 ) 
+    if(sub->publishingInterval <= 5 ) 
         return UA_STATUSCODE_BADNOTSUPPORTED;
     
     // Practically enough, the client sends a uint32 in ms, which we store as datetime, which here is required in as uint32 in ms as the interval
 #ifdef _MSC_VER
-    UA_Int32 retval = UA_Server_addRepeatedJob(server, *(sub->timedUpdateJob), sub->PublishingInterval,
+    UA_Int32 retval = UA_Server_addRepeatedJob(server, *(sub->timedUpdateJob), sub->publishingInterval,
                                                &sub->timedUpdateJobGuid);
 #else
-    UA_StatusCode retval = UA_Server_addRepeatedJob(server, *sub->timedUpdateJob, sub->PublishingInterval,
+    UA_StatusCode retval = UA_Server_addRepeatedJob(server, *sub->timedUpdateJob, sub->publishingInterval,
                                                     &sub->timedUpdateJobGuid);
 #endif
     if(!retval)
@@ -324,13 +322,13 @@ UA_StatusCode Subscription_unregisterUpdateJob(UA_Server *server, UA_Subscriptio
 
 UA_MonitoredItem *UA_MonitoredItem_new() {
     UA_MonitoredItem *new = (UA_MonitoredItem *) UA_malloc(sizeof(UA_MonitoredItem));
-    new->QueueSize   = (UA_UInt32_BoundedValue) { .minValue = 0, .maxValue = 0, .currentValue = 0};
-    new->LastSampled = 0;
+    new->queueSize   = (UA_UInt32_BoundedValue) { .minValue = 0, .maxValue = 0, .currentValue = 0};
+    new->lastSampled = 0;
     // FIXME: This is currently hardcoded;
-    new->MonitoredItemType = MONITOREDITEM_TYPE_CHANGENOTIFY;
+    new->monitoredItemType = MONITOREDITEM_TYPE_CHANGENOTIFY;
     TAILQ_INIT(&new->queue);
     UA_NodeId_init(&new->monitoredNodeId);
-    INITPOINTER(new->LastSampledValue.data );
+    INITPOINTER(new->lastSampledValue.data );
     return new;
 }
 
@@ -340,8 +338,8 @@ void MonitoredItem_delete(UA_MonitoredItem *monitoredItem) {
     // Remove from subscription list
     LIST_REMOVE(monitoredItem, listEntry);
     // Release comparison sample
-    if(monitoredItem->LastSampledValue.data != NULL) { 
-      UA_free(monitoredItem->LastSampledValue.data);
+    if(monitoredItem->lastSampledValue.data != NULL) { 
+      UA_free(monitoredItem->lastSampledValue.data);
     }
     
     UA_NodeId_deleteMembers(&(monitoredItem->monitoredNodeId));
@@ -355,7 +353,7 @@ int MonitoredItem_QueueToDataChangeNotifications(UA_MonitoredItemNotification *d
   
     // Count instead of relying on the items currentValue
     TAILQ_FOREACH(queueItem, &monitoredItem->queue, listEntry) {
-        dst[queueSize].clientHandle = monitoredItem->ClientHandle;
+        dst[queueSize].clientHandle = monitoredItem->clientHandle;
         dst[queueSize].value.hasServerPicoseconds = UA_FALSE;
         dst[queueSize].value.hasServerTimestamp   = UA_FALSE;
         dst[queueSize].value.serverTimestamp      = UA_FALSE;
@@ -380,18 +378,18 @@ void MonitoredItem_ClearQueue(UA_MonitoredItem *monitoredItem) {
         UA_Variant_deleteMembers(&val->value);
         UA_free(val);
     }
-    monitoredItem->QueueSize.currentValue = 0;
+    monitoredItem->queueSize.currentValue = 0;
 }
 
-UA_Boolean MonitoredItem_CopyMonitoredValueToVariant(UA_UInt32 AttributeID, const UA_Node *src,
+UA_Boolean MonitoredItem_CopyMonitoredValueToVariant(UA_UInt32 attributeID, const UA_Node *src,
                                                      UA_Variant *dst) {
     UA_Boolean samplingError = UA_TRUE; 
     UA_DataValue sourceDataValue;
     UA_DataValue_init(&sourceDataValue);
     const UA_VariableNode *srcAsVariableNode = (const UA_VariableNode*)src;
   
-    // FIXME: Not all AttributeIDs can be monitored yet
-    switch(AttributeID) {
+    // FIXME: Not all attributeIDs can be monitored yet
+    switch(attributeID) {
     case UA_ATTRIBUTEID_NODEID:
         UA_Variant_setScalarCopy(dst, (const UA_NodeId*)&src->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
         samplingError = UA_FALSE;
@@ -480,20 +478,18 @@ UA_Boolean MonitoredItem_CopyMonitoredValueToVariant(UA_UInt32 AttributeID, cons
 }
 
 void MonitoredItem_QueuePushDataValue(UA_Server *server, UA_MonitoredItem *monitoredItem) {
-    MonitoredItem_queuedValue *newvalue = NULL, *queueItem = NULL;
-    UA_Boolean samplingError = UA_TRUE; 
     UA_ByteString newValueAsByteString = { .length=0, .data=NULL };
     size_t encodingOffset = 0;
   
-    if(!monitoredItem || monitoredItem->LastSampled + monitoredItem->SamplingInterval > UA_DateTime_now())
+    if(!monitoredItem || monitoredItem->lastSampled + monitoredItem->samplingInterval > UA_DateTime_now())
         return;
   
     // FIXME: Actively suppress non change value based monitoring. There should be
     // another function to handle status and events.
-    if(monitoredItem->MonitoredItemType != MONITOREDITEM_TYPE_CHANGENOTIFY)
+    if(monitoredItem->monitoredItemType != MONITOREDITEM_TYPE_CHANGENOTIFY)
         return;
 
-    newvalue = UA_malloc(sizeof(MonitoredItem_queuedValue));
+    MonitoredItem_queuedValue *newvalue = UA_malloc(sizeof(MonitoredItem_queuedValue));
     if(!newvalue)
         return;
 
@@ -510,8 +506,8 @@ void MonitoredItem_QueuePushDataValue(UA_Server *server, UA_MonitoredItem *monit
         return;
     }
   
-    samplingError = MonitoredItem_CopyMonitoredValueToVariant(monitoredItem->AttributeID, target,
-                                                              &newvalue->value);
+    UA_Boolean samplingError = MonitoredItem_CopyMonitoredValueToVariant(monitoredItem->attributeID, target,
+                                                                         &newvalue->value);
     UA_NodeStore_release(target);
     if(samplingError != UA_FALSE || !newvalue->value.type) {
         UA_Variant_deleteMembers(&newvalue->value);
@@ -519,16 +515,16 @@ void MonitoredItem_QueuePushDataValue(UA_Server *server, UA_MonitoredItem *monit
         return;
     }
   
-    if(monitoredItem->QueueSize.currentValue >= monitoredItem->QueueSize.maxValue) {
-        if(monitoredItem->DiscardOldest != UA_TRUE) {
+    if(monitoredItem->queueSize.currentValue >= monitoredItem->queueSize.maxValue) {
+        if(monitoredItem->discardOldest != UA_TRUE) {
             // We cannot remove the oldest value and theres no queue space left. We're done here.
             UA_free(newvalue);
             return;
         }
-        queueItem = TAILQ_LAST(&monitoredItem->queue, QueueOfQueueDataValues);
+        MonitoredItem_queuedValue *queueItem = TAILQ_LAST(&monitoredItem->queue, QueueOfQueueDataValues);
         TAILQ_REMOVE(&monitoredItem->queue, queueItem, listEntry);
         UA_free(queueItem);
-        monitoredItem->QueueSize.currentValue--;
+        monitoredItem->queueSize.currentValue--;
     }
   
     // encode the data to find if its different to the previous
@@ -536,22 +532,22 @@ void MonitoredItem_QueuePushDataValue(UA_Server *server, UA_MonitoredItem *monit
     newValueAsByteString.data   = UA_malloc(newValueAsByteString.length);
     UA_encodeBinary(&newvalue->value, &UA_TYPES[UA_TYPES_VARIANT], &newValueAsByteString, &encodingOffset);
   
-    if(!monitoredItem->LastSampledValue.data) { 
-        monitoredItem->LastSampledValue = newValueAsByteString;
+    if(!monitoredItem->lastSampledValue.data) { 
+        monitoredItem->lastSampledValue = newValueAsByteString;
         TAILQ_INSERT_HEAD(&monitoredItem->queue, newvalue, listEntry);
-        monitoredItem->QueueSize.currentValue++;
-        monitoredItem->LastSampled = UA_DateTime_now();
+        monitoredItem->queueSize.currentValue++;
+        monitoredItem->lastSampled = UA_DateTime_now();
     } else {
-        if(UA_String_equal(&newValueAsByteString, &monitoredItem->LastSampledValue) == UA_TRUE) {
+        if(UA_String_equal(&newValueAsByteString, &monitoredItem->lastSampledValue) == UA_TRUE) {
             UA_Variant_deleteMembers(&newvalue->value);
             UA_free(newvalue);
             UA_String_deleteMembers(&newValueAsByteString);
             return;
         }
-        UA_ByteString_deleteMembers(&monitoredItem->LastSampledValue);
-        monitoredItem->LastSampledValue = newValueAsByteString;
+        UA_ByteString_deleteMembers(&monitoredItem->lastSampledValue);
+        monitoredItem->lastSampledValue = newValueAsByteString;
         TAILQ_INSERT_HEAD(&monitoredItem->queue, newvalue, listEntry);
-        monitoredItem->QueueSize.currentValue++;
-        monitoredItem->LastSampled = UA_DateTime_now();
+        monitoredItem->queueSize.currentValue++;
+        monitoredItem->lastSampled = UA_DateTime_now();
     }
 }

src/server/ua_subscription.h

@@ -29,29 +29,29 @@ typedef enum {
     MONITOREDITEM_TYPE_CHANGENOTIFY = 1,
     MONITOREDITEM_TYPE_STATUSNOTIFY = 2,
     MONITOREDITEM_TYPE_EVENTNOTIFY = 4
-} MONITOREDITEM_TYPE;
+} UA_MONITOREDITEM_TYPE;
 
 typedef struct MonitoredItem_queuedValue {
     UA_Variant value;
     TAILQ_ENTRY(MonitoredItem_queuedValue) listEntry;
 } MonitoredItem_queuedValue;
 
-typedef struct UA_MonitoredItem_s {
-    UA_UInt32                       ItemId;
-    MONITOREDITEM_TYPE		    MonitoredItemType;
-    UA_UInt32                       TimestampsToReturn;
-    UA_UInt32                       MonitoringMode;
-    UA_NodeId                       monitoredNodeId; 
-    UA_UInt32                       AttributeID;
-    UA_UInt32                       ClientHandle;
-    UA_UInt32                       SamplingInterval;
-    UA_UInt32_BoundedValue          QueueSize;
-    UA_Boolean                      DiscardOldest;
-    UA_DateTime                     LastSampled;
-    UA_ByteString                   LastSampledValue;
+typedef struct UA_MonitoredItem {
+    LIST_ENTRY(UA_MonitoredItem) listEntry;
+    UA_UInt32 itemId;
+    UA_MONITOREDITEM_TYPE monitoredItemType;
+    UA_UInt32 timestampsToReturn;
+    UA_UInt32 monitoringMode;
+    UA_NodeId monitoredNodeId; 
+    UA_UInt32 attributeID;
+    UA_UInt32 clientHandle;
+    UA_UInt32 samplingInterval;
+    UA_UInt32_BoundedValue queueSize;
+    UA_Boolean discardOldest;
+    UA_DateTime lastSampled;
+    UA_ByteString lastSampledValue;
     // FIXME: indexRange is ignored; array values default to element 0
     // FIXME: dataEncoding is hardcoded to UA binary
-    LIST_ENTRY(UA_MonitoredItem_s)  listEntry;
     TAILQ_HEAD(QueueOfQueueDataValues, MonitoredItem_queuedValue) queue;
 } UA_MonitoredItem;
 
@@ -59,7 +59,7 @@ UA_MonitoredItem *UA_MonitoredItem_new(void);
 void MonitoredItem_delete(UA_MonitoredItem *monitoredItem);
 void MonitoredItem_QueuePushDataValue(UA_Server *server, UA_MonitoredItem *monitoredItem);
 void MonitoredItem_ClearQueue(UA_MonitoredItem *monitoredItem);
-UA_Boolean MonitoredItem_CopyMonitoredValueToVariant(UA_UInt32 AttributeID, const UA_Node *src,
+UA_Boolean MonitoredItem_CopyMonitoredValueToVariant(UA_UInt32 attributeID, const UA_Node *src,
                                                      UA_Variant *dst);
 int MonitoredItem_QueueToDataChangeNotifications(UA_MonitoredItemNotification *dst,
                                                  UA_MonitoredItem *monitoredItem);
@@ -68,30 +68,30 @@ int MonitoredItem_QueueToDataChangeNotifications(UA_MonitoredItemNotification *d
 /* Subscription */
 /****************/
 
-typedef struct UA_unpublishedNotification_s {
-    UA_NotificationMessage 		     *notification;
-    LIST_ENTRY(UA_unpublishedNotification_s) listEntry;
+typedef struct UA_unpublishedNotification {
+    LIST_ENTRY(UA_unpublishedNotification) listEntry;
+    UA_NotificationMessage *notification;
 } UA_unpublishedNotification;
 
-typedef struct UA_Subscription_s {
-    UA_UInt32_BoundedValue              LifeTime;
-    UA_Int32_BoundedValue               KeepAliveCount;
-    UA_DateTime                         PublishingInterval;
-    UA_DateTime                         LastPublished;
-    UA_Int32                            SubscriptionID;
-    UA_Int32                            NotificationsPerPublish;
-    UA_Boolean                          PublishingMode;
-    UA_UInt32                           Priority;
-    UA_UInt32                           SequenceNumber;
-    UA_Guid                             timedUpdateJobGuid;
-    UA_Job                              *timedUpdateJob;
-    UA_Boolean                          timedUpdateIsRegistered;
-    LIST_ENTRY(UA_Subscription_s)       listEntry;
-    LIST_HEAD(UA_ListOfUnpublishedNotifications, UA_unpublishedNotification_s) unpublishedNotifications;
-    LIST_HEAD(UA_ListOfUAMonitoredItems, UA_MonitoredItem_s) MonitoredItems;
+typedef struct UA_Subscription {
+    LIST_ENTRY(UA_Subscription) listEntry;
+    UA_UInt32_BoundedValue lifeTime;
+    UA_Int32_BoundedValue keepAliveCount;
+    UA_DateTime publishingInterval;
+    UA_DateTime lastPublished;
+    UA_Int32 subscriptionID;
+    UA_Int32 notificationsPerPublish;
+    UA_Boolean publishingMode;
+    UA_UInt32 priority;
+    UA_UInt32 sequenceNumber;
+    UA_Guid timedUpdateJobGuid;
+    UA_Job *timedUpdateJob;
+    UA_Boolean timedUpdateIsRegistered;
+    LIST_HEAD(UA_ListOfUnpublishedNotifications, UA_unpublishedNotification) unpublishedNotifications;
+    LIST_HEAD(UA_ListOfUAMonitoredItems, UA_MonitoredItem) MonitoredItems;
 } UA_Subscription;
 
-UA_Subscription *UA_Subscription_new(UA_Int32 SubscriptionID);
+UA_Subscription *UA_Subscription_new(UA_Int32 subscriptionID);
 void UA_Subscription_deleteMembers(UA_Subscription *subscription, UA_Server *server);
 void Subscription_updateNotifications(UA_Subscription *subscription);
 UA_UInt32 Subscription_queuedNotifications(UA_Subscription *subscription);

src/server/ua_subscription_manager.c

@@ -8,14 +8,14 @@ void SubscriptionManager_init(UA_Session *session) {
 
     /* FIXME: These init values are empirical. Maybe they should be part
      *        of the server config? */
-    manager->GlobalPublishingInterval = (UA_Int32_BoundedValue) { .maxValue = 10000, .minValue = 0, .currentValue=0 };
-    manager->GlobalLifeTimeCount = (UA_UInt32_BoundedValue) { .maxValue = 15000, .minValue = 0, .currentValue=0 };
-    manager->GlobalKeepAliveCount = (UA_UInt32_BoundedValue) { .maxValue = 100, .minValue = 0, .currentValue=0 };
-    manager->GlobalNotificationsPerPublish = (UA_Int32_BoundedValue)  { .maxValue = 1000, .minValue = 1, .currentValue=0 };
-    manager->GlobalSamplingInterval = (UA_UInt32_BoundedValue) { .maxValue = 1000, .minValue = 5, .currentValue=0 };
-    manager->GlobalQueueSize = (UA_UInt32_BoundedValue) { .maxValue = 100, .minValue = 0, .currentValue=0 };
-    LIST_INIT(&manager->ServerSubscriptions);
-    manager->LastSessionID = (UA_UInt32) UA_DateTime_now();
+    manager->globalPublishingInterval = (UA_Int32_BoundedValue) { .maxValue = 10000, .minValue = 0, .currentValue=0 };
+    manager->globalLifeTimeCount = (UA_UInt32_BoundedValue) { .maxValue = 15000, .minValue = 0, .currentValue=0 };
+    manager->globalKeepAliveCount = (UA_UInt32_BoundedValue) { .maxValue = 100, .minValue = 0, .currentValue=0 };
+    manager->globalNotificationsPerPublish = (UA_Int32_BoundedValue)  { .maxValue = 1000, .minValue = 1, .currentValue=0 };
+    manager->globalSamplingInterval = (UA_UInt32_BoundedValue) { .maxValue = 1000, .minValue = 5, .currentValue=0 };
+    manager->globalQueueSize = (UA_UInt32_BoundedValue) { .maxValue = 100, .minValue = 0, .currentValue=0 };
+    LIST_INIT(&manager->serverSubscriptions);
+    manager->lastSessionID = (UA_UInt32) UA_DateTime_now();
     
     // Initialize a GUID with a 2^64 time dependant part, then fold the time in on itself to provide a more randomish
     // Counter
@@ -29,9 +29,9 @@ void SubscriptionManager_init(UA_Session *session) {
         UA_UInt64 ui64;
     } guidInitH;
     guidInitH.ui64 = (UA_UInt64) UA_DateTime_now();
-    manager->LastJobGuid.data1 = guidInitH.ui32h;
-    manager->LastJobGuid.data2 = (UA_UInt16) (guidInitH.ui32l >> 16);
-    manager->LastJobGuid.data3 = (UA_UInt16) (guidInitH.ui32l);
+    manager->lastJobGuid.data1 = guidInitH.ui32h;
+    manager->lastJobGuid.data2 = (UA_UInt16) (guidInitH.ui32l >> 16);
+    manager->lastJobGuid.data3 = (UA_UInt16) (guidInitH.ui32l);
     union {
         struct {
             UA_UInt32 ui32h;
@@ -40,20 +40,20 @@ void SubscriptionManager_init(UA_Session *session) {
         UA_UInt64 ui64;
     } guidInitL;
     guidInitL.ui64 = (UA_UInt64) UA_DateTime_now();
-    manager->LastJobGuid.data4[0] = (UA_Byte) guidInitL.ui32l;
-    manager->LastJobGuid.data4[1] = (UA_Byte) (guidInitL.ui32l >> 8); 
-    manager->LastJobGuid.data4[2] = (UA_Byte) (guidInitL.ui32l >> 16);
-    manager->LastJobGuid.data4[3] = (UA_Byte) (guidInitL.ui32l >> 24);
-    manager->LastJobGuid.data4[4] = (UA_Byte) (manager->LastJobGuid.data4[0]) ^ (guidInitL.ui32h);
-    manager->LastJobGuid.data4[5] = (UA_Byte) (manager->LastJobGuid.data4[0]) ^ (guidInitL.ui32h >> 8);
-    manager->LastJobGuid.data4[6] = (UA_Byte) (manager->LastJobGuid.data4[1]) ^ (guidInitL.ui32h >> 16);
-    manager->LastJobGuid.data4[7] = (UA_Byte) (manager->LastJobGuid.data4[0]) ^ (guidInitL.ui32h >> 24);
+    manager->lastJobGuid.data4[0] = (UA_Byte) guidInitL.ui32l;
+    manager->lastJobGuid.data4[1] = (UA_Byte) (guidInitL.ui32l >> 8); 
+    manager->lastJobGuid.data4[2] = (UA_Byte) (guidInitL.ui32l >> 16);
+    manager->lastJobGuid.data4[3] = (UA_Byte) (guidInitL.ui32l >> 24);
+    manager->lastJobGuid.data4[4] = (UA_Byte) (manager->lastJobGuid.data4[0]) ^ (guidInitL.ui32h);
+    manager->lastJobGuid.data4[5] = (UA_Byte) (manager->lastJobGuid.data4[0]) ^ (guidInitL.ui32h >> 8);
+    manager->lastJobGuid.data4[6] = (UA_Byte) (manager->lastJobGuid.data4[1]) ^ (guidInitL.ui32h >> 16);
+    manager->lastJobGuid.data4[7] = (UA_Byte) (manager->lastJobGuid.data4[0]) ^ (guidInitL.ui32h >> 24);
 }
 
 void SubscriptionManager_deleteMembers(UA_Session *session, UA_Server *server) {
     UA_SubscriptionManager *manager = &(session->subscriptionManager);
     UA_Subscription *current;
-    while((current = LIST_FIRST(&manager->ServerSubscriptions))) {
+    while((current = LIST_FIRST(&manager->serverSubscriptions))) {
         LIST_REMOVE(current, listEntry);
         UA_Subscription_deleteMembers(current, server);
         UA_free(current);
@@ -61,28 +61,28 @@ void SubscriptionManager_deleteMembers(UA_Session *session, UA_Server *server) {
 }
 
 void SubscriptionManager_addSubscription(UA_SubscriptionManager *manager, UA_Subscription *newSubscription) {
-    LIST_INSERT_HEAD(&manager->ServerSubscriptions, newSubscription, listEntry);
+    LIST_INSERT_HEAD(&manager->serverSubscriptions, newSubscription, listEntry);
 }
 
 UA_Subscription *SubscriptionManager_getSubscriptionByID(UA_SubscriptionManager *manager,
-                                                         UA_Int32 SubscriptionID) {
+                                                         UA_Int32 subscriptionID) {
     UA_Subscription *sub;
-    LIST_FOREACH(sub, &manager->ServerSubscriptions, listEntry) {
-        if(sub->SubscriptionID == SubscriptionID)
+    LIST_FOREACH(sub, &manager->serverSubscriptions, listEntry) {
+        if(sub->subscriptionID == subscriptionID)
             break;
     }
     return sub;
 }
 
-UA_Int32 SubscriptionManager_deleteMonitoredItem(UA_SubscriptionManager *manager, UA_Int32 SubscriptionID,
-                                                 UA_UInt32 MonitoredItemID) {
-    UA_Subscription *sub = SubscriptionManager_getSubscriptionByID(manager, SubscriptionID);
+UA_Int32 SubscriptionManager_deleteMonitoredItem(UA_SubscriptionManager *manager, UA_Int32 subscriptionID,
+                                                 UA_UInt32 monitoredItemID) {
+    UA_Subscription *sub = SubscriptionManager_getSubscriptionByID(manager, subscriptionID);
     if(!sub)
         return UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID;
     
     UA_MonitoredItem *mon;
     LIST_FOREACH(mon, &sub->MonitoredItems, listEntry) {
-        if (mon->ItemId == MonitoredItemID) {
+        if (mon->itemId == monitoredItemID) {
             // FIXME!! don't we need to remove the list entry?
             MonitoredItem_delete(mon);
             return UA_STATUSCODE_GOOD;
@@ -91,31 +91,25 @@ UA_Int32 SubscriptionManager_deleteMonitoredItem(UA_SubscriptionManager *manager
     return UA_STATUSCODE_BADMONITOREDITEMIDINVALID;
 }
 
-UA_Int32 SubscriptionManager_deleteSubscription(UA_Server *server, UA_SubscriptionManager *manager, UA_Int32 SubscriptionID) {
-    UA_Subscription *sub = SubscriptionManager_getSubscriptionByID(manager, SubscriptionID);    
+UA_Int32 SubscriptionManager_deleteSubscription(UA_Server *server, UA_SubscriptionManager *manager, UA_Int32 subscriptionID) {
+    UA_Subscription *sub = SubscriptionManager_getSubscriptionByID(manager, subscriptionID);    
     if(!sub)
         return UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID;
-
-    UA_Subscription_deleteMembers(sub, server);
-    
     LIST_REMOVE(sub, listEntry);
+    UA_Subscription_deleteMembers(sub, server);
     UA_free(sub);
     return UA_STATUSCODE_GOOD;
 } 
 
 UA_UInt32 SubscriptionManager_getUniqueUIntID(UA_SubscriptionManager *manager) {
-    UA_UInt32 id = ++(manager->LastSessionID);
+    UA_UInt32 id = ++(manager->lastSessionID);
     return id;
 }
 
 UA_Guid SubscriptionManager_getUniqueGUID(UA_SubscriptionManager *manager) {
     UA_Guid id;
-    unsigned long *incremental;
-    
-    incremental = (unsigned long *) &manager->LastJobGuid.data4[0];
+    unsigned long *incremental = (unsigned long *) &manager->lastJobGuid.data4[0];
     incremental++;
-    
-    UA_Guid_copy(&(manager->LastJobGuid), &id);
-    
+    UA_Guid_copy(&(manager->lastJobGuid), &id);
     return id;
 }

src/server/ua_subscription_manager.h

@@ -8,25 +8,25 @@
 #include "ua_subscription.h"
 
 typedef struct UA_SubscriptionManager {
-    UA_Int32_BoundedValue    GlobalPublishingInterval;
-    UA_UInt32_BoundedValue   GlobalLifeTimeCount;
-    UA_UInt32_BoundedValue   GlobalKeepAliveCount;
-    UA_Int32_BoundedValue    GlobalNotificationsPerPublish;
-    UA_UInt32_BoundedValue   GlobalSamplingInterval;
-    UA_UInt32_BoundedValue   GlobalQueueSize;
-    UA_Int32                 LastSessionID;
-    UA_Guid                  LastJobGuid;
-    LIST_HEAD(UA_ListOfUASubscriptions, UA_Subscription_s) ServerSubscriptions;
+    UA_Int32_BoundedValue globalPublishingInterval;
+    UA_UInt32_BoundedValue globalLifeTimeCount;
+    UA_UInt32_BoundedValue globalKeepAliveCount;
+    UA_Int32_BoundedValue globalNotificationsPerPublish;
+    UA_UInt32_BoundedValue globalSamplingInterval;
+    UA_UInt32_BoundedValue globalQueueSize;
+    UA_Int32 lastSessionID;
+    UA_Guid lastJobGuid;
+    LIST_HEAD(UA_ListOfUASubscriptions, UA_Subscription) serverSubscriptions;
 } UA_SubscriptionManager;
 
 void SubscriptionManager_init(UA_Session *session);
 void SubscriptionManager_deleteMembers(UA_Session *session, UA_Server *server);
 void SubscriptionManager_addSubscription(UA_SubscriptionManager *manager, UA_Subscription *subscription);
 UA_Subscription *SubscriptionManager_getSubscriptionByID(UA_SubscriptionManager *manager,
-                                                         UA_Int32 SubscriptionID);
-UA_Int32 SubscriptionManager_deleteSubscription(UA_Server *server, UA_SubscriptionManager *manager, UA_Int32 SubscriptionID);
-UA_Int32 SubscriptionManager_deleteMonitoredItem(UA_SubscriptionManager *manager, UA_Int32 SubscriptionID,
-                                                 UA_UInt32 MonitoredItemID);
+                                                         UA_Int32 subscriptionID);
+UA_Int32 SubscriptionManager_deleteSubscription(UA_Server *server, UA_SubscriptionManager *manager, UA_Int32 subscriptionID);
+UA_Int32 SubscriptionManager_deleteMonitoredItem(UA_SubscriptionManager *manager, UA_Int32 subscriptionID,
+                                                 UA_UInt32 monitoredItemID);
 
 UA_UInt32 SubscriptionManager_getUniqueUIntID(UA_SubscriptionManager *manager);
 UA_Guid SubscriptionManager_getUniqueGUID(UA_SubscriptionManager *manager);