Historically, the Developer Certificate of Origin originally adopted by the Linux Kernel in 2005 has seen widespread use within a large variety of Open Source projects. The DCO is designed to replace a Contributor Licence Agreement with a simple Signed-off-by attestation which is placed into the commit message of the source repository itself, thus meaning that all the necessary DCO attestations are automatically available to anyone who downloads the source code repository. It also allows (again, through the use of a strong source control system) the identification of who changed any given line of code within the source tree and all their DCO signoffs.
The legal basis of the DCO is that it is an attestation by an individual developer that they have sufficient rights in the contribution to submit it under the project (or file) licence.
The DCO and Corporate Contributions
In certain jurisdictions, particularly the United States of America, when you work as a software developer for a Corporation, they actually own, exclusively, the copyright of any source code you produce under something called the Work for Hire doctrine. So the question naturally arises: if the developer who makes the Signed-off-by attestation doesn’t actually own any rights in the code, how is that attestation valid and how does the rights owning entity (the corporation) actually license the code correctly to make the contribution?
The answer to that question resides in something called the theory of agency. Agency is the mechanism by which individuals give effect to actions of a corporation. For example, being a nebulous entity with no actual arms or legs, a corporation cannot itself sign any documents. Thus, when a salesman signs a contract to supply widgets on behalf of a corporation, he is acting as the agent of that corporation. His signature on the sales contract becomes binding on the corporation as if the corporation itself had made it. However, there’s a problem here: how does the person who paid for and is expecting the delivery of widgets know that the sales person is actually authorised to be an agent of the corporation? The answer here is again in the theory of agency: as long as the person receiving the widgets had reasonable cause to think that the salesperson signing the contract is acting as an agent of the corporation. Usually all that’s required is that the company gave the salesperson a business card and a title which would make someone think they were authorised to sign contracts (such as “Sales Manager”).
Thus, the same thing applies to developers submitting patches on behalf of a corporation. They become agents of that corporation when making DCO attestations and thus, even if the contribution is a work for hire and the copyright owned by the corporation, the DCO attestation the developer makes is still binding on the corporation.
Email addresses matter
Under the theory of agency, it’s not sufficient to state “I am an agent”, there must be some sign on behalf of the corporation that they’re granting agency (in the case of the salesperson, it was a business card and checkable title). For developers making contributions with a Signed-off-by, the best indication of agency is to do the signoff using a corporate email address. For this reason, the Linux kernel has adopted the habit of not accepting controversial patches without a corporate signoff.
Patents and the DCO
The Linux Kernel uses GPLv2 as its licence. GPLv2 is solely a copyright licence and has nothing really to say about patents, except that if you assert against the project, you lose your right to distribute under GPLv2. This is what is termed an implied patent licence, but it means that the DCO signoff for GPLv2 only concerns copyrights. However, there are many open source licences (like Apache-2 or GPLv3) which require explicit patent grants as well as copyright ones, so can the DCO give all the necessary rights, including patent ones, to make the contribution on behalf of the corporation? The common sense answer, which is if the developer is accepted as an agent for copyright, they should also be an agent for patent grants, isn’t as universally accepted as you might think.
The OpenStack problem
OpenStack has been trying for years to drop its complex contributor licence infrastructure in favour of a simple DCO attestation. Most recently, the Technical Committee made that request of the board in 2014 and it was finally granted in a limited fashion on November 2015. The recommendation of the OpenStack counsel was accepted and the DCO was adopted for individuals only, keeping the contributor licence agreements for corporations. The given reason for this is that the corporate members of OpenStack want more assurance that corporations are correctly granting their patents in their contributions than they believe the DCO gives (conversely, individuals aren’t expected to have any patents, so, for them, the DCO applies just fine since it’s effectively only a copyright attestation they’re giving).
Why are Patents such an Issue?
Or why do lots of people think developers aren’t agents for patents in contributions unlike for copyrights? The essential argument (as shown here) is that corporations as a matter of practise, do not allow developers (or anyone else except specific title holders) to be agents for patent transactions and thus there should not be an expectation, even when they make a DCO attestation using a corporate email signoff, that they are.
One way to look at this is that corporations have no choice but to make developers agents for the copyright because without that, the DCO attestation is false since the developers themselves has no rights to a work for hire piece of code. However, some corporations think they can get away with not making developers agents for patents because the contribution and the licence do not require this to happen. The theory here is that the developer is making an agency grant for the copyright, but an individual grant of the patents (and, since developers don’t usually own patents, that’s no grant at all). Effectively this is a get out of jail free card for corporations to cheat on the patent requirements of the licence.
Does this interpretation really hold water? Well, I don’t think so, because it’s deceptive. It’s deliberately trying to evade the responsibilities for patents that the licences require. Usually under the theory of agency, deceptive practises are barred. However, the fear that a court might be induced to accept this viewpoint is sufficient to get the OpenStack board to require that corporations sign a CLA to ensure that patents are well and truly bound. The problem with this viewpoint is that, if it becomes common enough, it ends up being de facto what the legal situation actually is (because the question courts most often ask in cases about agency is what would the average person think, so a practise that becomes standard in the industry ipso facto becomes what the average reasonable person would think). Effectively therefore, the very act of OpenStack acting on its fear causes the thing they fear eventually to become true. The only way to reverse this now is to change the current state of how the industry views patents and the DCO … and that will be the subject of another post.