If you are working with Linux remote machines on a daily basis, or simply are the kind of person who wants to work with his terminals in the most efficient way possible, you probably already heard of GNU screen. It is a terminal multiplexer, meaning that it allows you to access multiple virtual terminal sessions from inside a single physical terminal. How can this help you? Well, most commonly, it can help you in two situations:

• you want to work with six terminals on a remote machine;
  How do you do it?
  The classic way: you open up six terminals (or Putty sessions) and ssh to the remote machine on each one of them. Even if you have ssh keys configured and don’t have to introduce a password, it’s still a bummer. You still have to alt+tab or alt+# through six terminals and managing them can become a headache.
  The terminal multiplexer way: you open up a terminal/putty session and ssh to the remote machine. There, you run screen, and open new virtual terminals (called windows) without having to ssh to the remote machine again. You manage you windows with simple shortcuts, and instead of six open applications, you have just one.
• you want to have more terminals open on your screen at the same time, so you don’t have to switch through them to read each of their output;
  Newly created windows can be arranged like multiple tabs in your terminal, but in addition, each window can be split into regions, such that you can see and access multiple terminals at once, having all of them in front of you. For example, one way I am using this is for logically separating my areas of work: I keep one window with multiple regions for writing code in different files, one window with multiple regions for testing my code (each executable will have its own region) and one window for reading log files.

Like screen, tmux is also a terminal multiplexer; I’ve never been a screen power user, so I won’t go ranting on why one of them is better than the other. If you’re interested, from what I’ve read the main things that differentiate tmux from screen are:

• it’s a server-client system – meaning that there is a server instance (started when tmux is first run) and the sessions you open are the clients; this allows you to even move windows from one session to another, or view a window from multiple sessions at the same time
• it can split panes vertically, not just horizontally
• it has a pane-synchronizing option, such that when you write something in a pane, it simultaneously writes the same thing in all the panes from the current window
• multiple paste buffers
• the option of choosing either vim or emacs key bindings
• some say it’s less resource hungry than screen (but I don’t think any real benchmarks have been run yet in this regard)

How to use tmux

Tmux probably isn’t going to be installed by default on your system, so you will first have to install it either using your favorite package manager (aptitude, yum, …) or by compiling the sources. These can be found on the tmux website. If you decide to compile from source, be aware that you will also need to have installed the development files for libevent (on RHEL, these are libevent-devel.i686 or libevent-devel.x86_64, depending on your platform).

After you installed it, you can simply run ‘tmux’ to start a new session:

$ tmux

$ tmux ls
0: 2 windows (created Thu Dec 22 15:07:17 2011) [237x54] (attached)

$ tmux attach [-d] [-t session_index]

As you can see, tmux now looks just like your basic terminal, with the exception of the green status bar on the bottom. To give commands to tmux, you can either enter the tmux command prompt (by pressing C-b : ) and issue the command or you can use a key binding associated with a command. Below are the most common key bindings I use (PS: you can reassign key bindings if they’re not good for you, see the next section):

• C-b c -> create a new window
• C-b 0 to 9 -> go to a window number
• C-b n -> go to the next window
• C-b p -> go to the previous window
• C-b ” -> split the current pane in two: top and bottom
• C-b % -> split the current pane in two: left and right
• C-b ←/→/↑/↓ -> move focus to other panes; if you want to move through multiple panes, you don’t have to press C-b and a directional key every time, just press C-b once and then quickly press multiple directional keys
• C-b C-o -> swap panes in counter-clockwise order
• C-d -> exit the current shell
• C-b, and while holding Ctrl, press ←/→/↑/↓ -> resize a pane
• C-b ! -> make the current pane a new window
• C-b d -> detach from the current session
• C-b Alt-1 to Alt-5 -> arrange panes in one of the five preset layouts: even-horizontal, even-vertical, main-horizontal, main-vertical, or tiled
• C-b ? -> see all key bindings

