This is Copyright 1983 Microsoft – NOT!

If you look at a hexdump of any version of the Logitech mouse driver for MS-DOS, you will see the following:

*** This is Copyright 1983 Microsoft ***

000007c0                                       2a 2a 2a 20  |            *** |
000007d0  54 68 69 73 20 69 73 20  43 6f 70 79 72 69 67 68  |This is Copyrigh|
000007e0  74 20 31 39 38 33 20 4d  69 63 72 6f 73 6f 66 74  |t 1983 Microsoft|
000007f0  20 2a 2a 2a                                       | ***            |

Microsoft introduced the mouse to MS-DOS, and they specified the mouse driver interface and implemented the first MS-DOS mouse driver. Did Logitech license their code? Or did they steal it? Let’s look closer:

This is a LOGITECH mouse driver, but some software expect here the following string:*** This is Copyright 1983 Microsoft ***

00000770                           54 68 69 73 20 69 73 20  |        This is |
00000780  61 20 4c 4f 47 49 54 45  43 48 20 6d 6f 75 73 65  |a LOGITECH mouse|
00000790  20 64 72 69 76 65 72 2c  20 62 75 74 20 73 6f 6d  | driver, but som|
000007a0  65 20 73 6f 66 74 77 61  72 65 20 65 78 70 65 63  |e software expec|
000007b0  74 20 68 65 72 65 20 74  68 65 20 66 6f 6c 6c 6f  |t here the follo|
000007c0  77 69 6e 67 20 73 74 72  69 6e 67 3a 2a 2a 2a 20  |wing string:*** |
000007d0  54 68 69 73 20 69 73 20  43 6f 70 79 72 69 67 68  |This is Copyrigh|
000007e0  74 20 31 39 38 33 20 4d  69 63 72 6f 73 6f 66 74  |t 1983 Microsoft|
000007f0  20 2a 2a 2a                                       | ***            |

This string is located directly before the INT 0x33 API entry point, so it is easy to check for it. There’s a sucker born every minute, but this still makes you wonder what kind of programmer would really check for a string like this, even if some Microsoft API reference indeed suggested to do so. Maybe it was only Microsoft software to compare the string.

In either case, this is a very bad and unfair practice. If you define an interface, don’t add a call to ask for the version (or even the vendor!), but add feature bits instead, so that an alternative implementation can choose to be compatible with parts of it (or extend the interface independently). And if you are a developer that uses an interface, use feature bits if they are there, and resist the temptation to check for the vendor, even if the API documentation tells you to do so.

6 thoughts on “This is Copyright 1983 Microsoft – NOT!”

  1. I remember noticing that too back in the time. Though I couldn’t find out what program would actually check this sting. Now that I think about it, I probably should have tried and replaced that string to see which program breaks. Probably MS Windows (they did some crazy dos version checking there, too)


  2. Similarly, in the depths of reverse engineering time it was decided that PC BIOSes had to have the string “IBM” starting at 0xfe00e (so that you could tell you were running on IBM PC compatible hardware and not just some random MS-DOS platform). I think in the original IBM BIOS this was part of IBM’s copyright message as well, but in others it usually ends up just being “IBM” or “IBM compatible”. Something similar also occurs in EGA/VGA card BIOSes. I am occasionally amused when I find someone has gotten more creative in working the word “IBM” into a string there.

  3. Possibly Microsoft being evil. But int calls are pretty horrible when you get a conflict. I think some other software used 33h too & at least if you got a copyright string from Microsoft then you could be reasonably sure you were talking to what you thought you were.

  4. I used to support Banyan VINES for a living. Their DOS client drivers could be configured to hook one of a range of DOS interrupts (INT 0x60 to 0x66, I think), to prevent interrupt clashes with other systems. With early versions of the software the only way to determine which interrupt was being used was to look for the string BANV inside each relevant interrupt handler. Later drivers added an INT 0x2F call to return the actual interrupt to use.

  5. Sometimes a vendor’s assembler or compiler would automatically inject functionless strings into the executable code. By way of license agreement, if you used that vendor’s compiler, the binary output was still copyrighted by the vendor since they generated it, but you had a royalty free license to distribute it. MS and Borland do this for a fact.

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.