http://techno-jazz.blogspot.com/

void main() {

char * str = “NonWritable”;

str[0] = ‘X’; /*<< Booom*/

}

Compiling the same using -fwritable-strings option to gcc however did not result in a segmentation fault.

Let me warn you before you try it yourself. GCC removed the support of writable strings with 4.0 and above. Hence, GCC no longer accepts the -fwritable-strings option. Use named character arrays when you need a writable string.

What does that mean?

It means that use this instead: char str[] = {“Writable”}; instead of char * str = “Non Writable”

Aha, now i get it…somehow char * str is marked read only? but where and how?

Ok Lets dig in…

What Kinds of C Statements End Up in Which Segments? (Courtesy: “Expert C Programming“)

Segments? Does it have to do with segments and Paging in OS architecture… hell no! Its something to do with how ./a.out (executables) are organized and laid out. Many Authors call segments as sections who want to distinguish the two types. But for now I would continue calling them as segments.

Try this: Linux has a utility name size which prints out size of various segments(or sections) of the executable.

For example: size ./a.out

text data bss dec hex filename
1167 + 528 + 60032 = 61727 f11f ./a.out

Actual size of ./a.out is 9324 (9K Bytes) using dir equivalent.

What is the size program printing? Its actually printing various sizes of the segments in which the executable ./a.out is divided. As you might have guessed they are ‘text’ , bss and data.

Here is the example copied from the “Expert C Programming“

Here is the summary:
- All Initialized Global/Static variable go into the data segment.

- All uninitialized global variables go into the BSS segment. Since all global variables are initialized to zero by default, there is no need to remember it. That is probably why the bss segment was created.

- char * str = “Non Writable” goes into the text segment, which is when loaded into the memory by the loader(?) is marked as read only. That is why the above program crashes!

Now, I am wondering how can we write a self mutating program when the text segment is marked read only.

- Variables declared on stack are not captured in any segment. Thus declaring a big array on stack does not increase your a.out size.

But will declaring a huge array as global or static increase a.out size?

Lets see:

Declaring a global array int arr[], compiling and running size and also checking the actual size of the file a.out:

size.c:

char arr[64000];
void main () {
}

gcc size.c; size ./a.out gave the output as:

text data bss dec hex filename | Actual size of file ./a.out

char arr [6400]; 1012 484 64032 65528 fff8 a.out | 9121 bytes

char arr [640000]; 1012 484 6400032 6401528 61adf8 a.out | 9121 bytes
Clearly, just declaring a big array does not change the Actual size of the binary.

However declaring and initializing the array

char darr[6400000] = {“test”};
void main () {
}

text data bss dec hex filename | Actual size of file ./a.out
1012 6400512 16 6401540 61ae04 ./a.out | 6409145

Makes the executable size as 6409145 bytes, ouch! compare it with 9121 bytes above.

The only change was that the array was initialized, which moved the array into Data segment (instead of BSS segment). Since the BSS segment only holds variables that don’t have any value yet, it doesn’t actually need to store the image of these variables.

Until next time…

Download Royale Noir (.ZIP) [403K]
Download Royale Noir (.RAR) [232K]

And my Desktop looks like:

Sometime after the launch of XP, somewhere in Redmond, someone on the Microsoft design team was in the progress of developing something for Media Center. It was believed to be too powerful for public consumption and forever archived in the servers at 1 Microsoft Way (source http://www.istartedsomething.com/20061029/royale-noir/).

Archived Forever? Nah.. Vista looks much similar. Since I don’t like desktop wallpapers, I kept it dark (Although you may want to download one from the net..)

hail XP!!

Notes:
• The size and alignment of long integers and pointers have changed
from 32 bit to 64 bit.
• For the most part, as long as your code always uses the sizeof
function when allocating data structures, the size and alignment of
pointers should not affect your code, because structures containing
pointer members are generally not written to disk or sent across
networks between 32-bit and 64-bit applications. However, the
change in the size of long can cause problems if you frequently
move data between variables of type int and long.
• You should generally avoid casting a pointer to a non-pointer type
for any reason (and particularly not for performing address
arithmetic). If possible, rewrite any code that does this, either by
changing the data types or by replacing address arithmetic with
pointer arithmetic.
• If you are shifting through the bits stored in a variable of type long,
1 Depends on whether _FILE_OFFSET_BITS=64
you should be careful to avoid assuming that it is of a particular
length. Instead, use the value sysconf(_SC_LONG_BIT) to
determine the number of bits in a long.
• Be careful when using bit masks with variables of type long,
because the width will change between 32-bit and 64-bit
architectures.
• If you want the mask value to contain zeroes in the upper 32 bits on
a 64-bit architecture, the usual fixed-width mask will work as
expected, because it will be extended in an unsigned fashion to a
64-bit quantity.
• Use explicit types where possible. For example, types with names
like sint32_t and uint32_t will always be a 32-bit quantity,
regardless of future architectural changes.
• Conversion of shorter types to 64-bit longs may yield unexpected
results in certain cases. Be sure to read the section “Sign Extension
Rules for C” if you are seeing unexpected values from math that
mixes int and long variables.
• The alignment of long long (64-bit) integers has changed from 32
bit to 64 bit. This can pose a problem when you are exchanging
data between 32-bit and 64-bit applications.

void main()
{
int a=-2;
unsigned int b=1;
long c = a + b;
long c1 = a + (long) b;

long long d=c; // to get a consistent size for printing (on both architectures, 32 and 64 bit).

…

}

PROBLEM: When executed on a 32-bit architecture, the result is -1 (0xffffffff). When run on a 64-bit architecture, the result is 4294967295 (0x00000000ffffffff), which is probably not what you were expecting

Rule #1 : Now, when you add a (int) + b (uint) : The result is : Unsigned. Thus, a + b results in a unsigned integer (-1) which is 0xffffffff.

Rule #2: When unsigned int numbers are promoted to long’s. They are not sign Extended. Thus, -1 which is 0xffffffff is simply promoted to 0x00000000ffffffff which is a very high number. Note: This problem does not come on a 32 bit OS. Since long is 4 bytes.

What? The Idea is simple: unsigned quantity does not have a sign attached to it, right? so if unsigned quantity is promoted to a long(or unsigned long) then they simply cannot be sign extended!

However, signed quantities do have a sign, thus when they are promoted to a long, it is all duly taken care. i.e:

Rule #3: Signed values are always sign extended when promoted to a larger
type, even if the resulting type is unsigned.

(unsigned or signed) Long = Signed int will Work.

i.e. Signed values are always sign extended when promoted to a larger type, even if the resulting type is unsigned.

int a = -1;

long v = a;
unsigned long v1 = a;

printf(“%d %ld %ld\n”,a, v, v1);

Output (on a 64 bit value) is: -1 -1 18446744073709551615

The above big value clearly shows that when signed integer -1 was promoted to a signed long value (which would be 64th bit (sign bit) was set as 1).

Rule #5: Constants (unless modified by a suffix, such as 0x8L) are the
smallest size that will hold the value. For numbers written in
hexadecimal, this includes both signed and unsigned int, long,
and long long types. For decimal numbers, this only includes
signed types.

I have been coding for the last 7 years in c and c++. Now things have become so mundane that I can code with my eyes closed and my brain half dead. Programming everyday in office, I do not get a problem for which I’ve to think much. There is nothing which makes me awake from my sleep. Mostly a bug fix, a feature integration or just plain refactoring. There is no excitement of a new learning or a new technology. I am getting old and tired of doing the same/similar things again and again…

What I would like is to try something radically different. Like?

1) UI Design. Be an expert in designing simplified UI for next generation devices.

2) A web based software. With things now slowly moving towards SAAS (s/w as a service model) and web based delivery of software. I would like to get involved in it, to see the how this technology transforms the way s/w is delivered and used.

3) Product management: Instead of thinking about algorithms and datastructures, I would like to move one step closer to where products are incubated.

And some more…