There are a few more bindings it’s very useful that you know. A tmux window may operate in two ways: the default mode, which gives you access to the terminal attached to the window, and the copy mode. The last one lets you select and copy some text from your window into a paste buffer, so that you can later paste the selection into another window/pane.

• C-b [ -> enter copy mode; press Space to start selection, Enter to copy the selection into a paste buffer and q to go back to the default mode
• C-b ] -> paste the contents of the last paste buffer
• C-b = -> interactively choose a paste buffer from which to paste the contents into the current terminal

However, there are some interesting commands that don’t have key bindings by default. To issue them, press ‘C-b :’, write the command and press Enter. Some useful commands are:

• set-option -g mouse-resize-pane on -> lets you rearrange the panes’ width and height using the mouse
• set-option -g mouse-select-pane on -> lets you select panes by left-clicking on them
• set-window-option -g mode-mouse on -> lets you use the mouse to enter copy mode, copy a selection by dragging and scroll with the mouse wheel
• set-window-option -g monitor-activity on -> tells tmux that it should monitor the activity on all windows
• set-window-option -g visual-activity on -> display a status line message when activity occurs in a window that has the monitor-activity option enabled
• set-window-option monitor-content match-string -> tells tmux to monitor the content in the window, looking to match the match-string pattern
• set-window-option visual-content on -> display a status line message when content is present in a window for which the monitor-content option is enabled
• set-window-option synchronize-panes on -> synchronizes what you write in a pane with the rest of the panes in a window

You can see all the available commands in tmux’s man page.

The configuration file

If you want some options to be persistent over multiple runs of tmux, you must write them in the tmux configuration file: either /etc/tmux.conf, which is the global configuration file (it applies to all users), or ~/.tmux.conf, which only applies to the current user. Here is the configuration file I use:

# use this if you want to set the prefix to C-a, like screen does
# unbind C-b
# set -g prefix C-a

set -g history-limit 16384  # the number of lines you can search through in copy mode
set -g buffer-limit 50      # number of paste buffers
set -g base-index 1         # the window numbering will start from 1 instead of 0

# create a window with 4 panes by default
# Be careful! if you do this you must start tmux with 'tmux attach'
# if you start it with 'tmux' it will take you to a newly created session,
# and you will have 2 sessions, as 'tmux' is equivalent to 'tmux new-session'
new
splitw -v -t 0
splitw -h -t 1
splitw -h -t 0
selectp -t 0

# when splitting a window, make sure the new terminal keeps the same
# directory, just like gnome-terminal does when opening a new tab
bind h send-keys " ~/.scripts/tmux-split -h" \; send-keys "Enter"
bind v send-keys " ~/.scripts/tmux-split -v" \; send-keys "Enter"

# bind keys for pane synchronizing
bind y set-window-option synchronize on
bind t set-window-option synchronize off

$ cat ~/.scripts/tmux-split
#!/usr/bin/env bash
PWD=`pwd`
tmux split-window $1
tmux send-keys " cd $PWD;clear"
tmux send-keys "Enter"

In conclusion…

Tmux is one of those tools which, if configured and used right, can raise your productivity substantially. Even if it’s hard to get used to at first, it’s worth it in the long run.

PS: Even if it hasn’t any practical value, it’s damn cool to have 152 terminals into one single screen :)

The basics

Bulls and Cows (a version of Mastermind) is a 2-player game where your opponent (the computer) randomly chooses a 4-digit number for you to guess. All digits in the number must be distinct and you are allowed a maximum of 8 tries. After every try, it gives you feedback: how many digits you got in the correct position, and how many digits you got in the wrong position.
An open-source version of this game is available here.

The game solver

For solving the game, I decided to start from this page and for the language I chose Tcl.
First, I compiled the text version of 4 digits:

[claudiu@localhost Desktop]$ tar -xjvf 4digits_0.9.tar.bz2
...
[claudiu@localhost Desktop]$ cd 4digits-0.9/
[claudiu@localhost 4digits-0.9]$ make 
gcc -Wall -std=c99 -pedantic -g 4digits-text.c -o 4digits-text

