Merge branch 'modules-next' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux

Pull module signing support from Rusty Russell:
 "module signing is the highlight, but it's an all-over David Howells frenzy..."

Hmm "Magrathea: Glacier signing key". Somebody has been reading too much HHGTTG.

* 'modules-next' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux: (37 commits)
  X.509: Fix indefinite length element skip error handling
  X.509: Convert some printk calls to pr_devel
  asymmetric keys: fix printk format warning
  MODSIGN: Fix 32-bit overflow in X.509 certificate validity date checking
  MODSIGN: Make mrproper should remove generated files.
  MODSIGN: Use utf8 strings in signer's name in autogenerated X.509 certs
  MODSIGN: Use the same digest for the autogen key sig as for the module sig
  MODSIGN: Sign modules during the build process
  MODSIGN: Provide a script for generating a key ID from an X.509 cert
  MODSIGN: Implement module signature checking
  MODSIGN: Provide module signing public keys to the kernel
  MODSIGN: Automatically generate module signing keys if missing
  MODSIGN: Provide Kconfig options
  MODSIGN: Provide gitignore and make clean rules for extra files
  MODSIGN: Add FIPS policy
  module: signature checking hook
  X.509: Add a crypto key parser for binary (DER) X.509 certificates
  MPILIB: Provide a function to read raw data into an MPI
  X.509: Add an ASN.1 decoder
  X.509: Add simple ASN.1 grammar compiler
  ...

12 files changed, 1021 insertions, 140 deletions

diff --git a/lib/.gitignore b/lib/.gitignore
index 3bef1ea94c99..09aae85418ab 100644
--- a/lib/.gitignore
+++ b/lib/.gitignore
@@ -3,4 +3,4 @@
 #
 gen_crc32table
 crc32table.h
-
+oid_registry_data.c
diff --git a/lib/Kconfig b/lib/Kconfig
index bb94c1ba616a..4b31a46fb307 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -396,4 +396,9 @@ config SIGNATURE
 config LIBFDT
         bool
 
+config OID_REGISTRY
+        tristate
+        help
+          Enable fast lookup object identifier registry.
+
 endmenu
diff --git a/lib/Makefile b/lib/Makefile
index 3128e357e286..821a16229111 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -145,6 +145,8 @@ obj-$(CONFIG_INTERVAL_TREE_TEST) += interval_tree_test.o
 
 interval_tree_test-objs := interval_tree_test_main.o interval_tree.o
 
+obj-$(CONFIG_ASN1) += asn1_decoder.o
+
 hostprogs-y     := gen_crc32table
 clean-files     := crc32table.h
 
@@ -155,3 +157,19 @@ quiet_cmd_crc32 = GEN     $@
 
 $(obj)/crc32table.h: $(obj)/gen_crc32table
         $(call cmd,crc32)