A POC is scheduled for next day morning. Since its a big customer everyone is looking forward for it. POC preparations are underway when I get a call at 9.30pm that there is a crash. We have a reg-ex capabilities on the application data on the fly, as an when the message is parsed through our box.

We were using a standard posix regex engine. No brainer there..however what I left behind was a simple Null check.

This post is to remind myself as a good programmer that even when assumptions are that the string can never be null, go ahead and make a check on Null’ness of the string. Especially when passing it to standard libc libraries (strcpy/regcomp etc).

And if you don’t, what will be the end result? Crash at the nth hour..Fixes, Patches, unnecessary late nights…

I decided to play with a few CMS available on the net. And there are tons and tons of them, all free!

Requirements:

All I wanted was a good content management system,

- with Wiki support,

- along with a forum

- email based notifications

- integration with svn and bugzilla (if possible)

I should have added ‘Ease of install and configuration’ as my requirement. As many of the CMS packages available proved me otherwise.

First Choice: Twiki

Twiki was the first choice, but soon I realised its cumbersome installation and configuration. Tweaking twiki is a daunting task, Especially on a windows based system. Actually most of these CMS are made for Linux and hence installation and configuration is still based on .conf files, scripts, assumptions and more.

Fortunately there is a Windows Installer for Twiki 4.2 available on the net. And the installation of that is one-click, seamless install. It includes an inbuilt apache, perl etc. But this I stumbled upon accidentally, only after wasting my lot of time on WindowsInstallCookBook and  tons of garbage insturctions on how to install zillions of modules to just get twiki up and running! I say Why? Why do the end user has to follow tons and tons of instructions to just get the s/w running? I mean developers of twiki spent countless hours developing a good CMS system, but didn’t spend couple of hours maintaining some one-cick installater for the end users? sad.

Anyways, I was able to get twiki running (using the windows installer) however i stumbled upon another problem. Installation is one problem. Confguration of modules in Twiki requires another PHD. Its based on TWIKI_VARIABLES_TO_BE_SET=’Hell’ on a twiki page (instead of maintaining .conf files). This may sound to be a great idea from a developer point of view, but has a extreme learning curve from an end user point.

Finally trying hard to search in a extremely big bulky Twiki site, searching for modules, and how to make it working, i was more or less left on my own. A few modules (like forum in twiki) worked in one shot, simply by unzipping them into twiki directory. However a few gave me big time pain. Twiki originally based on a Linux system assumes a lot of stuff ( tools like svn etc are available on linux) but not on windows. Which means, I would have to download those tools, configure them and make sure the perl scripts from twiki are able to use those tools. Now there is no neat information available on the net which can help you do that in one shot.

Trac

Trac looked impressive. Had inbuilt support for forum and svn. However its installation is a night mare too.

Again it pointed me to a page of tons of confusing instructions on how to download stuff required to run trac: python, setuptools (some sort of python library used to setup trac), Pysqlite, Genshi and bleh!.

And the instructions are given in plain lucid form here.

1. Click “Start” > “Run…” (or press Win+R)
2. Type “cmd” and click “Ok” – this opens the Windows command console
3. Type “cd c:\Python24\Scripts”
4. easy_install blah_package.

Great! so easy. but somebody who spent hours in writing this information, could have created a single installation based script to do the same. isn’t it? Why force people who need a no-brainer solution go through hundreds of instruction..

I left trac evaluation in a hurry, couldn’t have possibly gone ahead with it.

Drupal and Joomla

Installation of  drupal was seamless!!!

This was the first time I could do it with minimal instructions.

Just Install XAMPP (which is apache + PHP +MySql and sendMail). Unzip the drupal directory under htdocs.

There you go, point your browser to http://localhost/drupalx.y/ and the installation is cool .

One catch!

Need to pre-create a database for drupal(just give any name) which can be done from http://localhost/xampp phpMyAdmin link. Also remember to copy user say: root and assign a password to it. again PhpMyAdmin> Priviledges.