#!/usr/bin/tclsh

package require struct::list
package require struct::set

# some procedures

proc in {str list} {
        foreach elem $list {
                if {$elem eq $str} {
                        return 1
                }
        }              
        return 0
}
 
proc has_diff_digits {x} {
        set i1 [lindex $x 0]
        set i2 [lindex $x 1]
        set i3 [lindex $x 2]
        set i4 [lindex $x 3]
        if {$i1 != $i2 && $i1 != $i3 && $i1 != $i4 && 
             $i2 != $i3 && $i2 != $i4 && $i3 != $i4} {
                return 1
        }
        return 0
}

proc scorecalc {guess chosen} {
    set bulls 0
    set cows 0
    foreach g $guess c $chosen {
	if {$g eq $c} {
	    incr bulls
	} elseif {[in $g $chosen]} {
	    incr cows
	}
    }
    return [list $bulls $cows]
}
 
# settings

set size 4
set choices {}

for {set i 1234} {$i < 10000} {incr i} {
        set l [split $i ""]
        if {[has_diff_digits $l]} {
		struct::set include choices $l
        }
}

set answers {}
set scores {}
 
# starting

puts "Playing Bulls & Cows with $size unique digits\n"
fconfigure stdout -buffering none
while 1 {
    set ans [lindex $choices [expr {int(rand()*[llength $choices])}]]
    lappend answers $ans
    puts -nonewline \
	"Guess [llength $answers] is [join $ans {}]. Answer (Bulls, cows)? "
    set score [scan [gets stdin] %d,%d]
    lappend scores $score
    if {[lindex $score 0] == 4} {
	puts "Ye-haw!"
	break
    }
    foreach c $choices[set choices {}] {
	if {[scorecalc $c $ans] eq $score} {
	    lappend choices $c
	}
    }
    if {![llength $choices]} {
	puts "Bad scoring? nothing fits those scores you gave:"
	foreach a $answers s $scores {
	    puts "  [join $a {}] -> ([lindex $s 0], [lindex $s 1])"
	}
	break
    }
}

A print screen of the execution of 4digits in parallel with the solver:

Automating with Expect

Of course, it’s better if we put a small script to do the work for us:

#!/usr/bin/expect -f

log_user 0

spawn -noecho /localhome/claudiu/workspace/expect/4digits-0.9/4digits-text
set 4digits $spawn_id

spawn -noecho ./bulls_cows.tcl
set bc $spawn_id

set tries 0
while 1 {
    incr tries
    expect -re "is (.+)\\."
    puts "TCL tries......$expect_out(1,string)"
    set spawn_id $4digits
    send "$expect_out(1,string)\r"
    expect -re "(\[0-9])A(\[0-9])B"
    if {$expect_out(1,string) == 4} {
        puts "4digits says...That's it!"
        puts "\nNr. of tries: $tries"
        exit 0
    }
    puts "4digits says...$expect_out(0,string)\n"
    set spawn_id $bc
    send "$expect_out(1,string),$expect_out(2,string)\r"
}

A run of the script:

Some statistics

Although the solution isn’t the optimum one, because we are only playing the 4-digit game, it runs pretty fast.
To measure an average of tries per game, I wrote another small Expect script that calls the initial script a number of times:

#!/usr/bin/expect -f

log_user 0

set runs 1000

set min 100
set max 0
set sum 0

for {set i 0} {$i < $runs} {incr i} {
    spawn -noecho ./bulls_cows.exp
    expect -re "tries: (\[0-9])"
    puts "$expect_out(0,string)"
    set tries $expect_out(1,string)
    if {$tries < $min} {
        set min $tries
    }
    if {$tries > $max} {
        set max $tries
    }
    set sum [expr $sum + $tries]
}

puts "Minimum number of tries: $min"
puts "Maximum number of tries: $max"
puts "Average tries for $runs runs: [expr double($sum)/$runs]"

