Simpler License Delivery with Push Updates

As of version 6.70, CodeMeter can now create Modified Context Files (*.WibuCmRaM) and combine Remote Update Files (*.WibuCmRaU) for Universal Firm Codes. This sounds like a secondary technical change, but it is indeed one of the marquee features when it comes to using CodeMeter in the field. This deceptively minor feature allows CodeMeter License Central to cover two new use cases: Delivering licenses without new Remote Context Files (*.WibuCmRaC) and delivering licenses when the Remote Context File is outdated.

Updating Licenses 101

A few weeks ago, I was invited to a medical device maker who is not yet using CodeMeter. The system currently used by the company works by sending the user a new USB dongle whenever he buys a new feature. If a user pays for two new features, he will receive two new dongles. One feature, one dongle, even if the user buys features in bulk.

This makes it easy for SAP, because the preprogrammed dongles can be delivered as usual. However, the approach does not scale easily, can be quite slow, and simply feels old-fashioned; for this medical device maker, cloud licensing was not an option, because not all of the devices were actually connected to the Internet.

CodeMeter comes with remote programming capabilities on board, based on a file exchange system. The actual licenses are kept on hardware-based CmDongles or in software-based CmActLicenses and can be used without an active Internet connection. To change anything about a license, a Context File needs to come back from the user to you, the ISV. You then create an Update File, which can get to the user through various, even offline channels. This file changes or removes licenses or adds new ones: Exactly as you need it.

You Only Update Once

Update Files are incremental updates, that is, each builds on the update that has gone before. This means that the chain of updates cannot have a single link missing or added at the wrong time. There are also two other important security features: Every Update File can only be used with the PC or CmDongle that sent the original request. And every Update File can only be used once. This is important for incremental updates, in particular, because a user could otherwise get only one legitimate update and use it multiple times without license to do so. The solution is simple, but restrictive: It all works with one current Context File sent to you by the user. At least, that used to be the case before CodeMeter 6.70.

Online – Offline No Longer Separate

With CodeMeter License Central, you have a cloud-based solution for creating, delivering, and managing licenses with unparalleled comfort. You give your user a ticket that he can use either in your software or in a dedicated license portal like WebDepot. If your user is online, the Context File is created automatically and sent to CodeMeter License Central, which generates an Update File with the licenses defined for the ticket. The system sends that file back to the software or license portal, where the update is imported and a receipt returned to CodeMeter License Central in the form of a Context File.

Back to our manufacturer who does not yet have CodeMeter on all of his devices. The online capabilities of the CodeMeter License Central cloud solution would make it easy to manage the licenses for all devices connected online. But what about offline devices? In this case, WebDepot allows you to upload the Context File and download the matching Update File; in most cases, the receipt, as the third link in that chain, is optional and can be skipped. For our medical device maker, this was still too unwieldy a process. Let us see how easy we can make it for him.

Before the First Update

It all begins with your delivery of software or hardware to your user. This normally goes with the purchase of a device or a license, but it could also be done for trial purchases. We can imagine three common scenarios:

1. You deliver your own hardware with an initial configuration of the required licenses, either a demo license, a basic version, or even just an empty container. The container can come in the form of a CmActLicense or a CmDongle.
2. You deliver a CmDongle with a preconfigured license for your user.
3. You send your user a ticket via CodeMeter License Central, which he can use for a CmActLicense or existing CmDongle (with multi-vendor capabilities) on his target device.

In the first two cases, you have the CmContainer with you before its delivery. This is an ideal opportunity to save a matching Context File for each container.

In the last case - the activation on a new device or in an already active CmDongle - the established process would have the user send a fingerprint of this device or dongle to you to get the license in return.

The Very First Update

After the initial license has been created, you kept a Context File, which you can now use for the first update. In this case, the user does not have to send in the new file, and you deliver the first update by push update instead. Either you or your user simply selects the serial number of the CmContainer that the licenses should go into.

CodeMeter License Central automates this job for you, saving Context Files and Update Files and managing which user goes with which CmContainer.

The Second and All Other Updates

This is the crux of the matter: We would need a new Context File for the next update, which we don’t have. Enter the Modified Context File as the hero of our story: CodeMeter creates a Modified Context File alongside the Update File in the last step. This is the stand-in for the Context File that the user would normally send you, and you can use it now to create push updates for your users without needing anything in return from them. With each update, a new Modified Context File is created for the next update.

From version 3.21, CodeMeter License Central does all of this automatically for you. You select the serial number of the CmContainer under ‘Push Update’ and download the Update File, or you integrate the same function in your license portal for your users to do this themselves.

Missed an Update?

But wait! What happens if a user forgets to install an update, or if the update never arrived in the first place? No need to worry: Update Files are made to join up. CodeMeter License Central knows exactly which updates were initiated with a Context File by being notified either by a separate receipt or automatically with the new update. Any update that was not confirmed yet is automatically integrated into the newest Update File for the CmContainer in question. And now for the best part: CodeMeter Runtime will automatically detect which updates have already been installed and skips them. After the new update, the user will be up to speed with whatever happened or did not happen before.

Everything Automatic

This makes the entire process just as easy for our medical device maker as it used to be with simple dongles. The manufacturer only needs to distribute the Update File that gets everything in order on the client’s machine by itself. All the user needs is a dongle or, in the case of CmActLicenses, not even that. Everything is delivered instantly.

One question remains: “What happens if we use the standard path, and a user picks an old Context File by mistake?” Short answer: “It doesn't matter, the update will be handled properly.” Longer answer: “CodeMeter License Central has a state counter, the so-called Firm Update Counter, that recognizes that an old file was selected. If it has not happened yet, the process automatically checks off all older updates. The current Modified Context File is then selected, and the update created, with all remaining updates included in the Update File.”

Returning Licenses

Our medical device ISV had one last question in store: “Can you return licenses via push update as well?” I had to ask a counter-question, even though I already knew the answer: “You mean if your users are returning, or you withdrawing the license?” Of course, both works just as well.

The user will typically return licenses e.g. in order to move to another device. This can then also be done by push update. A new Context File is needed once to confirm the returned license, and the next activation on the next device can again work by push update.

As an ISV, you can also withdraw licenses, which can again be done by push update. If you want to make sure that the recall worked, you can request a receipt in the form of a Context File, but even if you never received the receipt, the user could not skip the push update with the license withdrawal: it will be enforced automatically with the next license update for the CmContainer in question. It is virtually impossible for users to go into hiding and avoid withdrawals, which is helpful for subscription or pay-per-use licenses, in particular.

Conclusions

With push updates, distributing licenses is easy work, especially for offline scenarios. CodeMeter License Central makes sure that the user will always be up to date, even if he skipped some updates in between. Just like our medical device maker, you – the ISV – can sit back and rely on the automatic features of CodeMeter to do the heavy work for you.

 

KEYnote 36 – Edition Fall 2018