Today I received an email from a client that had just moved their site over to SSL (i.e. HTTPS) — they were no longer able to download files in Internet Explorer. When they tried to do so, a message would appear:

Unable to download...[file name]

The file could not be written to the cache

(an alternative error message is “Internet Explorer cannot download [file name] from [site].
Internet Explorer was not able to open this Internet site. The requested site is either unavailable or cannot be found. Please try again later.”)

I tried various suggestions: different response headers, settings to do with saving encrypted files, and even tried (and failed) to install a couple of hotfixes.

In the end, I’d nearly given up when I found this knowledgebase article and decided to have a go at manually adding the BypassSSLNoCacheCheck registry key.

Short story, it worked. It’s not great since it requires the user to do something — I couldn’t fix it server-side — but it was OK in this case because the site was an intranet so their IT people could sort it. Anyway, I hope this helps someone else out there…

UPDATE: OK, after a lot more experimentation I found a proper solution that doesn’t involve registry updates!

It’s a long story but it turns out that PHP was automatically sending an extra header (“Pragma: no-cache”) that I hadn’t noticed. So, I set the headers as follows:

header("Cache-Control: private");
header( "Pragma: private" );

…which overrides the automated headers and appears to solve the problem. Hurray!

All was working smoothly using the ‘PayPal sandbox’ testing domain, but when it came to testing a live transaction in Internet Explorer I received the following error:

“Sorry, an Error Occurred After You Clicked the Last Link”

…followed by a lengthy but rather unhelpful block of text suggesting various courses of action — none of which was any use at all.

Consulting Google, it seems that this is far from an unusual occurrence but there’s little consensus as to the cause. In the end, I tried adding target=”_top” to the form that submits to PayPal (thus forcing the ‘pop-out’ of the iframe), and presto, all is now fine again.

Briefly, the problem arises from the fact that the world is a sphere and representing it in two dimensions is not a straightforward task. There are various ‘projections’ to choose from, each of which uses a different method for mapping points — you can find out more in this Wikipedia article. The most common choice is the Mercator projection, where lines of latitude are spaced equally, and fortunately for me it’s the type of map used in the project I’m working on.

So, being somewhat mathematically inept, I decided that Google would save me from a day’s head-scratching. That turned out not to be the case, as I tried a good half-dozen different suggestions before finally stumbling across one that actually produced accurate results. To save others from the same fate I decided to reproduce here the code I ended up with, which is based heavily on code found in this newsgroup post. My implementation is PHP, but it shouldn’t be hard to convert it to another platform (see the original thread for a Javascript implementation). Apologies for the rubbish formatting, WordPress isn’t great at handling code:

function LongitudeToX( $lat, $lon, $map_zoom, $scale_value, $x_offset = 0 )
{
  $offset=16777216;
  $radius=$offset / pi();
  return ( ( ($offset+$radius*$lon*pi()/180)>>$map_zoom ) * $scale_value ) + $x_offset;
}
function LatitudeToY( $lat, $lon, $map_zoom, $scale_value, $y_offset = 0 )
{
  $offset=16777216;
  $radius=$offset / pi();
  return ( ( ($offset-$radius*log((1+sin($lat*pi()/180))/(1-sin($lat*pi()/180)))/2)>>$map_zoom ) * $scale_value ) + $y_offset;
}

A few notes about using these functions:

• From what I can tell, the above code is based on Google Maps and the $map_zoom relates in some way to the ‘zoom level’ of the map. I set it at 15 and it seemed to work OK.
• Because the dimensions of your own map might not exactly match the assumed dimensions of the map used in the calculation, the $scale_value parameter allows you to adjust the output to fit more precisely. I had to specify two decimal places of scaling to get an exact fit.
• Finally, the calculation assumes that the ‘origin point’ of the map (x=0, y=0) will be at the top, left-hand corner. This isn’t the case on the map I’m working on (the origin is at the centre) so I included $x_offset and $y_offset parameters so that I could adjust the output values accordingly.

In order to find the best values for the above parameters, I manually placed three widely-spaced temporary markers on the Flash map marking points whose latitude and longitude I already knew. Then I had the code render these points and adjusted the various parameters until the position of the generated points exactly matched the manually-placed markers.

I hope this code helps someone avoid wasting the sort of time I did yesterday!

Yesterday, for example, I was working on something that had already taken several days of my time when I’d hoped to get it done in hours. The final straw came when I found myself facing what appeared to be an intractable problem: a process that needed to insert multiple rows in a table, and increment a certain column in each row to get a unique value. I couldn’t use an auto-increment value in this case (there was one already), and using a separate query caused concurrency problems (resulting in non-unique values). I should just point out that this is a system that I’ve inherited, not one that I developed myself.

I started out with a simple update, like this:

UPDATE my_table SET some_value = ( MAX( some_value ) + 1 ) WHERE id = 123;

…which in hindsight was never going to work but anyway, it gave me this error:

#1111 - Invalid use of group function

So I thought about it a bit and then struck on this:

 UPDATE my_table SET some_value =
(
(
SELECT MAX( some_value )
FROM my_table
) +1
)
WHERE id = 123
…which gave me this error:

#1093 - You can't specify target table 'my_table' for update in FROM clause

…damn. I was starting to bang my head on the desk at this point, but Google came to my rescue by pointing me at this thread, which suggested using a nested sub-select. The result was the following rather ugly query:

UPDATE my_table
SET
my_value =
(
(
SELECT selected_value
FROM
(
SELECT MAX( my_value ) AS selected_value
FROM my_table
)
AS sub_selected_value
)
+ 1
)
WHERE id = 123

…which works. It’s not great  from a performance point of view since it uses a temporary table, but it does what it needs to. I hope in future that I will be given time to go back and rewrite this part of the system so as to entirely remove the issue.