The result for this code with 1000 runs is an average of 5.402 tries per game. Also, the minimum number of tries is 2 (how lucky can you get?!) and the maximum number of tries was 8.

For doing this, you can of course run 2 instances of GNUChess , take the output from the first instance, put it into the input of the second instance and vice-versa. But it would be easier to make a script that does this, and you can just lay back and watch the computer lose (er…unless it’s a draw).

Expect is a tool I recently discovered, which helps you automate interactive applications, so it’s suited perfectly for our goal. I’m actually amazed I didn’t discover it earlier, it’s such a great tool, and also works great with Tcl and Tk.

The code

You can look at the code below (I made printscreens because wordpress doesn’t have TCL syntax) or at this pastebin:

Some details

• set – defines a variable
• spawn – spawns a new process (in out case gnuchess, with it’s argument -x so it could play in engine mode) and holds a process identifier in $spawn_id. This variable helps us when we want to do switching between multiple processes. In out script, we constantly have to switch between the two instances of gnuchess, so we memorize the spawned id’s in variables $player1 and $player2
• proc – defines a procedure, which can be then called by writing “proc_name argument1 argument 2 …”. In our example, the “turn” procedure is called with one argument, a string representing the player’s name.
• send – sends input to the current proces; for example, when we say send “go\r”, we tell gnuchess to start playing
• expect – waits for output from the currently spawned process. We can tell it to wait for some output that we define, and on its arrival to do certain actions. The “-re” flag tells the command that the output we’re expecting is a regular expression.
  For example, on lines 20 through 25 we tell expect that we want to wait for some output from gnuchess that looks like “move”, then an undefined number of characters, and finally a newline. If output in this format arrives, expect will print on the screen the move of the current player, then change to the other player and send it the current player’s move.

Results

The test machine has an AMD Athlon(tm) 64 X2 Dual Core Processor 4400+, 2 GB of RAM, and runs on CentOS 5.5. GNUChess version is 5.08 and you can get it from here

• Depth 1, game ends in ~ 6 seconds
• Depth 2, game ends in ~ 5 seconds
• Depth 3, game ends in ~ 7 seconds
• Depth 4, game ends in ~ 6 seconds
• Depth 5, game ends in ~ 11 seconds
• Depth 6, game ends in ~ 22 seconds
• Depth 7, game ends in ~ 1m, 17seconds
• Depth 8, game ends in 2.5h
• Default depth, GNUChess beats GNUChess!
• Default depth, it’s a draw
• Player 1 at depth 1, Player 2 at depth 3 – player 1 wins!

Expect can be easily used on any interactive program, and can help automate some like ftp, ssh, etc.
So I strongly recommend giving it a look, and also getting your hands on the Exploring Expect book if possible, it’s well written and fun to read.

Go to the directory where Chrome is currently downloading the file (the file will look something like “filename.crdownload”) and make a copy of your file

cp your_filename.crdownload your_filename

Then, issue the command:

wget -c http://link_to_your_file

So, when you connection is not so steady, wget may save from lots of trouble :)

Some details

So I searched a bit and found here that some constants that control the maximum message length are defined in libpurple/protocols/yahoo/yahoo.h. However, this post was from 2009, and yahoo.h didn’t exist in version 2.7.9 of pidgin. So I downloaded the source code from here and did a bit of searching myself:

claudiu@elmer:~/Downloads/pidgin-2.7.9/libpurple/protocols/yahoo$ grep YAHOO_MAX_MESSAGE_LENGTH *
libymsg.c:		if(lenb > YAHOO_MAX_MESSAGE_LENGTH_BYTES || lenc > YAHOO_MAX_MESSAGE_LENGTH_CHARS) {
libymsg.c:					"  Message is '%s'.\n", lenb, lenc, YAHOO_MAX_MESSAGE_LENGTH_BYTES,
libymsg.c:					YAHOO_MAX_MESSAGE_LENGTH_CHARS, msg2);
libymsg.h:#define YAHOO_MAX_MESSAGE_LENGTH_BYTES 984
libymsg.h:#define YAHOO_MAX_MESSAGE_LENGTH_CHARS 800

