transmission 0.1.0

data/ext/platform.h

@@ -0,0 +1,63 @@
+/******************************************************************************
+ * $Id: platform.h 310 2006-06-09 19:53:35Z joshe $
+ *
+ * Copyright (c) 2005 Transmission authors and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *****************************************************************************/
+#ifndef TR_PLATFORM_H
+#define TR_PLATFORM_H 1
+
+#ifdef SYS_BEOS
+  #include <kernel/OS.h>
+  typedef thread_id tr_thread_t;
+  typedef sem_id    tr_lock_t;
+#else
+  #include <pthread.h>
+  typedef pthread_t       tr_thread_t;
+  typedef pthread_mutex_t tr_lock_t;
+#endif
+
+char * tr_getCacheDirectory();
+char * tr_getTorrentsDirectory();
+
+void tr_threadCreate ( tr_thread_t *, void (*func)(void *), void * arg );
+void tr_threadJoin   ( tr_thread_t * );
+void tr_lockInit     ( tr_lock_t * );
+void tr_lockClose    ( tr_lock_t * );
+
+static inline void tr_lockLock( tr_lock_t * l )
+{
+#ifdef SYS_BEOS
+    acquire_sem( *l );
+#else
+    pthread_mutex_lock( l );
+#endif
+}
+
+static inline void tr_lockUnlock( tr_lock_t * l )
+{
+#ifdef SYS_BEOS
+    release_sem( *l );
+#else
+    pthread_mutex_unlock( l );
+#endif
+}
+
+#endif

data/ext/r_transmission.c

