It certainly is looking that way, but there is the whole notion that what amount to call tables can be copyrighted. What the supreme Court has done here is basically unravel the common understanding of the difference between spec and implementation, and if Java is the most obviously vulnerable, in a very real way it means any number of APIs that have been re-implemented (like the standard *nix set of system calls) could suddenly be plunged into a purgatory-like nether world. I made vulgar jokes about using stdio.h in C programs, but that's the real question.
There is actually a big difference between the APIs from Java, and the System Calls; for Java you have to write an interface at the language level that matches up, for System Calls you do not - it's processor specifications that must match up, and those are covered by the processor vendor, not the system call creator. This is where the a language like Java fails.
In System Calls it doesn't matter what you call the function, it's parameters, etc - just that it matches the processor call stack sufficiently for the request to be transferred - which is typically an OS-level issue and a compiler issue, not your code.
So, you try to extend this to Linux vs Unix Sys7...and that's where it the fact that the function names and parameter names need not match makes it obvious that there is no issue here because they are not per se copyrighted, like they have to be with Java.
Suffice it to say, Linux out to be safe.
Considering that in many cases header files and libraries whose origins go back decades in many different languages and on many different architectures could become low-hanging fruit, and since copyrights are in most industrialized countries are essentially perpetual now, big software houses now have a far better club to beat competitors with than patents.
Do you think another Samba or Wine project could happen if the lower courts rule for Oracle? Who would be crazy enough to even try?
Coming to a different question: Does implementing a library sufficiently the same that the linker generates a matching symbol mean there is a copyright violation?
Not likely. There is an extreme amount of precedent for those being fair-use, and "interoperability" is an explicitly called out exemption by law (IANAL, go talk to one). This also easily applies to network interfaces.
The question comes down to: did you copy anything to make it work?
Again, a language like Java where the code structure and names must be sufficiently the same to make it work you'll have an issue, and it'll be harder to show "fair-use" even if "fair-use" applies; versus a language like C where you just need to tell the compiler how to match up the symbols to get it done - in some cases you can even specify to the compiler/linker that symbol A is really symbol B so if you have a list of the symbols you know, you can have other symbols of your own and let the linker take care of the mangling for you (no so in Java).
I expect Google will win in the end on "fair-use" since the language specifications so heavily require it to be the same for interoperability, and they have a strong case for interoperability which, as I said earlier, is explicitly called out under "fair-use" and "reverse engineering" exceptions to copyright law.