/*
 * Current Maximum Length for Instant Messages
 *
 * This was found by experiment.
 *
 * The YMSG protocol allows a message of up to 948 bytes, but the official client
 * limits to 800 characters.  According to experiments I conducted, it seems that
 * the discrepancy is to allow some leeway for messages with mixed single- and
 * multi-byte characters, as I was able to send messages of 840 and 932 bytes
 * by using some multibyte characters (some random Chinese or Japanese characters,
 * to be precise). - rekkanoryo
 */
#define YAHOO_MAX_MESSAGE_LENGTH_BYTES 984
#define YAHOO_MAX_MESSAGE_LENGTH_CHARS 800

The solution

…is a Pidgin plugin called Message Splitter, you just send the message as it is, and the plugin splits it up into more messages if it exceeds a certain character limit. You can even set this limit by yourself (remember, this limit can not be more than 800!). In addition, you can also specify the amount of delay in ms two messages will have between them.
To activate the plugin, you must install the pidgin-plugin-pack packet, but first you have to add the Pidgin Developers PPA to the repository. To do this, add the following two lines to your /etc/apt/sources.list file:

$ sudo vim /etc/apt/sources.list
deb http://ppa.launchpad.net/pidgin-developers/ppa/ubuntu maverick main
deb-src http://ppa.launchpad.net/pidgin-developers/ppa/ubuntu maverick main

$ sudo apt-get update
[...]
W: GPG error: http://ppa.launchpad.net maverick Release: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY 7FB8BEE0A1F196A8
$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 7FB8BEE0A1F196A8
$ sudo apt-get update

$ sudo apt-get install pidgin-plugin-pack

1. Push F5
2. In the reference tab, type x97:L97 and push the Enter key
3. Push Tab
4. Hold Ctrl+Shift and click on the chart wizard (The icon with the coloured bars)

And indeed, the myth was true!


You can control it easily with the mouse, or with the keyboard arrows. You can also see credits for the programmers (on the first photo) but what are supposed to be mountains (I think) appear a bit…colourful.
I modified the options for excel to run in compatibility with Windows 98, but same result unfortunately. So I thought maybe it’s because I’m running Win7 and not an older OS…so I wiped the dust off a Windows 98 CD, installed it on a virtual machine in VMWare and tried to run the simulator there. Then I realized, there’s no way I could install my video driver in Windows 98! (and I thing there’s issues with the virtual machine trying to access the video card too).
But anyway, if you missed Windows 98 (riiight…) here’s some screenshots:




(a dozen of these last errors appeared when I tried to access Google)

(click here if the SoundCloud widget doesn’t load)

Yeah, it’s a speed misspelling of “ls -l”…and to my surprise it worked!
Turns out “l” is an alias for “ls -CF” :)

claudiu@elmer:~$ alias
alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -alF'
alias ls='ls --color=auto'

(for a moment I thought the terminal was reading my mind)

While thinking what are the social rules that apply when people need to understand each other in these situations, two solutions rapidly came to mind:

1. one of us could yell really loud and stop the others from talking – then express his/her point of view – but that’s not very polite is it?
2. most often, people will wait an amount of time for the other person to finish what they had to say, then take their turn to speak.

The second solution immediately made me think of CSMA/CD. Then I thought “hey, but why not choose the first solution for collision detection on computer networks?”, but rapidly realized it was a bad idea. Network cards would need personality, then other network cards would probably be mad at the loud ones, and then refuse to communicate, etc etc
Anyhow, thinking how many factors influence humans in the process of shutting up and letting others speak (character,eye contact, relationship with the other individual)… I realized I don’t REALLY understand the collision detection method at the physical level.

Some background on CSMA/CD