@@ -0,0 +1,1135 @@
+#include <ruby.h>
+#include "transmission.h"
+
+#define VERSION "0.1"
+
+static VALUE cTransmission;
+static VALUE cTorrent;
+static VALUE cFileInfo;
+static VALUE cStat;
+
+static VALUE eTransmissionError;
+static VALUE eParseError;
+static VALUE eUnsupportedError;
+static VALUE eDuplicateError;
+static VALUE eTorrentError;
+
+typedef struct {
+    tr_handle_t *handle;
+    VALUE torrents;
+} r_transmission_t;
+
+typedef struct {
+    VALUE transmission;
+    tr_torrent_t *handle;
+    int flags;
+} r_torrent_t;
+
+#define TORRENT_CLOSED       0x1
+#define CLOSED(torrent) ((torrent)->flags & TORRENT_CLOSED)
+#define SET_CLOSED(torrent) (torrent)->flags |= TORRENT_CLOSED;
+
+#define STARTED(torrent) (tr_torrentStat((torrent)->handle)->status & TR_STATUS_ACTIVE)
+
+#define CHECK_TORRENT(torrent) if(CLOSED(torrent)) rb_raise(eTorrentError, "Torrrent is already closed.");
+
+static void r_torrent_close(r_torrent_t *);
+static VALUE r_torrent_get_folder(VALUE);
+static VALUE r_torrent_set_folder(VALUE, VALUE);
+
+static void
+r_transmission_mark(void *data)
+{
+    r_transmission_t *transmission;
+    
+    transmission = (r_transmission_t *) data;
+    rb_gc_mark(transmission -> torrents);
+}
+
+static void
+r_transmission_free(void *data)
+{
+    r_transmission_t *transmission;
+    r_torrent_t *torrent;
+    int i;
+    transmission = (r_transmission_t *) data;
+    for( i = 0; i < RARRAY(transmission->torrents)->len; i += 1 )
+    {
+        Data_Get_Struct(RARRAY(transmission->torrents)->ptr[i], r_torrent_t, torrent);
+        r_torrent_close(torrent);
+    }
+    tr_close(transmission->handle);
+    xfree(data);
+}
+
+static VALUE
+r_transmission_alloc(VALUE klass)
+{
+    tr_handle_t *handle;
+    r_transmission_t *transmission;
+    VALUE obj;
+    
+    handle = tr_init();
+    transmission = ALLOC(r_transmission_t);
+    transmission->handle = handle;
+    transmission->torrents = rb_ary_new();
+    obj = Data_Wrap_Struct(klass, r_transmission_mark, r_transmission_free, transmission);
+    return obj;
+}
+
+/*
+ *  call-seq:
+ *     Transmission.pref_directory -> string
+ * 
+ *  Returns the full path to a directory which can be used to store preferences.
+ *
+ */
+static VALUE
+r_transmission_pref_dir(VALUE self)
+{
+    return rb_str_new2(tr_getPrefsDirectory());
+}
+
+/*
+ *  call-seq:
+ *     transmission.bind_port = port -> port
+ * 
+ *  Sets a "starting" bind port. Everytime a torrent is started, the library tries to bind
+ *  this port, then the next one and so on until it is successful.
+ *
+ */
+static VALUE
+r_transmission_set_bind_port(VALUE self, VALUE port)
+{
+    r_transmission_t *transmission;
+    
+    Data_Get_Struct(self, r_transmission_t, transmission);
+    tr_setBindPort(transmission->handle, FIX2INT(port));
+    return port;
+}
+
+static void
+r_torrent_mark(void *data)
+{
+    r_torrent_t *torrent;
+    torrent = (r_torrent_t *)data;
+    rb_gc_mark(torrent->transmission);
+}
+
+static void
+r_torrent_free(void *data)
+{
+    r_torrent_t *torrent;
+    torrent = (r_torrent_t *) data;
+    r_torrent_close(torrent);
+    xfree(data);
+}
+
+/*
+ *  call-seq:
+ *     transmission.open(path) -> torrent
+ *
+ *  Opens and parses torrent file at 'path'. If the file exists and is a
+ *  valid torrent file, returns a Torrent instance and adds it to the list of
+ *  torrents (but doesn't start it). 
+ *
+ */
+static VALUE
+r_transmission_open(int argc, VALUE *argv, VALUE self)
+{
+    VALUE file, save = Qnil, saved = Qnil, excp, result;
+    r_transmission_t *transmission;
+    tr_torrent_t *torrent_h;
+    r_torrent_t *torrent;
+    int flags = 0;
+    int error = 0;
+    
+    rb_scan_args(argc, argv, "12", &file, &save, &saved);
+    
+    if( RTEST(save) && !RTEST(saved))
+        flags = TR_FSAVEPRIVATE;
+    
+    Data_Get_Struct(self, r_transmission_t, transmission);
+    
+    torrent_h = RTEST(saved) ? 
+        tr_torrentInitSaved(transmission->handle, StringValuePtr(file), flags, &error) :
+        tr_torrentInit(transmission->handle, StringValuePtr(file), flags, &error);
+    if(torrent_h == NULL) {
+        switch(error)
+        {
+            case TR_EINVALID:
+                excp = eParseError;
+                break;
+            case TR_EUNSUPPORTED:
+                excp = eUnsupportedError;
+                break;
+            case TR_EDUPLICATE:
+                excp = eDuplicateError;
+            case TR_EOTHER:
+            default:
+                excp = eTorrentError;
+        }
+        rb_raise(excp, "Failed to open torrent file");
+    }
+    torrent = ALLOC(r_torrent_t);
+    torrent->transmission = self;
+    torrent->handle = torrent_h;
+    torrent->flags = 0;
+    
+    result = Data_Wrap_Struct(cTorrent, r_torrent_mark, r_torrent_free, torrent);
+    rb_ary_push(transmission->torrents, result);
+    if(r_torrent_get_folder(result) == Qnil)
+        r_torrent_set_folder(result, rb_str_new2("."));
+    return result;
+}
+
+/*
+ *   call-seq:
+ *      transmission.size -> int
+ *
+ *   Returns the count of open torrents.
+ */
+static VALUE
+r_transmission_size(VALUE self)
+{
+    r_transmission_t *transmission;
+    Data_Get_Struct(self, r_transmission_t, transmission);
+    return INT2FIX(tr_torrentCount(transmission->handle));
+}
+
+static VALUE
+r_transmission_find(r_transmission_t *transmission, tr_torrent_t *h)
+{
+    r_torrent_t *torrent;
+    VALUE result;
+    int i;
+    for( i = 0; i < RARRAY(transmission->torrents)->len; i += 1 )
+    {
+        result = RARRAY(transmission->torrents)->ptr[i];
+        Data_Get_Struct(result, r_torrent_t, torrent);
+        if(torrent->handle == h && !CLOSED(torrent)) return result;
+    }
+    return Qnil;
+}
+
+
+static void
+r_transmission_each_i(tr_torrent_t *h, void *data)
+{
+    r_transmission_t *transmission;
+    VALUE torrent;
+    
+    transmission = (r_transmission_t *)data;
+    torrent = r_transmission_find(transmission, h);
+    if(torrent != Qnil) rb_yield(torrent);
+}
+
+/*
+ *   call-seq:
+ *      transmission.each {|torrent| ...} -> transmission
+ *
+ *   Iterate through all opened torrents.
+ */
+static VALUE
+r_transmission_each(VALUE self)
+{
+    r_transmission_t *transmission;
+    Data_Get_Struct(self, r_transmission_t, transmission);
+    
+    tr_torrentIterate(transmission->handle, r_transmission_each_i, (void *)transmission);
+    return self;
+}
+
+/*
+ *   call-seq:
+ *      transmission.rates -> [int, int]
+ *
+ *   Returns total download and upload rates.
+ */
+static VALUE
+r_transmission_rates(VALUE self)
+{
+    r_transmission_t *transmission;
+    float down, up;
+    
+    Data_Get_Struct(self, r_transmission_t, transmission);
+    tr_torrentRates(transmission->handle, &down, &up);
+    return rb_ary_new3(2, rb_float_new(down), rb_float_new(up));
+}
+
+/*
+ *   call-seq:
+ *      transmission.upload_limit = limit -> limit
+ *
+ *   Sets upload limit in Kb.
+ */
+static VALUE
+r_transmission_set_upload_limit(VALUE self, VALUE limit)
+{
+    r_transmission_t *transmission;
+    Data_Get_Struct(self, r_transmission_t, transmission);
+    tr_setUploadLimit(transmission->handle, FIX2INT(limit));
+    return limit;
+}
+
+/*
+ *   call-seq:
+ *      transmission.download_limit = limit -> limit
+ *
+ *   Sets download limit in Kb.
+ */
+static VALUE
+r_transmission_set_download_limit(VALUE self, VALUE limit)
+{
+    r_transmission_t *transmission;
+    Data_Get_Struct(self, r_transmission_t, transmission);
+    tr_setDownloadLimit(transmission->handle, FIX2INT(limit));
+    return limit;
+}
+
+static void
+r_torrent_close(r_torrent_t *torrent)
+{
+    r_transmission_t *transmission;
+    
+    if(CLOSED(torrent)) return;
+
+    Data_Get_Struct(torrent->transmission, r_transmission_t, transmission);
+
+    if(STARTED(torrent))
+        tr_torrentStop(torrent->handle);
+    
+    tr_torrentClose(transmission->handle, torrent->handle);
+    SET_CLOSED(torrent);
+}
+
+/*
+ *   call-seq:
+ *      torrent.remove(saved = false) -> nil
+ *
+ *   Removes torrent from the current session. If 'saved' parameter is true, 
+ *   it also deletes a private torrent copy if there is one.
+ */
+static VALUE
+r_torrent_remove(int argc, VALUE *argv, VALUE self)
+{
+    r_transmission_t *transmission;
+    r_torrent_t *torrent;
+    VALUE remove_saved = Qfalse;
+    
+    rb_scan_args(argc, argv, "01", &remove_saved);
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    Data_Get_Struct(torrent->transmission, r_transmission_t, transmission);
+    if(RTEST(remove_saved))
+        tr_torrentRemoveSaved(torrent->handle);
+    rb_ary_delete(transmission->torrents, self);
+    r_torrent_close(torrent);
+    return Qnil;
+}
+
+static char *
+r_torrent_scrape_error(int code)
+{
+    switch(code)
+    {
+        case TR_SCRAPE_RESOLVE:
+            return "Could not resolve address";
+        case TR_SCRAPE_CONNECT:
+            return "Could not connect to the tracker";
+        case TR_SCRAPE_READ:
+            return "Failed to read from the tracker";
+        default:
+            return "Failed to scrape the tracker";
+    }
+}
+
+/*
+ *   call-seq:
+ *      torrent.scrape -> [int, int]
+ *
+ *   Scrapes the tracker and returns a number of seeders and leechers.
+ */
+static VALUE
+r_torrent_scrape(VALUE self)
+{
+    r_torrent_t *torrent;
+    int seeders, leechers;
+    int ret_code;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    
+    if((ret_code = tr_torrentScrape(torrent->handle, &seeders, &leechers)) != 0)
+    {
+        rb_raise(eTorrentError, r_torrent_scrape_error(ret_code));
+    }
+    return rb_ary_new3(2, INT2FIX(seeders), INT2FIX(leechers));
+}
+
+static tr_info_t *
+r_torrent_info(VALUE self)
+{
+    r_torrent_t *torrent;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    return tr_torrentInfo(torrent->handle);
+}
+
+/*
+ *   call-seq:
+ *      torrent.file_name -> string
+ *
+ *   Returns file name of the torrent file.
+ */
+static VALUE
+r_torrent_file_name(VALUE self) 
+{
+    return rb_str_new2(r_torrent_info(self)->torrent);
+}
+
+/*
+ *   call-seq:
+ *      torrent.name -> string
+ *
+ *   Returns the description of the torrent file.
+ */
+static VALUE
+r_torrent_name(VALUE self) 
+{
+    return rb_str_new2(r_torrent_info(self)->name);
+}
+
+/*
+ *   call-seq:
+ *      torrent.hash_string -> string
+ *
+ *   Returns the hash string of the torrent file.
+ */
+static VALUE
+r_torrent_hash_string(VALUE self) 
+{
+    return rb_str_new2(r_torrent_info(self)->hashString);
+}
+
+/*
+ *   call-seq:
+ *      torrent.tracker_address -> string
+ *
+ *   Returns the tracker address.
+ */
+static VALUE
+r_torrent_tracker_address(VALUE self) 
+{
+    return rb_str_new2(r_torrent_info(self)->trackerAddress);
+}
+
+/*
+ *   call-seq:
+ *      torrent.tracker_port -> int
+ *
+ *   Returns the tracker port.
+ */
+static VALUE
+r_torrent_tracker_port(VALUE self) 
+{
+    return INT2FIX(r_torrent_info(self)->trackerPort);
+}
+
+/*
+ *   call-seq:
+ *      torrent.tracker_announce -> string
+ *
+ *   Returns the tracker announce address.
+ */
+static VALUE
+r_torrent_tracker_announce(VALUE self) 
+{
+    return rb_str_new2(r_torrent_info(self)->trackerAnnounce);
+}
+
+/*
+ *   call-seq:
+ *      torrent.piece_size -> int
+ *
+ *   Returns piece size in bytes.
+ */
+static VALUE
+r_torrent_piece_size(VALUE self) 
+{
+    return INT2FIX(r_torrent_info(self)->pieceSize);
+}
+
+/*
+ *   call-seq:
+ *      torrent.piece_count -> string
+ *
+ *   Returns piece count.
+ */
+static VALUE
+r_torrent_piece_count(VALUE self) 
+{
+    return INT2FIX(r_torrent_info(self)->pieceCount);
+}
+
+/*
+ *   call-seq:
+ *      torrent.total_size -> string
+ *
+ *   Returns the total size of all pieces in bytes.
+ */
+static VALUE
+r_torrent_total_size(VALUE self) 
+{
+    return ULONG2NUM(r_torrent_info(self)->totalSize);
+}
+
+/*
+ *   call-seq:
+ *      torrent.pieces -> array
+ *
+ *   Returns the array of pieces.
+ */
+static VALUE
+r_torrent_pieces(VALUE self) 
+{
+    VALUE *pieces;
+    tr_info_t *info;
+    VALUE result;
+    int i;
+    
+    info = r_torrent_info(self);
+    
+    pieces = ALLOC_N(VALUE, info->pieceCount);
+    for( i = 0; i < info->pieceCount; i += 1 )
+    {
+        pieces[i] = INT2FIX(info->pieces[i]);
+    }
+    
+    result = rb_ary_new4(info->pieceCount, pieces);
+    xfree(pieces);
+    return result;
+}
+
+/*
+ *   call-seq:
+ *      torrent.file_count -> int
+ *
+ *   Returns the total number of files for this torrent.
+ */
+static VALUE
+r_torrent_file_count(VALUE self) 
+{
+    return INT2FIX(r_torrent_info(self)->fileCount);
+}
+
+/*
+ *   call-seq:
+ *      torrent.files -> array
+ *
+ *   Returns the array of FileInfo.
+ */
+static VALUE
+r_torrent_files(VALUE self) 
+{
+    VALUE *files;
+    VALUE result;
+    tr_info_t *info;
+    tr_file_t *f;
+    int i;
+    
+    info = r_torrent_info(self);
+    
+    files = ALLOC_N(VALUE, info->fileCount);
+    for( i = 0; i < info->fileCount; i += 1 )
+    {
+        f = ALLOC(tr_file_t);
+        MEMCPY(f, &info->files[i], tr_file_t, 1);
+        files[i] = Data_Wrap_Struct(cFileInfo, NULL, xfree, f);
+    }
+    result = rb_ary_new4(info->fileCount, files);
+    xfree(files);
+    return result;
+}
+
+/*
+ *   call-seq:
+ *      torrent.stat -> Stat
+ *
+ *   Returns the stat of this torrent.
+ */
+static VALUE
+r_torrent_stat(VALUE self) 
+{
+    r_torrent_t *torrent;
+    tr_stat_t *stat;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    
+    stat = ALLOC(tr_stat_t);
+    MEMCPY(stat, tr_torrentStat(torrent->handle), tr_stat_t, 1);
+    return Data_Wrap_Struct(cStat, NULL, xfree, stat);
+}
+
+/*
+ *   call-seq:
+ *      torrent.folder -> string
+ *
+ *   Returns the path where torrent files will be stored.
+ */
+static VALUE
+r_torrent_get_folder(VALUE self) 
+{
+    r_torrent_t *torrent;
+    char *folder;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    
+    folder = tr_torrentGetFolder(torrent->handle);
+    if(folder)
+        return rb_str_new2(folder);
+    return Qnil;
+}
+
+/*
+ *   call-seq:
+ *      torrent.folder = folder -> folder
+ *
+ *   Changes the directory wher torrent file will be stored.
+ */
+static VALUE
+r_torrent_set_folder(VALUE self, VALUE file) 
+{
+    r_torrent_t *torrent;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    
+    tr_torrentSetFolder(torrent->handle, StringValuePtr(file));
+    return file;
+}
+
+/*
+ *   call-seq:
+ *      torrent.start -> nil
+ *
+ *   Starts the torrent downloading. The download is launched in a seperate thread,
+ *   therefore torrent.start returns immediately.
+ */
+static VALUE
+r_torrent_start(VALUE self) 
+{
+    r_torrent_t *torrent;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    
+    if(!STARTED(torrent))
+    {
+        tr_torrentStart(torrent->handle);
+    }
+    
+    return Qnil;
+}
+
+/*
+ *   call-seq:
+ *      torrent.stop -> nil
+ *
+ *   Stops the torrent downloading.
+ */
+static VALUE
+r_torrent_stop(VALUE self) 
+{
+    r_torrent_t *torrent;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    
+    if(STARTED(torrent))
+    {
+        tr_torrentStop(torrent->handle);
+    }
+    
+    return Qnil;
+}
+
+/*
+ *   call-seq:
+ *      torrent.active? -> bool
+ *
+ *   Returns true if torrent is in active state.
+ */
+static VALUE
+r_torrent_active(VALUE self)
+{
+    r_torrent_t *torrent;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    
+    return STARTED(torrent) ? Qtrue : Qfalse;
+}
+
+/*
+ *   call-seq:
+ *      torrent.closed? -> bool
+ *
+ *   Returns true if torrent is closed and can't be used anymore.
+ */
+static VALUE
+r_torrent_closed(VALUE self)
+{
+    r_torrent_t *torrent;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    
+    return CLOSED(torrent) ? Qtrue : Qfalse;
+}
+
+/*
+ *   call-seq:
+ *      torrent.availability(size) -> array of integers
+ *
+ *   Use this to draw an advanced progress bar which is 'size' pixels
+ *   wide. Returns an array of integer where each integer is set
+ *   to either -1 if we have the piece, otherwise it is set to the number
+ *   of connected peers who have the piece. 
+ */
+static VALUE
+r_torrent_availability(VALUE self, VALUE size)
+{
+    r_torrent_t *torrent;
+    int8_t *data;
+    VALUE *result_data;
+    VALUE result;
+    int length, i;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    CHECK_TORRENT(torrent);
+    
+    length = FIX2INT(size);
+    data = ALLOC_N(int8_t, length);
+    result_data = ALLOC_N(VALUE, length);
+    tr_torrentAvailability(torrent->handle, data, length);
+    for( i = 0; i < length; i += 1 )
+    {
+        result_data[i] = INT2FIX(data[i]);
+    }
+    result = rb_ary_new4(length, result_data);
+    xfree(data);
+    xfree(result_data);
+    return result;
+}
+
+/*
+ *   call-seq:
+ *      torrent.just_finished? -> bool
+ *
+ *   The first call after a torrent is completed returns true. Returns false
+ *   in other cases.
+ */
+static VALUE
+r_torrent_just_finished(VALUE self)
+{
+    r_torrent_t *torrent;
+    
+    Data_Get_Struct(self, r_torrent_t, torrent);
+    
+    return tr_getFinished(torrent->handle) ? Qtrue : Qfalse;
+}
+
+/*
+ *   call-seq:
+ *      file_info.name -> string
+ *
+ *   Returns the name of the file.
+ */
+static VALUE
+r_file_info_name(VALUE self)
+{
+    tr_file_t *file;
+    Data_Get_Struct(self, tr_file_t, file);
+    return rb_str_new2(file->name);
+}
+
+/*
+ *   call-seq:
+ *      file_info.size -> int
+ *
+ *   Returns the size of the file.
+ */
+static VALUE
+r_file_info_size(VALUE self)
+{
+    tr_file_t *file;
+    Data_Get_Struct(self, tr_file_t, file);
+    return INT2FIX(file->length);
+}
+
+/*
+ *   call-seq:
+ *      stat.status -> int
+ *
+ *   Returns the status of the torrent.
+ */
+static VALUE
+r_stat_status(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return INT2FIX(stat->status);
+}
+
+/*
+ *   call-seq:
+ *      stat.error -> int
+ *
+ *   Returns the error code of the torrent, 0 otherwise.
+ */
+static VALUE
+r_stat_error(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return INT2FIX(stat->error);
+}
+
+/*
+ *   call-seq:
+ *      stat.tracker_error -> string
+ *
+ *   Returns the tracker error or empty string.
+ */
+static VALUE
+r_stat_tracker_error(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return rb_str_new2(stat->trackerError);
+}
+
+/*
+ *   call-seq:
+ *      stat.progress -> float
+ *
+ *   Returns the progress of the torrent from 0.0 to 1.0.
+ */
+static VALUE
+r_stat_progress(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return rb_float_new(stat->progress);
+}
+
+/*
+ *   call-seq:
+ *      stat.down_rate -> float
+ *
+ *   Returns downloading rate.
+ */
+static VALUE
+r_stat_down_rate(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return rb_float_new(stat->rateDownload);
+}
+
+/*
+ *   call-seq:
+ *      stat.up_rate -> float
+ *
+ *   Returns uploading rate.
+ */
+static VALUE
+r_stat_up_rate(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return rb_float_new(stat->rateUpload);
+}
+
+/*
+ *   call-seq:
+ *      stat.rates -> [float, float]
+ *
+ *   Returns an array of downloading and uploading rates.
+ */
+static VALUE
+r_stat_rates(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return rb_ary_new3(2, rb_float_new(stat->rateDownload), rb_float_new(stat->rateUpload));
+}
+
+/*
+ *   call-seq:
+ *      stat.eta -> int
+ *
+ *   Returns eta until the torrent finishes downloading.
+ */
+static VALUE
+r_stat_eta(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return INT2FIX(stat->eta);
+}
+
+/*
+ *   call-seq:
+ *      stat.peers_total -> int
+ *
+ *   Returns the total number of peers.
+ */
+static VALUE
+r_stat_peers_total(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return INT2FIX(stat->peersTotal);
+}
+
+/*
+ *   call-seq:
+ *      stat.up_peers -> int
+ *
+ *   Returns a number of uploading peers.
+ */
+static VALUE
+r_stat_up_peers(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return INT2FIX(stat->peersUploading);
+}
+
+/*
+ *   call-seq:
+ *      stat.down_peers -> int
+ *
+ *   Returns a number of downloaded peers.
+ */
+static VALUE
+r_stat_down_peers(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return INT2FIX(stat->peersDownloading);
+}
+
+/*
+ *   call-seq:
+ *      stat.peers -> [int, int]
+ *
+ *   Returns an array of numbers of downloading and uploading peers.
+ */
+static VALUE
+r_stat_peers(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return rb_ary_new3(2, INT2FIX(stat->peersDownloading), INT2FIX(stat->peersUploading));
+}
+
+/*
+ *   call-seq:
+ *      stat.seeders -> int
+ *
+ *   Returns a number of seeders.
+ */
+static VALUE
+r_stat_seeders(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return INT2FIX(stat->seeders);
+}
+
+/*
+ *   call-seq:
+ *      stat.leechers -> int
+ *
+ *   Returns a number of leechers.
+ */
+static VALUE
+r_stat_leechers(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return INT2FIX(stat->leechers);
+}
+
+/*
+ *   call-seq:
+ *      stat.downloaded -> int
+ *
+ *   Returns the total number of downloaded bytes.
+ */
+static VALUE
+r_stat_downloaded(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return ULONG2NUM(stat->downloaded);
+}
+
+/*
+ *   call-seq:
+ *      stat.uploaded -> int
+ *
+ *   Returns the total number of uploaded bytes.
+ */
+static VALUE
+r_stat_uploaded(VALUE self)
+{
+    tr_stat_t *stat;
+    Data_Get_Struct(self, tr_stat_t, stat);
+    return ULONG2NUM(stat->uploaded);
+}
+
+/*
+ *   Document-class: Transmission::Torrent
+ *   
+ *   == Summary
+ *
+ *   The Torrent class represent a torrent instance. You can use this instance 
+ *   start and stop downloading process and keep track of its progress.
+ */
+static void
+Init_torrent()
+{
+    cTorrent = rb_define_class_under(cTransmission, "Torrent", rb_cObject);
+    rb_define_method(cTorrent, "remove", r_torrent_remove, -1);
+    rb_define_method(cTorrent, "scrape", r_torrent_scrape, 0);
+    rb_define_method(cTorrent, "file_name", r_torrent_file_name, 0);
+    rb_define_method(cTorrent, "name", r_torrent_name, 0);
+    rb_define_method(cTorrent, "hash_string", r_torrent_hash_string, 0);
+    rb_define_method(cTorrent, "tracker_addr", r_torrent_tracker_address, 0);
+    rb_define_method(cTorrent, "tracker_address", r_torrent_tracker_address, 0);
+    rb_define_method(cTorrent, "tracker_port", r_torrent_tracker_port, 0);
+    rb_define_method(cTorrent, "tracker_announce", r_torrent_tracker_announce, 0);
+    rb_define_method(cTorrent, "tracker_ann", r_torrent_tracker_announce, 0);
+    rb_define_method(cTorrent, "piece_size", r_torrent_piece_size, 0);
+    rb_define_method(cTorrent, "piece_count", r_torrent_piece_count, 0);
+    rb_define_method(cTorrent, "total_size", r_torrent_total_size, 0);
+    rb_define_method(cTorrent, "size", r_torrent_total_size, 0);
+    rb_define_method(cTorrent, "pieces", r_torrent_pieces, 0);
+    rb_define_method(cTorrent, "file_count", r_torrent_file_count, 0);
+    rb_define_method(cTorrent, "files", r_torrent_files, 0);
+    rb_define_method(cTorrent, "stat", r_torrent_stat, 0);
+    rb_define_method(cTorrent, "download_to", r_torrent_set_folder, 1);
+    rb_define_method(cTorrent, "folder", r_torrent_get_folder, 0);
+    rb_define_method(cTorrent, "folder=", r_torrent_set_folder, 1);
+    rb_define_method(cTorrent, "start", r_torrent_start, 0);
+    rb_define_method(cTorrent, "stop", r_torrent_stop, 0);
+    rb_define_method(cTorrent, "active?", r_torrent_active, 0);
+    rb_define_method(cTorrent, "closed?", r_torrent_closed, 0);
+    rb_define_method(cTorrent, "availability", r_torrent_availability, 1);
+    rb_define_method(cTorrent, "just_finished?", r_torrent_just_finished, 0);
+}
+
+/*
+ *   Document-class: Transmission::Torrent::FileInfo
+ *   
+ *   == Summary
+ *
+ *   The FileInfo class containts the information about a file which is part of this torrent.
+ */
+static void
+Init_fileinfo()
+{
+    cFileInfo = rb_define_class_under(cTorrent, "FileInfo", rb_cObject);
+    rb_define_method(cFileInfo, "name", r_file_info_name, 0);
+    rb_define_method(cFileInfo, "file_name", r_file_info_name, 0);
+    rb_define_method(cFileInfo, "size", r_file_info_size, 0);
+    rb_define_method(cFileInfo, "length", r_file_info_size, 0);
+}
+
+/*
+ *   Document-class: Transmission::Torrent::Stat
+ *   
+ *   == Summary
+ *
+ *   The Stat class containts the information about the torrent.
+ */
+static void
+Init_stat()
+{
+    cStat = rb_define_class_under(cTorrent, "Stat", rb_cObject);
+    rb_define_method(cStat, "status", r_stat_status, 0);
+    rb_define_method(cStat, "error", r_stat_error, 0);
+    rb_define_method(cStat, "tracker_error", r_stat_tracker_error, 0);
+    rb_define_method(cStat, "progress", r_stat_progress, 0);
+    rb_define_method(cStat, "rates", r_stat_rates, 0);
+    rb_define_method(cStat, "down_rate", r_stat_down_rate, 0);
+    rb_define_method(cStat, "up_rate", r_stat_up_rate, 0);
+    rb_define_method(cStat, "eta", r_stat_eta, 0);
+    rb_define_method(cStat, "peers_total", r_stat_peers_total, 0);
+    rb_define_method(cStat, "peers", r_stat_peers, 0);
+    rb_define_method(cStat, "up_peers", r_stat_up_peers, 0);
+    rb_define_method(cStat, "down_peers", r_stat_down_peers, 0);
+    rb_define_method(cStat, "seeders", r_stat_seeders, 0);
+    rb_define_method(cStat, "leechers", r_stat_leechers, 0);
+    rb_define_method(cStat, "downloaded", r_stat_downloaded, 0);
+    rb_define_method(cStat, "uploaded", r_stat_uploaded, 0);
+    
+    rb_define_const(cStat, "STATUS_CHECK", INT2FIX(TR_STATUS_CHECK));
+    rb_define_const(cStat, "STATUS_DOWNLOAD", INT2FIX(TR_STATUS_DOWNLOAD));
+    rb_define_const(cStat, "STATUS_SEED", INT2FIX(TR_STATUS_SEED));
+    rb_define_const(cStat, "STATUS_STOPPING", INT2FIX(TR_STATUS_STOPPING));
+    rb_define_const(cStat, "STATUS_STOPPED", INT2FIX(TR_STATUS_STOPPED));
+    rb_define_const(cStat, "STATUS_PAUSE", INT2FIX(TR_STATUS_PAUSE));
+    rb_define_const(cStat, "STATUS_ACTIVE", INT2FIX(TR_STATUS_ACTIVE));
+    rb_define_const(cStat, "STATUS_INACTIVE", INT2FIX(TR_STATUS_INACTIVE));
+    
+    rb_define_const(cStat, "ERR_TRACKER", INT2FIX(TR_ETRACKER));
+    rb_define_const(cStat, "ERR_INOUT", INT2FIX(TR_EINOUT));
+}
+
+/*
+ *   Document-class: Transmission
+ *   
+ *   == Summary
+ *
+ *   The Transmission class represent a bittorrent session. You can use an instance of
+ *   this class to open a torrent and start its downloading process.
+ */
+void
+Init_transmission()
+{
+    cTransmission = rb_define_class("Transmission", rb_cObject);
+
+    rb_define_const(cTransmission, "VERSION", rb_obj_freeze(rb_str_new2(VERSION)));
+
+    rb_define_module_function(cTransmission, "pref_directory", r_transmission_pref_dir, 0);
+    
+    rb_define_alloc_func(cTransmission, r_transmission_alloc);
+    rb_define_method(cTransmission, "bind_port=", r_transmission_set_bind_port, 1);
+    rb_define_method(cTransmission, "open", r_transmission_open, -1);
+    rb_define_method(cTransmission, "size", r_transmission_size, 0);
+    rb_define_method(cTransmission, "length", r_transmission_size, 0);
+    rb_define_method(cTransmission, "each", r_transmission_each, 0);
+    rb_define_method(cTransmission, "rates", r_transmission_rates, 0);
+    rb_define_method(cTransmission, "upload_limit=", r_transmission_set_upload_limit, 1);
+    rb_define_method(cTransmission, "download_limit=", r_transmission_set_download_limit, 1);
+    
+    rb_include_module(cTransmission, rb_mEnumerable);
+
+    eTransmissionError = rb_define_class_under(cTransmission, "TransmissionError", rb_eStandardError);
+    eParseError = rb_define_class_under(cTransmission, "ParseError", eTransmissionError);
+    eUnsupportedError = rb_define_class_under(cTransmission, "UnsupportedError", eTransmissionError);
+    eDuplicateError = rb_define_class_under(cTransmission, "DuplicateError", eTransmissionError);
+    eTorrentError = rb_define_class_under(cTransmission, "TorrentError", eTransmissionError);
+    
+    Init_torrent();
+    Init_fileinfo();
+    Init_stat();
+}