Both user name, password and database name(given above) are asked as input during the drupal installation (http://localhost/drupalx.y/)

Great CMS systems, but I rejected them as they didn’t had wiki support.

Thank drupal and joomla, now Its easy to create a website of your own!

And Finally TikiWiki

- The installation was seamless (xampp, unzip into htdocs, point your browser to your installation http://localhost/tiki/ and there you go. Just remember to create a database and a user using http:/localhost/xampp phpMyAdmin link.

- The configuration was UI based, thank goodness.

- Documentation was comprehensive along with a Tikiwiki manual for Dummies smarties.

- There forum support was good as well.

All in all. I was up with TikiWiki in no time…

To my surprise, it looked more refined than Twiki, the UI was more intuitive, not cluttered. Finding and setting up information was easy.

Finally one last thing! The email notifications. This took me a lot of time.

Considering that al other previous installs had explicitly asked for SMTP settings, I was expecting similar. However it was only after a night out I realised that Tiki email notifications (for first time registrations for example) are dependent on php.ini.

Tiki relies on your xampp php.ini and sendmail/smtp.ini settings. It depends on mail() function inbuilt into PHP to work. Thus, if your settings in the above two files are correct, then tiki email notifications should work seamlessly. But first I had to be sure that my above configuration is right. For that I googled for a php email script.

Found one:

<?php
$to = “recipient@example.com”;
$subject = “Hi!”;
$body = “Hi,\n\nHow are you?”;
if (mail($to, $subject, $body)) {
echo(“<p>Message successfully sent!</p>”);
} else {
echo(“<p>Message delivery failed…</p>”);
}
?>

Copied it into htdocs and tried it using my browser. Showed ‘Message successfully sent’ but no mail

Had to tweak xampp/sendmail/smtp.ini to enable debug.log to figure out that the authentication was failing. Alright, that was fixed and voila the script worked and so did the Twiki Email notificaions.

Yahoo!

Product Quality Guidelines: What can be done from engineering point of view to make users happy?

1) Integrate CruiseControl (free software) to do daily builds. Find build breaks faster..

2) Automated test-suite for Regression, run every day on daily builds.

3) Automated emails to engineering for Regression failures.

4) Fix for regression failures to be taken as P1

5) All Code Checkins go through strict peer-code review (Code quality).

6) Developers Add new test cases into regression as and when new features get in (a must).

7) QA folks add new system test cases, Run randomization/Performance tests. Send weekly emails on the status.

Make an attempt to keep your software Bug-free!

When you fix one bug, there are 50% chances that you would introduce several* newer bugs. Thats a fact. Irrespective of how good programmer you are, Its very easy for a bug to crop in. Especially at the last hour, just before a release.

If a bug is found at the last minute and a quick-fix can be made by the dev-team. What would you chose to do?

• Fix the bug.
• Take it up in the next release, no checkins at the last hour. After all the qa-complete, regression tests and randomization/performance tests have been completed on a qualified build. Why take unnecessary risk of disqualifying/breaking any of it?

This is the dilemma every Dev-manager has to go-through.. Whether or not he/she choses to make the fix(or break the release!) depends on many factors.

Decision to fix the bug should not be on how easy the fix is. It should be on how crucial is the fix for the success of the product?

1. How many customers will it effect. If its one in four people(25%), than its a P1 blocker (P1-B). If its less than that, then probably the bug can go as a patch fix. Microsoft is famous for its SP1 and SP2 releases.
2. Is it something the user will notice right away (P1) or is it a usability issue with the product
3. Is there a work around?
4. Is it one of the input-types which fails validation? Can an attacker misuse it? If yes, then its P1
5. Remember how embarrassing the situation went for Bill Gates when Win-98 crashed right while doing its presentation (see Infamous Windows 98 crash ). Fixing that kind of bug is P1.

There can be other questions as well which a dev-manager needs to ask himself before the decision is made to checkin the fix.

Remember generally the gut-feeling will be that everything will work. Hence the decision should be based on some rational thinking rather than the gut-feeling. In my opinion its wise to be pessimist rather than an optimist..because Murphy is there and he is always watching…

“if anything can go wrong, it will.”