CSMA/CD is Carrier Sense Multiple Access / Collision Detection :
- Carrier Sense – the ability of a network card to sense or detect communication on the network
- Multiple Access – states that in that network there are multiple stations that could access the network at the same time
- Collision Detection – the method we need for detecting a collision

When a collision is detected, the devices involved in the collision send a jam signal to be sure the other devices detect the collision. After that, they initiate the back-off algorithm, which practically means they wait for a random amount of time before rescanning the medium for any frames and then retransmitting.
Ethernet devices will wait for a minimum amount of time before retransmitting, named interframe gap. This time is the time necessary to transmit 96 bits of data on the medium, so it has several values depending on the cable type.

Important to keep in mind is that collision detection is needed only on wired networks where stations in the network communicate in half-duplex mode. A half-duplex transmission allows both ends of the channel to be transceiver and receiver, but since they use the same wire they cannot transmit at the same time!

So, two widely spread computer network types today that don’t use CSMA/CD are:

• local area networks connected with UTP cables – the Ethernet technology, when using UTP cables, allows full-duplex transmission, which means two stations will transmit and receive at the same time but on different wires, so without any interference
  PS: you can still get collisions on copper and fiber (different channels); you can also still get collisions on full-duplex if you use hubs instead of switches!
• wireless networks – because a wireless device cannot detect a receiving signal while transmitting, it uses the CSMA/Collision Avoidance scheme.

On the physical level…

So, the thing is: how does a NIC (network interface card) detect a collision?
Well, it appears that NICs detect collisions because they appear to be higher in signal amplitude than normal signals.
Thus, the current level when leaving the transmitter might be between 16 and 20 milliamperes, but the receiver will get back a stronger signal. But why is the receiver getting a stronger signal, aren’t the currents opposed one to each other?

In addition, what is the jam signal made up of? Does it’s amplitude need to be between some fixed values so the other stations know it’s a signal of a collision happening? If that’s so, can the emitting NIC know for sure the signal won’t attenuate too much as it propagates along the lines?

Hope I’ll get the answer to these questions soon and update this post…until then, mystery unsolved :)

Edit: well, it seems I was looking at the problem the wrong way…there are actually voltages on the wire, so when packets are put on the wire by the NIC, they have certain voltage levels, which obviously add up (0 and 1 bits are sent through the wire using different encodings, for example NRZI in the case of Ethernet).

My physics knowledge suck.

iframes

This is a good method to use, taking in account that most browsers will support it and it’s not too complicated…
So let’s say your page contains a basic form, like this one:

<form name="upload_form" target="hidden_frame" action="upload.php" enctype="multipart/form-data" method="post">
Attach a file:
<input id="file_upload" name="file_upload" type="file" onchange="document.uploadform.submit()" />
</form>

Now, when you will choose a file to upload, it will trigger the submit() function and it will run the script upload.php, targeted into the hidden iframe. So, the script will run without anybody seeing it.
Additionally, you can add an (initially) empty paragraph where the name of the file will appear after the upload has been completed, so the user will know it has been uploaded.

<iframe name="hidden_frame" style="display: none"></iframe>
<p id="filename"></p>

// UPLOAD_DIR is a constant holding the path to the upload folder
$path = UPLOAD_DIR.basename($_FILES['file_upload']['name']);

if (!move_uploaded_file($_FILES['file_upload']['tmp_name'], $path)) {
    echo "There was an error uploading the file!";
}
?>
<script language="javascript">
parent.document.getElementById('file_upload').innerHTML += 
  '<br/>
   <a href="<?php echo UPLOAD_DIR.$_FILES['file_upload']['name'] ?>">
   <?php echo $_FILES['filefieldname']['name'] ?>
   </a>';
</script>

parent.document.getElementById('file_upload').innerHTML = ...

The AJAX File Upload plugin

This is easier to implement than the previous one, but it involves using jQuery. So, for this one, you must download a version of jQuery and the AJAX File Upload plugin and include them in your index.html file.

<script type="text/javascript" src="../js/jquery1.2.js"></script>
<script type="text/javascript" src="../js/ajaxupload.3.5.js"></script>

