"When software publishers talk about “enforcing” their “rights” or “stopping piracy”, what they actually say is secondary. The real message of these statements is in the unstated assumptions they take for granted; the public is supposed to accept them uncritically. So let's examine them.
One assumption is that software companies have an unquestionable natural right to own software and thus have power over all its users. (If this were a natural right, then no matter how much harm it does to the public, we could not object.) Interestingly, the US Constitution and legal tradition reject this view; copyright is not a natural right, but an artificial government-imposed monopoly that limits the users' natural right to copy.
Another unstated assumption is that the only important thing about software is what jobs it allows you to do—that we computer users should not care what kind of society we are allowed to have.
A third assumption is that we would have no usable software (or would never have a program to do this or that particular job) if we did not offer a company power over the users of the program. This assumption may have seemed plausible, before the free software movement demonstrated that we can make plenty of useful software without putting chains on it.
If we decline to accept these assumptions, and judge these issues based on ordinary common-sense morality while placing the users first, we arrive at very different conclusions. Computer users should be free to modify programs to fit their needs, and free to share software, because helping other people is the basis of society." -- R.M. Stallman, About the Gnu Project: http://www.gnu.org/gnu/thegnuproject.html
Software piracy exists with regard to proprietary software as well as smartphone apps. Using and modifying Linux code, be it Ada source, BASH scripts, C (and C++) source, etc. I am not sure about HTML and XML, but GPL could augment ordinary copyright laws to cover those mark-up languages as they usually present documents on the Internet or are used to manipulate character data (or manipulate characters as data in the case of XML, and also include ASCII encryption (in some hexadecimal format such as binhex, uuencode, or xxencode) of raw binary data.
Though, the publishing derivative of Gnu Public License (GPL) could cover the SGML-like languages. The GNU site should have that somewhere.
Returning to the quoute, the text refers to another article by Stallman called "Why Software Should Not Have Owners", which is almost like a prime directive for UNIX programmers and users.
In it, he writes:
"Digital technology is more flexible than the printing press: when information has digital form, you can easily copy it to share it with others. This very flexibility makes a bad fit with a system like copyright. That's the reason for the increasingly nasty and draconian measures now used to enforce software copyright. Consider these four practices of the Software Publishers Association (SPA):
1) Massive propaganda saying it is wrong to disobey the owners to help your friend.
2) Solicitation for stool pigeons to inform on their coworkers and colleagues.
3) Raids (with police help) on offices and schools, in which people are told they must prove they are innocent of illegal copying.
4) Prosecution (by the US government, at the SPA's request) of people such as MIT's David LaMacchia, not for copying software (he is not accused of copying any), but merely for leaving copying facilities unguarded and failing to censor their use.
All four practices resemble those used in the former Soviet Union, where every copying machine had a guard to prevent forbidden copying, and where individuals had to copy information secretly and pass it from hand to hand as “samizdat”. There is of course a difference: the motive for information control in the Soviet Union was political; in the US the motive is profit. But it is the actions that affect us, not the motive. Any attempt to block the sharing of information, no matter why, leads to the same methods and the same harshness" -- R.M. Stallman, Why Software Should Not Have Owners: http://www.gnu.org/philosophy/why-free.html
With regard to "free" software, it is an extension of free speech. If one pays a member of the SPA to attend workshops on their new product, they will probaby be given a non-disclosure document to sign, which essentially makes that product in effect a "slave" of its own. If one then "frees" the slave of an SPA owner, he becomes a "pirate". However, there is an unwritten clause in that owner's license which states that a customer may purchase "limited" freedom to use more than one copy on more than one computer. This is called "licensing". This licensing violates a person's right to make a copy of a software product because usually the contract limits one to a certain number of copies and a license has to be purchased to cover more copies. In short, software licensing only propagates slavery.
If the product has a defect in it, and you know of a workaround to compensate it, sharing the knowledge about that workaround isn't covered by software licensing; but if the workaround consists of changing a byte or character in the software, then that could be considered a license violation even if it improves productivity.
Consider a product whose license limits it to 10 copies, and the 11(+n) copy will not run on any computer, and the license for additional copies is expensive. Suppose a customer reverse engineers the software and figures out how to change the program so that the 11th copy will still run on his computer. He is considered to be a software pirate for freeing his program from being limited to 10 copies. If he tells other people about how to modify their copies of this program, then he is a criminal.
Today, digital rights are considered the sole domain of publishers, be they software (the members of SPA) or multimedia like MPAA or RIAA. Rather than sticking with offshore piracy, common in Asia because of the cost of software, which very few people in Asian countries can afford, publishers are now targeting children of people who work in offices whose owners usually pay publishers for limited licensing of their products. This is probably because it's harder to bring Asian pirates to justice, but you have a captive audience waiting to be milked of their money for being busted for peer-to-peer (p2p) download of multimedia and software products in the form of high school and college students.
Obviously, the conclusion I can come to is that being a good consumer comes with a high price. Any consumer is in no way free, for he has to live by the rumes of his community, and with respect to published works controlled by publishers, he always pays for the right of use, be it running a program on a computer or even reading a book.
A typical consumer may consist of being a Winblows "owner", where you own a license to use Vista. He is described in Stallman's first quote above. In contrast, a UNIX programmer/user is described in his second quote.
Returning to the title of this article, the reason why software wants to be free is, in the hands of a competent programmer or user, the source code has the potential of being modified to work on a particular system.
For example, on my Ubuntu Linux system (6.06.10 LTS), I've installed smokeping, a software which fpings hosts and sotres the results in a database that is used to create graphics of network statistics based on the response times derived from the use of smokeping.
And one bug I've noticed is that Ubuntu Linux creates /var/run as a volatile tmpfs - that is, the directory which stores pid files for programs run as daemons which may have child copies running concurrently in memory and need to know the process number for their parent in order to complete nicely and not run amok by becoming zombies.
My understanding of why /var/run was made volatile is that it is easier to dump it on reboot and start over. However, the smokeping author has a script run from /etc/init.d which has this line:
start-stop-daemon --start --quiet --pidfile /var/run/smokeping/$NAME.pid
** $NAME=smokeping
Basically, in this line the program to start and stop a program nicely as daemon, start-stop-daemon, starts quietly, and in the process creates the file smokeping.pid in the directory, /var/run/smokeping
However, this line fails on startup because /var/run being actually a directory mounted on a tmpfs, does not have the directory /var/run/smokeping !
Here's df's output showing /var/run:
varrun 127340 196 127144 1% /var/run
So, whenever I reboot my system, I get an error message that states that smokeping cannot create /var/run/smokeping/smokeping.pid because the smokeping directory does not exist.
Now /var/run/smokeping needs to be created first and assigned ownership to smokeping by root before /etc/init.d/smokeping can be run successfully.
So this needs to be done on startup before other resident programs are run under one of the seven different user modes Linux uses. This is done by running in numerical sequence the scripts in /etc/rcS.d, followed by the running of scripts found in the rc[0-6]. rc0.d and rc1.d are used for killing processes during certain shutdown modes, with rc0.d for major shutdown (halt) and rc1.d for single user mode.
However, for the purpose of this example, I'll assume we know where smokeping runs from after startup, and if I get a question about that, find out so we both know.
Because of the nonexistence of the /var/run/smokeping, I had to create a script to check to see if the smokeping.pid is in it, and if it isn't to confirm the directory smokeping is present and after confirming that it does not exist, then create the directory and change ownership to smokeping by root.
And this effort was done all because of a 'bug' in smokeping.
That's like about a total time of an hour invested because of one bug which partially due to the volatile nature of /var/run, but mostly due to the author of smokeping assuming that the installation of the smokeping software would create the smokeping directory on a /var/run directory that is a part of the /var hierarchy on the filesystem.
Now it would not be useful to use apt-get install --reinstall smokeping, since in some cases you may have to download smokeping again, just to recreate the /var/run/smokeping directory.
I could have edited the /etc/init.d/smokeping script but realized that restarts and stop/starts would rerun a check for the /var/run/smokeping repeatedly. So I created my own script, thus leaving the startup script /etc/init.d/smokeping alone.
Instead, I created /etc/init.d/mksmokeping_dir to create the directory and give the smokeping user ownership. Then I created a link to /etc/rcS.d/S98mksmokeping_dir so that the next to last thing started up is the creation of the smokeping directory.
I presented this example to show you how one software was freed of a bug caused by making /var/run volatile i.e. mounting it as a tmpfs. The action of this bug was to prevent the creation of a pid file used by the program to handle child process completion i.e. knowing the process ID number of their parent, they are able to complete nicely and not live on as zombies. My script basically checks to make sure the pid file and the /var/run/smokeping directory do not exist before creating the smokeping directory and assigning ownership to smokeping. Hopefully my program solves this problem and successfully fixes this bug on startup consistently.
And generally I hope I have explained why software wants to be free, and hinted at what kind of freedom applies to software (and other published works related to computers). This is the reason why I am here on Jinx. I figure I'd be collaborating with the enemy by using a third-party example and avoiding using a recent trivial example of how I freed a particular software on my Linux computer.
If someone is reading this post and is using Ubuntu Linux, then I may provide my mksmokeping_dir script on demand. If you wish to use smokeping, then you should remember that you need apache if you don't need to "break" your system to use it with thttpd. I don't mention how to break the system to use smokeping with thttpd because it is trivial: it consists of changing the smokeping config file to point to the rrd subdirectory. the main html directory is /var/www/smokeping in which are subdirectories created for the png files used to display graphic statistics.
If you need the config file to see how I do it under my system, then I can't let you have my version. Another thing that needs to be done, which does break Linux, is you have to modify the permissions of the smokeping directory and everything under it to 777 or at least chown smokeping the rrd files. So, don't try this on a DMZ'd computer because you can end up with /var/www/smokeping being turned into a ftp warez repository.
Thus, if you want to use smokeping on Ubuntu Linux under Apache, then you only need my script.
If you want to adapt smokeping to thttpd, then you have to break Linux security to do it by making /var/www/smokeping world read/writeable preferably owned by smokeping. The risk here is that once smokeping is owned by a cracker, root can be compromised with some work, especially if your password is secure by consisting of a minimum of seven alphabetic charactrs and one numeric character, and is changed every three weeks. So, remember, thttpd is for secure media pushing content and should not be pushing output of programs that need to break security by the use of world read/writeable permissions on everything. You might get away by using chmod -R 755 and chown -R smokeping:smokeping on /var/www/smokeping.
No comments:
Post a Comment