+
+#
+# Build a fast OID lookip registry from include/linux/oid_registry.h
+#
+obj-$(CONFIG_OID_REGISTRY) += oid_registry.o
+
+$(obj)/oid_registry.c: $(obj)/oid_registry_data.c
+
+$(obj)/oid_registry_data.c: $(srctree)/include/linux/oid_registry.h \
+                            $(src)/build_OID_registry
+        $(call cmd,build_OID_registry)
+
+quiet_cmd_build_OID_registry = GEN     $@
+      cmd_build_OID_registry = perl $(srctree)/$(src)/build_OID_registry $< $@
+
+clean-files     += oid_registry_data.c
diff --git a/lib/asn1_decoder.c b/lib/asn1_decoder.c
new file mode 100644
index 000000000000..de2c8b5a715b
--- /dev/null
+++ b/lib/asn1_decoder.c
@@ -0,0 +1,487 @@
+/* Decoder for ASN.1 BER/DER/CER encoded bytestream
+ *
+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#include <linux/export.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/asn1_decoder.h>
+#include <linux/asn1_ber_bytecode.h>
+
+static const unsigned char asn1_op_lengths[ASN1_OP__NR] = {
+        /*                                      OPC TAG JMP ACT */
+        [ASN1_OP_MATCH]                         = 1 + 1,
+        [ASN1_OP_MATCH_OR_SKIP]                 = 1 + 1,
+        [ASN1_OP_MATCH_ACT]                     = 1 + 1     + 1,
+        [ASN1_OP_MATCH_ACT_OR_SKIP]             = 1 + 1     + 1,
+        [ASN1_OP_MATCH_JUMP]                    = 1 + 1 + 1,
+        [ASN1_OP_MATCH_JUMP_OR_SKIP]            = 1 + 1 + 1,
+        [ASN1_OP_MATCH_ANY]                     = 1,
+        [ASN1_OP_MATCH_ANY_ACT]                 = 1         + 1,
+        [ASN1_OP_COND_MATCH_OR_SKIP]            = 1 + 1,
+        [ASN1_OP_COND_MATCH_ACT_OR_SKIP]        = 1 + 1     + 1,
+        [ASN1_OP_COND_MATCH_JUMP_OR_SKIP]       = 1 + 1 + 1,
+        [ASN1_OP_COND_MATCH_ANY]                = 1,
+        [ASN1_OP_COND_MATCH_ANY_ACT]            = 1         + 1,
+        [ASN1_OP_COND_FAIL]                     = 1,
+        [ASN1_OP_COMPLETE]                      = 1,
+        [ASN1_OP_ACT]                           = 1         + 1,
+        [ASN1_OP_RETURN]                        = 1,
+        [ASN1_OP_END_SEQ]                       = 1,
+        [ASN1_OP_END_SEQ_OF]                    = 1     + 1,
+        [ASN1_OP_END_SET]                       = 1,
+        [ASN1_OP_END_SET_OF]                    = 1     + 1,
+        [ASN1_OP_END_SEQ_ACT]                   = 1         + 1,
+        [ASN1_OP_END_SEQ_OF_ACT]                = 1     + 1 + 1,
+        [ASN1_OP_END_SET_ACT]                   = 1         + 1,
+        [ASN1_OP_END_SET_OF_ACT]                = 1     + 1 + 1,
+};
+
+/*
+ * Find the length of an indefinite length object
+ * @data: The data buffer
+ * @datalen: The end of the innermost containing element in the buffer
+ * @_dp: The data parse cursor (updated before returning)
+ * @_len: Where to return the size of the element.
+ * @_errmsg: Where to return a pointer to an error message on error
+ */
+static int asn1_find_indefinite_length(const unsigned char *data, size_t datalen,
+                                       size_t *_dp, size_t *_len,
+                                       const char **_errmsg)
+{
+        unsigned char tag, tmp;
+        size_t dp = *_dp, len, n;
+        int indef_level = 1;
+
+next_tag:
+        if (unlikely(datalen - dp < 2)) {
+                if (datalen == dp)
+                        goto missing_eoc;
+                goto data_overrun_error;
+        }
+
+        /* Extract a tag from the data */
+        tag = data[dp++];
+        if (tag == 0) {
+                /* It appears to be an EOC. */
+                if (data[dp++] != 0)
+                        goto invalid_eoc;
+                if (--indef_level <= 0) {
+                        *_len = dp - *_dp;
+                        *_dp = dp;
+                        return 0;
+                }
+                goto next_tag;
+        }
+
+        if (unlikely((tag & 0x1f) == 0x1f)) {
+                do {
+                        if (unlikely(datalen - dp < 2))
+                                goto data_overrun_error;
+                        tmp = data[dp++];
+                } while (tmp & 0x80);
+        }
+
+        /* Extract the length */
+        len = data[dp++];
+        if (len < 0x7f) {
+                dp += len;
+                goto next_tag;
+        }
+
+        if (unlikely(len == 0x80)) {
+                /* Indefinite length */
+                if (unlikely((tag & ASN1_CONS_BIT) == ASN1_PRIM << 5))
+                        goto indefinite_len_primitive;
+                indef_level++;
+                goto next_tag;
+        }
+
+        n = len - 0x80;
+        if (unlikely(n > sizeof(size_t) - 1))
+                goto length_too_long;
+        if (unlikely(n > datalen - dp))
+                goto data_overrun_error;
+        for (len = 0; n > 0; n--) {
+                len <<= 8;
+                len |= data[dp++];
+        }
+        dp += len;
+        goto next_tag;
+
+length_too_long:
+        *_errmsg = "Unsupported length";
+        goto error;
+indefinite_len_primitive:
+        *_errmsg = "Indefinite len primitive not permitted";
+        goto error;
+invalid_eoc:
+        *_errmsg = "Invalid length EOC";
+        goto error;
+data_overrun_error:
+        *_errmsg = "Data overrun error";
+        goto error;
+missing_eoc:
+        *_errmsg = "Missing EOC in indefinite len cons";
+error:
+        *_dp = dp;
+        return -1;
+}
+
+/**
+ * asn1_ber_decoder - Decoder BER/DER/CER ASN.1 according to pattern
+ * @decoder: The decoder definition (produced by asn1_compiler)
+ * @context: The caller's context (to be passed to the action functions)
+ * @data: The encoded data
+ * @datasize: The size of the encoded data
+ *
+ * Decode BER/DER/CER encoded ASN.1 data according to a bytecode pattern
+ * produced by asn1_compiler.  Action functions are called on marked tags to
+ * allow the caller to retrieve significant data.
+ *
+ * LIMITATIONS:
+ *
+ * To keep down the amount of stack used by this function, the following limits
+ * have been imposed:
+ *
+ *  (1) This won't handle datalen > 65535 without increasing the size of the
+ *      cons stack elements and length_too_long checking.
+ *
+ *  (2) The stack of constructed types is 10 deep.  If the depth of non-leaf
+ *      constructed types exceeds this, the decode will fail.
+ *
+ *  (3) The SET type (not the SET OF type) isn't really supported as tracking
+ *      what members of the set have been seen is a pain.
+ */
+int asn1_ber_decoder(const struct asn1_decoder *decoder,
+                     void *context,
+                     const unsigned char *data,
+                     size_t datalen)
+{
+        const unsigned char *machine = decoder->machine;
+        const asn1_action_t *actions = decoder->actions;
+        size_t machlen = decoder->machlen;
+        enum asn1_opcode op;
+        unsigned char tag = 0, csp = 0, jsp = 0, optag = 0, hdr = 0;
+        const char *errmsg;
+        size_t pc = 0, dp = 0, tdp = 0, len = 0;
+        int ret;
+
+        unsigned char flags = 0;
+#define FLAG_INDEFINITE_LENGTH  0x01
+#define FLAG_MATCHED            0x02
+#define FLAG_CONS               0x20 /* Corresponds to CONS bit in the opcode tag
+                                      * - ie. whether or not we are going to parse
+                                      *   a compound type.
+                                      */
+
+#define NR_CONS_STACK 10
+        unsigned short cons_dp_stack[NR_CONS_STACK];
+        unsigned short cons_datalen_stack[NR_CONS_STACK];
+        unsigned char cons_hdrlen_stack[NR_CONS_STACK];
+#define NR_JUMP_STACK 10
+        unsigned char jump_stack[NR_JUMP_STACK];
+
+        if (datalen > 65535)
+                return -EMSGSIZE;
+
+next_op:
+        pr_debug("next_op: pc=\e[32m%zu\e[m/%zu dp=\e[33m%zu\e[m/%zu C=%d J=%d\n",
+                 pc, machlen, dp, datalen, csp, jsp);
+        if (unlikely(pc >= machlen))
+                goto machine_overrun_error;
+        op = machine[pc];
+        if (unlikely(pc + asn1_op_lengths[op] > machlen))
+                goto machine_overrun_error;
+
+        /* If this command is meant to match a tag, then do that before
+         * evaluating the command.
+         */
+        if (op <= ASN1_OP__MATCHES_TAG) {
+                unsigned char tmp;
+
+                /* Skip conditional matches if possible */
+                if ((op & ASN1_OP_MATCH__COND &&
+                     flags & FLAG_MATCHED) ||
+                    dp == datalen) {
+                        pc += asn1_op_lengths[op];
+                        goto next_op;
+                }
+
+                flags = 0;
+                hdr = 2;
+
+                /* Extract a tag from the data */
+                if (unlikely(dp >= datalen - 1))
+                        goto data_overrun_error;
+                tag = data[dp++];
+                if (unlikely((tag & 0x1f) == 0x1f))
+                        goto long_tag_not_supported;
+
+                if (op & ASN1_OP_MATCH__ANY) {
+                        pr_debug("- any %02x\n", tag);
+                } else {
+                        /* Extract the tag from the machine
+                         * - Either CONS or PRIM are permitted in the data if
+                         *   CONS is not set in the op stream, otherwise CONS
+                         *   is mandatory.
+                         */
+                        optag = machine[pc + 1];
+                        flags |= optag & FLAG_CONS;
+
+                        /* Determine whether the tag matched */
+                        tmp = optag ^ tag;
+                        tmp &= ~(optag & ASN1_CONS_BIT);
+                        pr_debug("- match? %02x %02x %02x\n", tag, optag, tmp);
+                        if (tmp != 0) {
+                                /* All odd-numbered tags are MATCH_OR_SKIP. */
+                                if (op & ASN1_OP_MATCH__SKIP) {
+                                        pc += asn1_op_lengths[op];
+                                        dp--;
+                                        goto next_op;
+                                }
+                                goto tag_mismatch;
+                        }
+                }
+                flags |= FLAG_MATCHED;
+
+                len = data[dp++];
+                if (len > 0x7f) {
+                        if (unlikely(len == 0x80)) {
+                                /* Indefinite length */
+                                if (unlikely(!(tag & ASN1_CONS_BIT)))
+                                        goto indefinite_len_primitive;
+                                flags |= FLAG_INDEFINITE_LENGTH;
+                                if (unlikely(2 > datalen - dp))
+                                        goto data_overrun_error;
+                        } else {
+                                int n = len - 0x80;
+                                if (unlikely(n > 2))
+                                        goto length_too_long;
+                                if (unlikely(dp >= datalen - n))
+                                        goto data_overrun_error;
+                                hdr += n;
+                                for (len = 0; n > 0; n--) {
+                                        len <<= 8;
+                                        len |= data[dp++];
+                                }
+                                if (unlikely(len > datalen - dp))
+                                        goto data_overrun_error;
+                        }
+                }
+
+                if (flags & FLAG_CONS) {
+                        /* For expected compound forms, we stack the positions
+                         * of the start and end of the data.
+                         */
+                        if (unlikely(csp >= NR_CONS_STACK))
+                                goto cons_stack_overflow;
+                        cons_dp_stack[csp] = dp;
+                        cons_hdrlen_stack[csp] = hdr;
+                        if (!(flags & FLAG_INDEFINITE_LENGTH)) {
+                                cons_datalen_stack[csp] = datalen;
+                                datalen = dp + len;
+                        } else {
+                                cons_datalen_stack[csp] = 0;
+                        }
+                        csp++;
+                }
+
+                pr_debug("- TAG: %02x %zu%s\n",
+                         tag, len, flags & FLAG_CONS ? " CONS" : "");
+                tdp = dp;
+        }
+
+        /* Decide how to handle the operation */
+        switch (op) {
+        case ASN1_OP_MATCH_ANY_ACT:
+        case ASN1_OP_COND_MATCH_ANY_ACT:
+                ret = actions[machine[pc + 1]](context, hdr, tag, data + dp, len);
+                if (ret < 0)
+                        return ret;
+                goto skip_data;
+
+        case ASN1_OP_MATCH_ACT:
+        case ASN1_OP_MATCH_ACT_OR_SKIP:
+        case ASN1_OP_COND_MATCH_ACT_OR_SKIP:
+                ret = actions[machine[pc + 2]](context, hdr, tag, data + dp, len);
+                if (ret < 0)
+                        return ret;
+                goto skip_data;
+
+        case ASN1_OP_MATCH:
+        case ASN1_OP_MATCH_OR_SKIP:
+        case ASN1_OP_MATCH_ANY:
+        case ASN1_OP_COND_MATCH_OR_SKIP:
+        case ASN1_OP_COND_MATCH_ANY:
+        skip_data:
+                if (!(flags & FLAG_CONS)) {
+                        if (flags & FLAG_INDEFINITE_LENGTH) {
+                                ret = asn1_find_indefinite_length(
+                                        data, datalen, &dp, &len, &errmsg);
+                                if (ret < 0)
+                                        goto error;
+                        } else {
+                                dp += len;
+                        }
+                        pr_debug("- LEAF: %zu\n", len);
+                }
+                pc += asn1_op_lengths[op];
+                goto next_op;
+
+        case ASN1_OP_MATCH_JUMP:
+        case ASN1_OP_MATCH_JUMP_OR_SKIP:
+        case ASN1_OP_COND_MATCH_JUMP_OR_SKIP:
+                pr_debug("- MATCH_JUMP\n");
+                if (unlikely(jsp == NR_JUMP_STACK))
+                        goto jump_stack_overflow;
+                jump_stack[jsp++] = pc + asn1_op_lengths[op];
+                pc = machine[pc + 2];
+                goto next_op;
+
+        case ASN1_OP_COND_FAIL:
+                if (unlikely(!(flags & FLAG_MATCHED)))
+                        goto tag_mismatch;
+                pc += asn1_op_lengths[op];
+                goto next_op;
+
+        case ASN1_OP_COMPLETE:
+                if (unlikely(jsp != 0 || csp != 0)) {
+                        pr_err("ASN.1 decoder error: Stacks not empty at completion (%u, %u)\n",
+                               jsp, csp);
+                        return -EBADMSG;
+                }
+                return 0;
+
+        case ASN1_OP_END_SET:
+        case ASN1_OP_END_SET_ACT:
+                if (unlikely(!(flags & FLAG_MATCHED)))
+                        goto tag_mismatch;
+        case ASN1_OP_END_SEQ:
+        case ASN1_OP_END_SET_OF:
+        case ASN1_OP_END_SEQ_OF:
+        case ASN1_OP_END_SEQ_ACT:
+        case ASN1_OP_END_SET_OF_ACT:
+        case ASN1_OP_END_SEQ_OF_ACT:
+                if (unlikely(csp <= 0))
+                        goto cons_stack_underflow;
+                csp--;
+                tdp = cons_dp_stack[csp];
+                hdr = cons_hdrlen_stack[csp];
+                len = datalen;
+                datalen = cons_datalen_stack[csp];
+                pr_debug("- end cons t=%zu dp=%zu l=%zu/%zu\n",
+                         tdp, dp, len, datalen);
+                if (datalen == 0) {
+                        /* Indefinite length - check for the EOC. */
+                        datalen = len;
+                        if (unlikely(datalen - dp < 2))
+                                goto data_overrun_error;
+                        if (data[dp++] != 0) {
+                                if (op & ASN1_OP_END__OF) {
+                                        dp--;
+                                        csp++;
+                                        pc = machine[pc + 1];
+                                        pr_debug("- continue\n");
+                                        goto next_op;
+                                }
+                                goto missing_eoc;
+                        }
+                        if (data[dp++] != 0)
+                                goto invalid_eoc;
+                        len = dp - tdp - 2;
+                } else {
+                        if (dp < len && (op & ASN1_OP_END__OF)) {
+                                datalen = len;
+                                csp++;
+                                pc = machine[pc + 1];
+                                pr_debug("- continue\n");
+                                goto next_op;
+                        }
+                        if (dp != len)
+                                goto cons_length_error;
+                        len -= tdp;
+                        pr_debug("- cons len l=%zu d=%zu\n", len, dp - tdp);
+                }
+
+                if (op & ASN1_OP_END__ACT) {
+                        unsigned char act;
+                        if (op & ASN1_OP_END__OF)
+                                act = machine[pc + 2];
+                        else
+                                act = machine[pc + 1];
+                        ret = actions[act](context, hdr, 0, data + tdp, len);
+                }
+                pc += asn1_op_lengths[op];
+                goto next_op;
+
+        case ASN1_OP_ACT:
+                ret = actions[machine[pc + 1]](context, hdr, tag, data + tdp, len);
+                pc += asn1_op_lengths[op];
+                goto next_op;
+
+        case ASN1_OP_RETURN:
+                if (unlikely(jsp <= 0))
+                        goto jump_stack_underflow;
+                pc = jump_stack[--jsp];
+                goto next_op;
+
+        default:
+                break;
+        }
+
+        /* Shouldn't reach here */
+        pr_err("ASN.1 decoder error: Found reserved opcode (%u)\n", op);
+        return -EBADMSG;
+
+data_overrun_error:
+        errmsg = "Data overrun error";
+        goto error;
+machine_overrun_error:
+        errmsg = "Machine overrun error";
+        goto error;
+jump_stack_underflow:
+        errmsg = "Jump stack underflow";
+        goto error;
+jump_stack_overflow:
+        errmsg = "Jump stack overflow";
+        goto error;
+cons_stack_underflow:
+        errmsg = "Cons stack underflow";
+        goto error;
+cons_stack_overflow:
+        errmsg = "Cons stack overflow";
+        goto error;
+cons_length_error:
+        errmsg = "Cons length error";
+        goto error;
+missing_eoc:
+        errmsg = "Missing EOC in indefinite len cons";
+        goto error;
+invalid_eoc:
+        errmsg = "Invalid length EOC";
+        goto error;
+length_too_long:
+        errmsg = "Unsupported length";
+        goto error;
+indefinite_len_primitive:
+        errmsg = "Indefinite len primitive not permitted";
+        goto error;
+tag_mismatch:
+        errmsg = "Unexpected tag";
+        goto error;
+long_tag_not_supported:
+        errmsg = "Long tag not supported";
+error:
+        pr_debug("\nASN1: %s [m=%zu d=%zu ot=%02x t=%02x l=%zu]\n",
+                 errmsg, pc, dp, optag, tag, len);
+        return -EBADMSG;
+}
+EXPORT_SYMBOL_GPL(asn1_ber_decoder);
diff --git a/lib/build_OID_registry b/lib/build_OID_registry
new file mode 100755
index 000000000000..dfbdaab81bc8
--- /dev/null
+++ b/lib/build_OID_registry
@@ -0,0 +1,209 @@
+#!/usr/bin/perl -w
+#
+# Build a static ASN.1 Object Identified (OID) registry
+#
+# Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
+# Written by David Howells (dhowells@redhat.com)
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public Licence
+# as published by the Free Software Foundation; either version
+# 2 of the Licence, or (at your option) any later version.
+#
+
+use strict;
+
+my @names = ();
+my @oids = ();
+
+if ($#ARGV != 1) {
+    print STDERR "Format: ", $0, " <in-h-file> <out-c-file>\n";
+    exit(2);
+}
+
+#
+# Open the file to read from
+#
+open IN_FILE, "<$ARGV[0]" || die;
+while (<IN_FILE>) {
+    chomp;
+    if (m!\s+OID_([a-zA-z][a-zA-Z0-9_]+),\s+/[*]\s+([012][.0-9]*)\s+[*]/!) {
+        push @names, $1;
+        push @oids, $2;
+    }
+}
+close IN_FILE || die;
+
+#
+# Open the files to write into
+#
+open C_FILE, ">$ARGV[1]" or die;
+print C_FILE "/*\n";
+print C_FILE " * Automatically generated by ", $0, ".  Do not edit\n";
+print C_FILE " */\n";
+
+#
+# Split the data up into separate lists and also determine the lengths of the
+# encoded data arrays.
+#
+my @indices = ();
+my @lengths = ();
+my $total_length = 0;
+
+print "Compiling ", $#names + 1, " OIDs\n";
+
+for (my $i = 0; $i <= $#names; $i++) {
+    my $name = $names[$i];
+    my $oid = $oids[$i];
+
+    my @components = split(/[.]/, $oid);
+
+    # Determine the encoded length of this OID
+    my $size = $#components;
+    for (my $loop = 2; $loop <= $#components; $loop++) {
+        my $c = $components[$loop];
+
+        # We will base128 encode the number
+        my $tmp = ($c == 0) ? 0 : int(log($c)/log(2));
+        $tmp = int($tmp / 7);
+        $size += $tmp;
+    }
+    push @lengths, $size;
+    push @indices, $total_length;
+    $total_length += $size;
+}
+
+#
+# Emit the look-up-by-OID index table
+#
+print C_FILE "\n";
+if ($total_length <= 255) {
+    print C_FILE "static const unsigned char oid_index[OID__NR + 1] = {\n";
+} else {
+    print C_FILE "static const unsigned short oid_index[OID__NR + 1] = {\n";
+}
+for (my $i = 0; $i <= $#names; $i++) {
+    print C_FILE "\t[OID_", $names[$i], "] = ", $indices[$i], ",\n"
+}
+print C_FILE "\t[OID__NR] = ", $total_length, "\n";
+print C_FILE "};\n";
+
+#
+# Encode the OIDs
+#
+my @encoded_oids = ();
+
+for (my $i = 0; $i <= $#names; $i++) {
+    my @octets = ();
+
+    my @components = split(/[.]/, $oids[$i]);
+
+    push @octets, $components[0] * 40 + $components[1];
+
+    for (my $loop = 2; $loop <= $#components; $loop++) {
+        my $c = $components[$loop];
+
+        # Base128 encode the number
+        my $tmp = ($c == 0) ? 0 : int(log($c)/log(2));
+        $tmp = int($tmp / 7);
+
+        for (; $tmp > 0; $tmp--) {
+            push @octets, (($c >> $tmp * 7) & 0x7f) | 0x80;
+        }
+        push @octets, $c & 0x7f;
+    }
+
+    push @encoded_oids, \@octets;
+}
+
+#
+# Create a hash value for each OID
+#
+my @hash_values = ();
+for (my $i = 0; $i <= $#names; $i++) {
+    my @octets = @{$encoded_oids[$i]};
+
+    my $hash = $#octets;
+    foreach (@octets) {
+        $hash += $_ * 33;
+    }
+
+    $hash = ($hash >> 24) ^ ($hash >> 16) ^ ($hash >> 8) ^ ($hash);
+
+    push @hash_values, $hash & 0xff;
+}
+
+#
+# Emit the OID data
+#
+print C_FILE "\n";
+print C_FILE "static const unsigned char oid_data[", $total_length, "] = {\n";
+for (my $i = 0; $i <= $#names; $i++) {
+    my @octets = @{$encoded_oids[$i]};
+    print C_FILE "\t";
+    print C_FILE $_, ", " foreach (@octets);
+    print C_FILE "\t// ", $names[$i];
+    print C_FILE "\n";
+}
+print C_FILE "};\n";
+
+#
+# Build the search index table (ordered by length then hash then content)
+#
+my @index_table = ( 0 .. $#names );
+
+@index_table = sort {
+    my @octets_a = @{$encoded_oids[$a]};
+    my @octets_b = @{$encoded_oids[$b]};
+
+    return $hash_values[$a] <=> $hash_values[$b]
+        if ($hash_values[$a] != $hash_values[$b]);
+    return $#octets_a <=> $#octets_b
+        if ($#octets_a != $#octets_b);
+    for (my $i = $#octets_a; $i >= 0; $i--) {
+        return $octets_a[$i] <=> $octets_b[$i]
+            if ($octets_a[$i] != $octets_b[$i]);
+    }
+    return 0;
+
+} @index_table;
+
+#
+# Emit the search index and hash value table
+#
+print C_FILE "\n";
+print C_FILE "static const struct {\n";
+print C_FILE "\tunsigned char hash;\n";
+if ($#names <= 255) {
+    print C_FILE "\tenum OID oid : 8;\n";
+} else {
+    print C_FILE "\tenum OID oid : 16;\n";
+}
+print C_FILE "} oid_search_table[OID__NR] = {\n";
+for (my $i = 0; $i <= $#names; $i++) {
+    my @octets = @{$encoded_oids[$index_table[$i]]};
+    printf(C_FILE "\t[%3u] = { %3u, OID_%-35s }, // ",
+           $i,
+           $hash_values[$index_table[$i]],
+           $names[$index_table[$i]]);
+    printf C_FILE "%02x", $_ foreach (@octets);
+    print C_FILE "\n";
+}
+print C_FILE "};\n";
+
+#
+# Emit the OID debugging name table
+#
+#print C_FILE "\n";
+#print C_FILE "const char *const oid_name_table[OID__NR + 1] = {\n";
+#
+#for (my $i = 0; $i <= $#names; $i++) {
+#    print C_FILE "\t\"", $names[$i], "\",\n"
+#}
+#print C_FILE "\t\"Unknown-OID\"\n";
+#print C_FILE "};\n";
+
+#
+# Polish off
+#
+close C_FILE or die;
diff --git a/lib/mpi/Makefile b/lib/mpi/Makefile
index 45ca90a8639c..019a68c90144 100644
--- a/lib/mpi/Makefile
+++ b/lib/mpi/Makefile
@@ -14,6 +14,7 @@ mpi-y = \
         generic_mpih-add1.o             \
         mpicoder.o                      \
         mpi-bit.o                       \
+        mpi-cmp.o                       \
         mpih-cmp.o                      \
         mpih-div.o                      \
         mpih-mul.o                      \
diff --git a/lib/mpi/longlong.h b/lib/mpi/longlong.h
index 29f98624ef93..678ce4f1e124 100644
--- a/lib/mpi/longlong.h
+++ b/lib/mpi/longlong.h
@@ -19,6 +19,8 @@
  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  * MA 02111-1307, USA. */
 
+#include <asm-generic/bitops/count_zeros.h>
+
 /* You have to define the following before including this file:
  *
  * UWtype -- An unsigned type, default type for operations (typically a "word")
@@ -146,12 +148,6 @@ do { \
         : "1" ((USItype)(n1)), \
                 "r" ((USItype)(n0)), \
                 "r" ((USItype)(d)))
-
-#define count_leading_zeros(count, x) \
-        __asm__ ("clz %0,%1" \
-        : "=r" ((USItype)(count)) \
-        : "r" ((USItype)(x)))
-#define COUNT_LEADING_ZEROS_0 32
 #endif /* __a29k__ */
 
 #if defined(__alpha) && W_TYPE_SIZE == 64
@@ -298,11 +294,6 @@ extern UDItype __udiv_qrnnd();
         : "1" ((USItype)(nh)), \
                 "0" ((USItype)(nl)), \
                 "g" ((USItype)(d)))
-#define count_leading_zeros(count, x) \
-        __asm__ ("bsch/1 %1,%0" \
-        : "=g" (count) \
-        : "g" ((USItype)(x)), \
-             "0" ((USItype)0))
 #endif
 
 /***************************************
@@ -354,27 +345,6 @@ do { USItype __r; \
 } while (0)
 extern USItype __udiv_qrnnd();
 #endif /* LONGLONG_STANDALONE */
-#define count_leading_zeros(count, x) \
-do { \
-        USItype __tmp; \
-        __asm__ ( \
-        "ldi             1,%0\n" \
-        "extru,=        %1,15,16,%%r0  ; Bits 31..16 zero?\n" \
-        "extru,tr       %1,15,16,%1    ; No.  Shift down, skip add.\n" \
-        "ldo            16(%0),%0      ; Yes.   Perform add.\n" \
-        "extru,=        %1,23,8,%%r0   ; Bits 15..8 zero?\n" \
-        "extru,tr       %1,23,8,%1     ; No.  Shift down, skip add.\n" \
-        "ldo            8(%0),%0       ; Yes.   Perform add.\n" \
-        "extru,=        %1,27,4,%%r0   ; Bits 7..4 zero?\n" \
-        "extru,tr       %1,27,4,%1     ; No.  Shift down, skip add.\n" \
-        "ldo            4(%0),%0       ; Yes.   Perform add.\n" \
-        "extru,=        %1,29,2,%%r0   ; Bits 3..2 zero?\n" \
-        "extru,tr       %1,29,2,%1     ; No.  Shift down, skip add.\n" \
-        "ldo            2(%0),%0       ; Yes.   Perform add.\n" \
-        "extru          %1,30,1,%1     ; Extract bit 1.\n" \
-        "sub            %0,%1,%0       ; Subtract it.              " \
-        : "=r" (count), "=r" (__tmp) : "1" (x)); \
-} while (0)
 #endif /* hppa */
 
 /***************************************
@@ -457,15 +427,6 @@ do { \
         : "0" ((USItype)(n0)), \
              "1" ((USItype)(n1)), \
              "rm" ((USItype)(d)))
-#define count_leading_zeros(count, x) \
-do { \
-        USItype __cbtmp; \
-        __asm__ ("bsrl %1,%0" \
-        : "=r" (__cbtmp) : "rm" ((USItype)(x))); \
-        (count) = __cbtmp ^ 31; \
-} while (0)
-#define count_trailing_zeros(count, x) \
-        __asm__ ("bsfl %1,%0" : "=r" (count) : "rm" ((USItype)(x)))
 #ifndef UMUL_TIME
 #define UMUL_TIME 40
 #endif
@@ -536,15 +497,6 @@ do { \
              "dI" ((USItype)(d))); \
         (r) = __rq.__i.__l; (q) = __rq.__i.__h; \
 } while (0)
-#define count_leading_zeros(count, x) \
-do { \
-        USItype __cbtmp; \
-        __asm__ ("scanbit %1,%0" \
-        : "=r" (__cbtmp) \
-        : "r" ((USItype)(x))); \
-        (count) = __cbtmp ^ 31; \
-} while (0)
-#define COUNT_LEADING_ZEROS_0 (-32)     /* sic */
 #if defined(__i960mx)           /* what is the proper symbol to test??? */
 #define rshift_rhlc(r, h, l, c) \
 do { \
@@ -603,11 +555,6 @@ do { \
         : "0" ((USItype)(n0)), \
              "1" ((USItype)(n1)), \
              "dmi" ((USItype)(d)))
-#define count_leading_zeros(count, x) \
-        __asm__ ("bfffo %1{%b2:%b2},%0" \
-        : "=d" ((USItype)(count)) \
-        : "od" ((USItype)(x)), "n" (0))
-#define COUNT_LEADING_ZEROS_0 32
 #else /* not mc68020 */
 #define umul_ppmm(xh, xl, a, b) \
 do { USItype __umul_tmp1, __umul_tmp2; \
@@ -664,15 +611,6 @@ do { USItype __umul_tmp1, __umul_tmp2; \
              "rJ" ((USItype)(bh)), \
              "rJ" ((USItype)(al)), \
              "rJ" ((USItype)(bl)))
-#define count_leading_zeros(count, x) \
-do { \
-        USItype __cbtmp; \
-        __asm__ ("ff1 %0,%1" \
-        : "=r" (__cbtmp) \
-        : "r" ((USItype)(x))); \
-        (count) = __cbtmp ^ 31; \
-} while (0)
-#define COUNT_LEADING_ZEROS_0 63        /* sic */
 #if defined(__m88110__)
 #define umul_ppmm(wh, wl, u, v) \
 do { \
@@ -779,12 +717,6 @@ do { \
         : "0" (__xx.__ll), \
              "g" ((USItype)(d))); \
         (r) = __xx.__i.__l; (q) = __xx.__i.__h; })
-#define count_trailing_zeros(count, x) \
-do { \
-        __asm__("ffsd      %2,%0" \
-        : "=r"((USItype) (count)) \
-        : "0"((USItype) 0), "r"((USItype) (x))); \
-        } while (0)
 #endif /* __ns32000__ */
 
 /***************************************
@@ -855,11 +787,6 @@ do { \
                 "rI" ((USItype)(al)), \
                 "r" ((USItype)(bl))); \
 } while (0)
-#define count_leading_zeros(count, x) \
-        __asm__ ("{cntlz|cntlzw} %0,%1" \
-        : "=r" ((USItype)(count)) \
-        : "r" ((USItype)(x)))
-#define COUNT_LEADING_ZEROS_0 32
 #if defined(_ARCH_PPC)
 #define umul_ppmm(ph, pl, m0, m1) \
 do { \
@@ -1001,19 +928,6 @@ do { \
 } while (0)
 #define UMUL_TIME 20
 #define UDIV_TIME 200
-#define count_leading_zeros(count, x) \
-do { \
-        if ((x) >= 0x10000) \
-                __asm__ ("clz     %0,%1" \
-                : "=r" ((USItype)(count)) \
-                : "r" ((USItype)(x) >> 16)); \
-        else { \
-                __asm__ ("clz   %0,%1" \
-                : "=r" ((USItype)(count)) \
-                : "r" ((USItype)(x))); \
-                (count) += 16; \
-        } \
-} while (0)
 #endif /* RT/ROMP */
 
 /***************************************
@@ -1142,13 +1056,6 @@ do { \
         "rI" ((USItype)(d)) \
         : "%g1" __AND_CLOBBER_CC)
 #define UDIV_TIME 37
-#define count_leading_zeros(count, x) \
-        __asm__ ("scan %1,0,%0" \
-        : "=r" ((USItype)(x)) \
-        : "r" ((USItype)(count)))
-/* Early sparclites return 63 for an argument of 0, but they warn that future
-        implementations might change this.  Therefore, leave COUNT_LEADING_ZEROS_0
-        undefined.  */
 #endif /* __sparclite__ */
 #endif /* __sparc_v8__ */
         /* Default to sparc v7 versions of umul_ppmm and udiv_qrnnd.  */
@@ -1454,47 +1361,6 @@ do { \
 #define udiv_qrnnd __udiv_qrnnd_c
 #endif
 
-#undef count_leading_zeros
-#if !defined(count_leading_zeros)
-        extern
-#ifdef __STDC__
-                        const
-#endif
-                        unsigned char __clz_tab[];
-#define count_leading_zeros(count, x) \
-do { \
-        UWtype __xr = (x); \
-        UWtype __a; \
-        \
-        if (W_TYPE_SIZE <= 32) { \
-                __a = __xr < ((UWtype) 1 << 2*__BITS4) \
-                ? (__xr < ((UWtype) 1 << __BITS4) ? 0 : __BITS4) \
-                : (__xr < ((UWtype) 1 << 3*__BITS4) ?  2*__BITS4 : 3*__BITS4); \
-        } \
-        else { \
-                for (__a = W_TYPE_SIZE - 8; __a > 0; __a -= 8) \
-                        if (((__xr >> __a) & 0xff) != 0) \
-                                break; \
-        } \
-        \
-        (count) = W_TYPE_SIZE - (__clz_tab[__xr >> __a] + __a); \
-} while (0)
-        /* This version gives a well-defined value for zero. */
-#define COUNT_LEADING_ZEROS_0 W_TYPE_SIZE
-#endif
-
-#if !defined(count_trailing_zeros)
-/* Define count_trailing_zeros using count_leading_zeros.  The latter might be
-        defined in asm, but if it is not, the C version above is good enough.  */
-#define count_trailing_zeros(count, x) \
-do { \
-        UWtype __ctz_x = (x); \
-        UWtype __ctz_c; \
-        count_leading_zeros(__ctz_c, __ctz_x & -__ctz_x); \
-        (count) = W_TYPE_SIZE - 1 - __ctz_c; \
-} while (0)
-#endif
-
 #ifndef UDIV_NEEDS_NORMALIZATION
 #define UDIV_NEEDS_NORMALIZATION 0
 #endif
diff --git a/lib/mpi/mpi-bit.c b/lib/mpi/mpi-bit.c
index 568724804f29..503537e08436 100644
--- a/lib/mpi/mpi-bit.c
+++ b/lib/mpi/mpi-bit.c
@@ -45,7 +45,7 @@ unsigned mpi_get_nbits(MPI a)
         if (a->nlimbs) {
                 mpi_limb_t alimb = a->d[a->nlimbs - 1];
                 if (alimb)
-                        count_leading_zeros(n, alimb);
+                        n = count_leading_zeros(alimb);
                 else
                         n = BITS_PER_MPI_LIMB;
                 n = BITS_PER_MPI_LIMB - n + (a->nlimbs - 1) * BITS_PER_MPI_LIMB;
diff --git a/lib/mpi/mpi-cmp.c b/lib/mpi/mpi-cmp.c
new file mode 100644
index 000000000000..1871e7b61ca0
--- /dev/null
+++ b/lib/mpi/mpi-cmp.c
@@ -0,0 +1,70 @@
+/* mpi-cmp.c  -  MPI functions
+ * Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include "mpi-internal.h"
+
+int mpi_cmp_ui(MPI u, unsigned long v)
+{
+        mpi_limb_t limb = v;
+
+        mpi_normalize(u);
+        if (!u->nlimbs && !limb)
+                return 0;
+        if (u->sign)
+                return -1;
+        if (u->nlimbs > 1)
+                return 1;
+
+        if (u->d[0] == limb)
+                return 0;
+        else if (u->d[0] > limb)
+                return 1;
+        else
+                return -1;
+}
+EXPORT_SYMBOL_GPL(mpi_cmp_ui);
+
+int mpi_cmp(MPI u, MPI v)
+{
+        mpi_size_t usize, vsize;
+        int cmp;
+
+        mpi_normalize(u);
+        mpi_normalize(v);
+        usize = u->nlimbs;
+        vsize = v->nlimbs;
+        if (!u->sign && v->sign)
+                return 1;
+        if (u->sign && !v->sign)
+                return -1;
+        if (usize != vsize && !u->sign && !v->sign)
+                return usize - vsize;
+        if (usize != vsize && u->sign && v->sign)
+                return vsize + usize;
+        if (!usize)
+                return 0;
+        cmp = mpihelp_cmp(u->d, v->d, usize);
+        if (!cmp)
+                return 0;
+        if ((cmp < 0 ? 1 : 0) == (u->sign ? 1 : 0))
+                return 1;
+        return -1;
+}
+EXPORT_SYMBOL_GPL(mpi_cmp);
diff --git a/lib/mpi/mpi-pow.c b/lib/mpi/mpi-pow.c
index 67f3e79af914..5464c8744ea9 100644
--- a/lib/mpi/mpi-pow.c
+++ b/lib/mpi/mpi-pow.c
@@ -77,7 +77,7 @@ int mpi_powm(MPI res, MPI base, MPI exp, MPI mod)
         mp = mp_marker = mpi_alloc_limb_space(msize);
         if (!mp)
                 goto enomem;
-        count_leading_zeros(mod_shift_cnt, mod->d[msize - 1]);
+        mod_shift_cnt = count_leading_zeros(mod->d[msize - 1]);
         if (mod_shift_cnt)
                 mpihelp_lshift(mp, mod->d, msize, mod_shift_cnt);
         else
@@ -169,7 +169,7 @@ int mpi_powm(MPI res, MPI base, MPI exp, MPI mod)
 
                 i = esize - 1;
                 e = ep[i];
-                count_leading_zeros(c, e);
+                c = count_leading_zeros(e);
                 e = (e << c) << 1;      /* shift the exp bits to the left, lose msb */
                 c = BITS_PER_MPI_LIMB - 1 - c;
 
diff --git a/lib/mpi/mpicoder.c b/lib/mpi/mpicoder.c
index f0fa65995800..3962b7f7fe3f 100644
--- a/lib/mpi/mpicoder.c
+++ b/lib/mpi/mpicoder.c
@@ -18,10 +18,65 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
+#include <linux/bitops.h>
+#include <asm-generic/bitops/count_zeros.h>
 #include "mpi-internal.h"
 
 #define MAX_EXTERN_MPI_BITS 16384
 
+/**
+ * mpi_read_raw_data - Read a raw byte stream as a positive integer
+ * @xbuffer: The data to read
+ * @nbytes: The amount of data to read
+ */
+MPI mpi_read_raw_data(const void *xbuffer, size_t nbytes)
+{
+        const uint8_t *buffer = xbuffer;
+        int i, j;
+        unsigned nbits, nlimbs;
+        mpi_limb_t a;
+        MPI val = NULL;
+
+        while (nbytes >= 0 && buffer[0] == 0) {
+                buffer++;
+                nbytes--;
+        }
+
+        nbits = nbytes * 8;
+        if (nbits > MAX_EXTERN_MPI_BITS) {
+                pr_info("MPI: mpi too large (%u bits)\n", nbits);
+                return NULL;
+        }
+        if (nbytes > 0)
+                nbits -= count_leading_zeros(buffer[0]);
+        else
+                nbits = 0;
+
+        nlimbs = (nbytes + BYTES_PER_MPI_LIMB - 1) / BYTES_PER_MPI_LIMB;
+        val = mpi_alloc(nlimbs);
+        if (!val)
+                return NULL;
+        val->nbits = nbits;
+        val->sign = 0;
+        val->nlimbs = nlimbs;
+
+        if (nbytes > 0) {
+                i = BYTES_PER_MPI_LIMB - nbytes % BYTES_PER_MPI_LIMB;
+                i %= BYTES_PER_MPI_LIMB;
+                for (j = nlimbs; j > 0; j--) {
+                        a = 0;
+                        for (; i < BYTES_PER_MPI_LIMB; i++) {
+                                a <<= 8;
+                                a |= *buffer++;
+                        }
+                        i = 0;
+                        val->d[j - 1] = a;
+                }
+        }
+        return val;
+}
+EXPORT_SYMBOL_GPL(mpi_read_raw_data);
+
 MPI mpi_read_from_buffer(const void *xbuffer, unsigned *ret_nread)
 {
         const uint8_t *buffer = xbuffer;
diff --git a/lib/oid_registry.c b/lib/oid_registry.c
new file mode 100644
index 000000000000..d8de11f45908
--- /dev/null
+++ b/lib/oid_registry.c
@@ -0,0 +1,170 @@
+/* ASN.1 Object identifier (OID) registry
+ *
+ * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#include <linux/export.h>
+#include <linux/oid_registry.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/bug.h>
+#include "oid_registry_data.c"
+
+/**
+ * look_up_OID - Find an OID registration for the specified data
+ * @data: Binary representation of the OID
+ * @datasize: Size of the binary representation
+ */
+enum OID look_up_OID(const void *data, size_t datasize)
+{
+        const unsigned char *octets = data;
+        enum OID oid;
+        unsigned char xhash;
+        unsigned i, j, k, hash;
+        size_t len;
+
+        /* Hash the OID data */
+        hash = datasize - 1;
+
+        for (i = 0; i < datasize; i++)
+                hash += octets[i] * 33;
+        hash = (hash >> 24) ^ (hash >> 16) ^ (hash >> 8) ^ hash;
+        hash &= 0xff;
+
+        /* Binary search the OID registry.  OIDs are stored in ascending order
+         * of hash value then ascending order of size and then in ascending
+         * order of reverse value.
+         */
+        i = 0;
+        k = OID__NR;
+        while (i < k) {
+                j = (i + k) / 2;
+
+                xhash = oid_search_table[j].hash;
+                if (xhash > hash) {
+                        k = j;
+                        continue;
+                }
+                if (xhash < hash) {
+                        i = j + 1;
+                        continue;
+                }
+
+                oid = oid_search_table[j].oid;
+                len = oid_index[oid + 1] - oid_index[oid];
+                if (len > datasize) {
+                        k = j;
+                        continue;
+                }
+                if (len < datasize) {
+                        i = j + 1;
+                        continue;
+                }
+
+                /* Variation is most likely to be at the tail end of the
+                 * OID, so do the comparison in reverse.
+                 */
+                while (len > 0) {
+                        unsigned char a = oid_data[oid_index[oid] + --len];
+                        unsigned char b = octets[len];
+                        if (a > b) {
+                                k = j;
+                                goto next;
+                        }
+                        if (a < b) {
+                                i = j + 1;
+                                goto next;
+                        }
+                }
+                return oid;
+        next:
+                ;
+        }
+
+        return OID__NR;
+}
+EXPORT_SYMBOL_GPL(look_up_OID);
+
+/*
+ * sprint_OID - Print an Object Identifier into a buffer
+ * @data: The encoded OID to print
+ * @datasize: The size of the encoded OID
+ * @buffer: The buffer to render into
+ * @bufsize: The size of the buffer
+ *
+ * The OID is rendered into the buffer in "a.b.c.d" format and the number of
+ * bytes is returned.  -EBADMSG is returned if the data could not be intepreted
+ * and -ENOBUFS if the buffer was too small.
+ */
+int sprint_oid(const void *data, size_t datasize, char *buffer, size_t bufsize)
+{
+        const unsigned char *v = data, *end = v + datasize;
+        unsigned long num;
+        unsigned char n;
+        size_t ret;
+        int count;
+
+        if (v >= end)
+                return -EBADMSG;
+
+        n = *v++;
+        ret = count = snprintf(buffer, bufsize, "%u.%u", n / 40, n % 40);
+        buffer += count;
+        bufsize -= count;
+        if (bufsize == 0)
+                return -ENOBUFS;
+
+        while (v < end) {
+                num = 0;
+                n = *v++;
+                if (!(n & 0x80)) {
+                        num = n;
+                } else {
+                        num = n & 0x7f;
+                        do {
+                                if (v >= end)
+                                        return -EBADMSG;
+                                n = *v++;
+                                num <<= 7;
+                                num |= n & 0x7f;
+                        } while (n & 0x80);
+                }
+                ret += count = snprintf(buffer, bufsize, ".%lu", num);
+                buffer += count;
+                bufsize -= count;
+                if (bufsize == 0)
+                        return -ENOBUFS;
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(sprint_oid);
+
+/**
+ * sprint_OID - Print an Object Identifier into a buffer
+ * @oid: The OID to print
+ * @buffer: The buffer to render into
+ * @bufsize: The size of the buffer
+ *
+ * The OID is rendered into the buffer in "a.b.c.d" format and the number of
+ * bytes is returned.
+ */
+int sprint_OID(enum OID oid, char *buffer, size_t bufsize)
+{
+        int ret;
+
+        BUG_ON(oid >= OID__NR);
+
+        ret = sprint_oid(oid_data + oid_index[oid],
+                         oid_index[oid + 1] - oid_index[oid],
+                         buffer, bufsize);
+        BUG_ON(ret == -EBADMSG);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(sprint_OID);