<div id="files"></div>
<input name="btnFile" id="btnFile" type="button" value="Upload file" />
<p id="status_file" ></p>

$(function(){
  var fileUpload = $('#btnFile');
  var status = $('#status_file');
  new AjaxUpload(fileUpload, {
    action: 'upload.php',
    name: 'file',
    onSubmit: function(file, ext){
        status.html('<br/>Uploading...');
    },
    onComplete: function(file, response){
       status.text('');
       //Add uploaded file to list
       $('<p></p>').appendTo('#files').html('<img src="./uploads/'+file+'" alt="" /><br />'+file).addClass('success');
    }
  });
});

<?php
  $uploaddir = './uploads/'; 
  $file = $uploaddir.basename($_FILES['file']['name']); 
  move_uploaded_file($_FILES['file']['tmp_name'], $file);
?>

$('#files').html('<p class="success">
                    <a href="./uploads/'+file+'">'+file+'</a>
                    <br/>
                    <br/>
                  </p>');

SWFUpload

SWFUpload is a cute flash/javascript library that can handle multiple file uploads, allow you to choose what filetypes you want uploaded, shows upload progress and has client-side file size checking. Another cool thing is that it will degrade to a normal file input-field if flash/javascript isn’t allowed.
First, you have to download the library, from here.
Now let’s begin writing the code. So, for starters, you will have to create a SWFUpload object and set some of its parameters.

<script type="text/javascript">
		var swfu;

		window.onload = function() {
			var settings = {
				flash_url : "../swfupload/swfupload.swf",
				upload_url: "upload.php",
				post_params: {"PHPSESSID" : ""},
				file_size_limit : "100 MB",
				file_types : "*.*",
				file_types_description : "All Files",
				file_upload_limit : 100,
				file_queue_limit : 0,
				custom_settings : {
					progressTarget : "fsUploadProgress",
					cancelButtonId : "btnCancel"
				},
				debug: false,

				// Button settings
				button_image_url: "images/TestImageNoText_65x29.png",
				button_width: "65",
				button_height: "29",
				button_placeholder_id: "spanButtonPlaceHolder",
				button_text: '<span class="theFont">Upload</span>',
				button_text_style: ".theFont { font-size: 16; }",
				button_text_left_padding: 12,
				button_text_top_padding: 3,
				
				// event handler functions should be defined elsewhere
				file_queued_handler : fileQueued,
				file_queue_error_handler : fileQueueError,
				file_dialog_complete_handler : fileDialogComplete,
				upload_start_handler : uploadStart,
				upload_progress_handler : uploadProgress,
				upload_error_handler : uploadError,
				upload_success_handler : uploadSuccess,
				upload_complete_handler : uploadComplete,
				queue_complete_handler : queueComplete
			};

			swfu = new SWFUpload(settings);
	     };
</script>

<form id="form1" action="index.php" method="post" enctype="multipart/form-data">
  <div class="fieldset flash" id="fsUploadProgress">
    <span class="legend">Upload Queue</span>
  </div>
  <div id="divStatus">0 Files Uploaded</div>
  <div>
    <span id="spanButtonPlaceHolder"></span>
    <input id="btnCancel" type="button" value="Cancel All Uploads" onclick="swfu.cancelQueue();" disabled="disabled"     style="margin-left: 2px; font-size: 8pt; height: 29px;" />
  </div>
</form>

Also, you can find some useful demos of SWFUpload here.

Note: Unfortunately, the plugin doesn’t work on Linux operating systems, and Adobe’s workaround is “Use Mac OS or Windows OS to perform uploads, where the exact same SWF works fine”. I know, that’s nice. Check it out.

Other stuff

If you’re using ASP.NET, you could try this -> Ajax Uploader
If you’re using Java, you could try this -> DWR version 3.0
Haven’t tried them out, but looks promising.

On a future post, I’ll look more into those exceptions I was talking about: the real AJAX file uploads :)