mupnp 0.1

data/ext/upnpcommands.h

@@ -0,0 +1,179 @@
+/* $Id: upnpcommands.h,v 1.13 2008/02/18 13:27:24 nanard Exp $ */
+/* Miniupnp project : http://miniupnp.free.fr/
+ * Author : Thomas Bernard
+ * Copyright (c) 2005-2006 Thomas Bernard
+ * This software is subject to the conditions detailed in the
+ * LICENCE file provided within this distribution */
+#ifndef __UPNPCOMMANDS_H__
+#define __UPNPCOMMANDS_H__
+
+#include "upnpreplyparse.h"
+#include "declspec.h"
+
+/* MiniUPnPc return codes : */
+#define UPNPCOMMAND_SUCCESS (0)
+#define UPNPCOMMAND_UNKNOWN_ERROR (-1)
+#define UPNPCOMMAND_INVALID_ARGS (-2)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LIBSPEC unsigned int
+UPNP_GetTotalBytesSent(const char * controlURL,
+					const char * servicetype);
+
+LIBSPEC unsigned int
+UPNP_GetTotalBytesReceived(const char * controlURL,
+						const char * servicetype);
+
+LIBSPEC unsigned int
+UPNP_GetTotalPacketsSent(const char * controlURL,
+					const char * servicetype);
+
+LIBSPEC unsigned int
+UPNP_GetTotalPacketsReceived(const char * controlURL,
+					const char * servicetype);
+
+/* UPNP_GetStatusInfo()
+ * status and lastconnerror are 64 byte buffers
+ * Return values :
+ * UPNPCOMMAND_SUCCESS, UPNPCOMMAND_INVALID_ARGS, UPNPCOMMAND_UNKNOWN_ERROR
+ * or a UPnP Error code */
+LIBSPEC int
+UPNP_GetStatusInfo(const char * controlURL,
+			       const char * servicetype,
+				   char * status,
+				   unsigned int * uptime,
+                   char * lastconnerror);
+
+/* UPNP_GetConnectionTypeInfo()
+ * argument connectionType is a 64 character buffer
+ * Return Values :
+ * UPNPCOMMAND_SUCCESS, UPNPCOMMAND_INVALID_ARGS, UPNPCOMMAND_UNKNOWN_ERROR
+ * or a UPnP Error code */
+LIBSPEC int
+UPNP_GetConnectionTypeInfo(const char * controlURL,
+                           const char * servicetype,
+						   char * connectionType);
+
+/* UPNP_GetExternalIPAddress() call the corresponding UPNP method.
+ * if the third arg is not null the value is copied to it.
+ * at least 16 bytes must be available 
+ *
+ * Return values :
+ * 0 : SUCCESS
+ * NON ZERO : ERROR Either an UPnP error code or an unknown error.
+ * 
+ * possible UPnP Errors :
+ * 402 Invalid Args - See UPnP Device Architecture section on Control.
+ * 501 Action Failed - See UPnP Device Architecture section on Control. */
+LIBSPEC int
+UPNP_GetExternalIPAddress(const char * controlURL,
+                          const char * servicetype,
+                          char * extIpAdd);
+
+/* UPNP_GetLinkLayerMaxBitRates()
+ * call WANCommonInterfaceConfig:1#GetCommonLinkProperties
+ *
+ * return values :
+ * UPNPCOMMAND_SUCCESS, UPNPCOMMAND_INVALID_ARGS, UPNPCOMMAND_UNKNOWN_ERROR
+ * or a UPnP Error Code. */
+LIBSPEC int
+UPNP_GetLinkLayerMaxBitRates(const char* controlURL,
+							const char* servicetype,
+							unsigned int * bitrateDown,
+							unsigned int * bitrateUp);
+
+/* UPNP_AddPortMapping()
+ *
+ * Return values :
+ * 0 : SUCCESS
+ * NON ZERO : ERROR. Either an UPnP error code or an unknown error.
+ * 
+ * List of possible UPnP errors for AddPortMapping :
+ * errorCode errorDescription (short) - Description (long)
+ * 402 Invalid Args - See UPnP Device Architecture section on Control.
+ * 501 Action Failed - See UPnP Device Architecture section on Control.
+ * 715 WildCardNotPermittedInSrcIP - The source IP address cannot be
+ *                                   wild-carded
+ * 716 WildCardNotPermittedInExtPort - The external port cannot be wild-carded
+ * 718 ConflictInMappingEntry - The port mapping entry specified conflicts
+ *                     with a mapping assigned previously to another client
+ * 724 SamePortValuesRequired - Internal and External port values
+ *                              must be the same 
+ * 725 OnlyPermanentLeasesSupported - The NAT implementation only supports
+ *                  permanent lease times on port mappings
+ * 726 RemoteHostOnlySupportsWildcard - RemoteHost must be a wildcard
+ *                             and cannot be a specific IP address or DNS name
+ * 727 ExternalPortOnlySupportsWildcard - ExternalPort must be a wildcard and
+ *                                        cannot be a specific port value */
+LIBSPEC int
+UPNP_AddPortMapping(const char * controlURL, const char * servicetype,
+                    const char * extPort,
+				    const char * inPort,
+					const char * inClient,
+					const char * desc,
+                    const char * proto);
+
+/* UPNP_DeletePortMapping()
+ * Return Values :
+ * 0 : SUCCESS
+ * NON ZERO : error. Either an UPnP error code or an undefined error.
+ *
+ * List of possible UPnP errors for DeletePortMapping :
+ * 402 Invalid Args - See UPnP Device Architecture section on Control.
+ * 714 NoSuchEntryInArray - The specified value does not exist in the array */
+LIBSPEC int
+UPNP_DeletePortMapping(const char * controlURL, const char * servicetype,
+                       const char * extPort, const char * proto);
+
+/* UPNP_GetPortMappingNumberOfEntries()
+ * not supported by all routers */
+LIBSPEC int
+UPNP_GetPortMappingNumberOfEntries(const char* controlURL, const char* servicetype, unsigned int * num);
+
+/* UPNP_GetSpecificPortMappingEntry retrieves an existing port mapping
+ * the result is returned in the intClient and intPort strings
+ * please provide 16 and 6 bytes of data
+ *
+ * return value :
+ * UPNPCOMMAND_SUCCESS, UPNPCOMMAND_INVALID_ARGS, UPNPCOMMAND_UNKNOWN_ERROR
+ * or a UPnP Error Code. */
+LIBSPEC int
+UPNP_GetSpecificPortMappingEntry(const char * controlURL,
+                                 const char * servicetype,
+                                 const char * extPort,
+                                 const char * proto,
+                                 char * intClient,
+                                 char * intPort);
+
+/* UPNP_GetGenericPortMappingEntry()
+ *
+ * return value :
+ * UPNPCOMMAND_SUCCESS, UPNPCOMMAND_INVALID_ARGS, UPNPCOMMAND_UNKNOWN_ERROR
+ * or a UPnP Error Code.
+ *
+ * Possible UPNP Error codes :
+ * 402 Invalid Args - See UPnP Device Architecture section on Control.
+ * 713 SpecifiedArrayIndexInvalid - The specified array index is out of bounds
+ */
+LIBSPEC int
+UPNP_GetGenericPortMappingEntry(const char * controlURL,
+                                const char * servicetype,
+								const char * index,
+								char * extPort,
+								char * intClient,
+								char * intPort,
+								char * protocol,
+								char * desc,
+								char * enabled,
+								char * rHost,
+								char * duration);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

data/ext/upnperrors.c

@@ -0,0 +1,55 @@
+/* $Id: upnperrors.c,v 1.2 2008/02/05 12:50:22 nanard Exp $ */
+/* Project : miniupnp
+ * Author : Thomas BERNARD
+ * copyright (c) 2007 Thomas Bernard
+ * All Right reserved.
+ * This software is subjet to the conditions detailed in the
+ * provided LICENCE file. */
+#include <string.h>
+#include "upnperrors.h"
+
+const char * strupnperror(int err)
+{
+	const char * s = NULL;
+	switch(err) {
+	case 401:
+		s = "Invalid Action";
+		break;
+	case 402:
+		s = "Invalid Args";
+		break;
+	case 501:
+		s = "Action Failed";
+		break;
+	case 713:
+		s = "SpecifiedArrayIndexInvalid";
+		break;
+	case 714:
+		s = "NoSuchEntryInArray";
+		break;
+	case 715:
+		s = "WildCardNotPermittedInSrcIP";
+		break;
+	case 716:
+		s = "WildCardNotPermittedInExtPort";
+		break;
+	case 718:
+		s = "ConflictInMappingEntry";
+		break;
+	case 724:
+		s = "SamePortValuesRequired";
+		break;
+	case 725:
+		s = "OnlyPermanentLeasesSupported";
+		break;
+	case 726:
+		s = "RemoteHostOnlySupportsWildcard";
+		break;
+	case 727:
+		s = "ExternalPortOnlySupportsWildcard";
+		break;
+	default:
+		s = NULL;
+	}
+	return s;
+}

data/ext/upnperrors.h

@@ -0,0 +1,16 @@
+/* $Id: upnperrors.h,v 1.1 2007/12/22 11:28:04 nanard Exp $ */
+/* (c) 2007 Thomas Bernard
+ * All rights reserved.
+ * MiniUPnP Project.
+ * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
+ * This software is subjet to the conditions detailed in the
+ * provided LICENCE file. */
+#ifndef __UPNPERRORS_H__
+#define __UPNPERRORS_H__
+
+/* strupnperror()
+ * Return a string description of the UPnP error code 
+ * or NULL for undefinded errors */
+const char * strupnperror(int err);
+
+#endif

data/ext/upnpreplyparse.c

@@ -0,0 +1,127 @@
+/* $Id: upnpreplyparse.c,v 1.10 2008/02/21 13:05:27 nanard Exp $ */
+/* MiniUPnP project
+ * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
+ * (c) 2006 Thomas Bernard 
+ * This software is subject to the conditions detailed
+ * in the LICENCE file provided within the distribution */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "upnpreplyparse.h"
+#include "minixml.h"
+
+static void
+NameValueParserStartElt(void * d, const char * name, int l)
+{
+    struct NameValueParserData * data = (struct NameValueParserData *)d;
+    if(l>63)
+        l = 63;
+    memcpy(data->curelt, name, l);
+    data->curelt[l] = '\0';
+}
+
+static void
+NameValueParserGetData(void * d, const char * datas, int l)
+{
+    struct NameValueParserData * data = (struct NameValueParserData *)d;
+    struct NameValue * nv;
+    nv = malloc(sizeof(struct NameValue));
+    if(l>63)
+        l = 63;
+    strncpy(nv->name, data->curelt, 64);
+	nv->name[63] = '\0';
+    memcpy(nv->value, datas, l);
+    nv->value[l] = '\0';
+    LIST_INSERT_HEAD( &(data->head), nv, entries);
+}
+
+void
+ParseNameValue(const char * buffer, int bufsize,
+                    struct NameValueParserData * data)
+{
+    struct xmlparser parser;
+    LIST_INIT(&(data->head));
+    /* init xmlparser object */
+    parser.xmlstart = buffer;
+    parser.xmlsize = bufsize;
+    parser.data = data;
+    parser.starteltfunc = NameValueParserStartElt;
+    parser.endeltfunc = 0;
+    parser.datafunc = NameValueParserGetData;
+	parser.attfunc = 0;
+    parsexml(&parser);
+}
+
+void
+ClearNameValueList(struct NameValueParserData * pdata)
+{
+    struct NameValue * nv;
+    while((nv = pdata->head.lh_first) != NULL)
+    {
+        LIST_REMOVE(nv, entries);
+        free(nv);
+    }
+}
+
+char * 
+GetValueFromNameValueList(struct NameValueParserData * pdata,
+                          const char * Name)
+{
+    struct NameValue * nv;
+    char * p = NULL;
+    for(nv = pdata->head.lh_first;
+        (nv != NULL) && (p == NULL);
+        nv = nv->entries.le_next)
+    {
+        if(strcmp(nv->name, Name) == 0)
+            p = nv->value;
+    }
+    return p;
+}
+
+#if 0
+/* useless now that minixml ignores namespaces by itself */
+char *
+GetValueFromNameValueListIgnoreNS(struct NameValueParserData * pdata,
+                                  const char * Name)
+{
+	struct NameValue * nv;
+	char * p = NULL;
+	char * pname;
+	for(nv = pdata->head.lh_first;
+	    (nv != NULL) && (p == NULL);
+		nv = nv->entries.le_next)
+	{
+		pname = strrchr(nv->name, ':');
+		if(pname)
+			pname++;
+		else
+			pname = nv->name;
+		if(strcmp(pname, Name)==0)
+			p = nv->value;
+	}
+	return p;
+}
+#endif
+
+/* debug all-in-one function 
+ * do parsing then display to stdout */
+#ifdef DEBUG
+void
+DisplayNameValueList(char * buffer, int bufsize)
+{
+    struct NameValueParserData pdata;
+    struct NameValue * nv;
+    ParseNameValue(buffer, bufsize, &pdata);
+    for(nv = pdata.head.lh_first;
+        nv != NULL;
+        nv = nv->entries.le_next)
+    {
+        printf("%s = %s\n", nv->name, nv->value);
+    }
+    ClearNameValueList(&pdata);
+}
+#endif
+

data/ext/upnpreplyparse.h

@@ -0,0 +1,62 @@
+/* $Id: upnpreplyparse.h,v 1.8 2008/02/21 13:05:27 nanard Exp $ */
+/* MiniUPnP project
+ * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
+ * (c) 2006 Thomas Bernard 
+ * This software is subject to the conditions detailed
+ * in the LICENCE file provided within the distribution */
+
+#ifndef __UPNPREPLYPARSE_H__
+#define __UPNPREPLYPARSE_H__
+
+#if defined(NO_SYS_QUEUE_H) || defined(WIN32)
+#include "bsdqueue.h"
+#else
+#include <sys/queue.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct NameValue {
+    LIST_ENTRY(NameValue) entries;
+    char name[64];
+    char value[64];
+};
+
+struct NameValueParserData {
+    LIST_HEAD(listhead, NameValue) head;
+    char curelt[64];
+};
+
+/* ParseNameValue() */
+void
+ParseNameValue(const char * buffer, int bufsize,
+               struct NameValueParserData * data);
+
+/* ClearNameValueList() */
+void
+ClearNameValueList(struct NameValueParserData * pdata);
+
+/* GetValueFromNameValueList() */
+char *
+GetValueFromNameValueList(struct NameValueParserData * pdata,
+                          const char * Name);
+
+/* GetValueFromNameValueListIgnoreNS() */
+char *
+GetValueFromNameValueListIgnoreNS(struct NameValueParserData * pdata,
+                                  const char * Name);
+
+/* DisplayNameValueList() */
+#ifdef DEBUG
+void
+DisplayNameValueList(char * buffer, int bufsize);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

data/lib/UPnP.rb

@@ -0,0 +1,400 @@
+#! /usr/bin/ruby
+# Author: Dario Meloni <mellon85@gmail.com>
+# This module is a binding to the Thomas Bernard miniupnp library
+# written in C.  It supports the IGD specification and works with IPv4
+# only.  Every exception that comes from inside the library is report as
+# UPnPException while wrong arguments are returned as ArgumentError.
+
+require 'MiniUPnP'
+include ObjectSpace
+
+module UPnP
+    
+    # Represent a port mapping decriptor received from the router.
+    class PortMapping
+        # Internal address.
+        attr_reader :client
+
+        # Internal port.
+        attr_reader :lport
+
+        # External port.
+        attr_reader :nport
+
+        # External protocol.
+        attr_reader :protocol
+
+        # Provided description.
+        attr_reader :description
+
+        # Is the mapping enabled?.
+        attr_reader :enabled
+
+        # Don't know ...
+        attr_reader :rhost
+
+        # Duration of the binding.
+        attr_reader :duration
+
+        def initialize(cl,lp,np,p,d,e,rh,du)
+            @client = cl
+            @lport = lp
+            @nport = np
+            @protocol = p
+            @description = d
+            @enabled = e
+            @rhost = rh
+            @duration = du
+        end
+
+        def to_s()
+            return "#{@nport}->#{@client}:#{@lport} #{@protocol} for #{@duration} -- #{@description}"
+        end
+    end
+
+
+    # Enumeration of protocol values to pass to the library.
+    class Protocol
+        # TCP protcol
+        TCP = "TCP"
+
+        # UDP protocol
+        UDP = "UDP"
+    end
+
+    # Represents an exception from inside the library.
+    class UPnPException < Exception
+    end
+        
+
+    # The UPNP class represent the binding to the library.  It exports
+    # all the functions the library itself exports. 
+    class UPnP
+
+        # Max time to wait for a broadcast answer from the routers.
+        attr_reader :max_wait_time
+
+        # This will create a new UPnP instance.  max_wait is the maximum
+        # time the instance will wait for an answer from the router
+        # while seaching or it autodiscover to true will start a thread
+        # on the background to scan the network.  All the other
+        # functions are safe to be called in the meanwhile, they will
+        # just wait for the scan to end before operating.
+        def initialize(autodiscover=true,max_wait=1000)
+            if max_wait <= 0 then
+                raise ArgumentError, "Max wait time must be >= 1."
+            end
+            if !(autodiscover.is_a? TrueClass) &&
+               !(autodiscover.is_a? FalseClass) then
+                raise ArgumentError, "Autodiscover must be a boolean value."
+            end
+            @max_wait_time = max_wait
+            # start the discover process at the object initialization.
+            # until ruby2, this thread will block the ruby environment
+            # for the wait time.
+            if autodiscover then
+                @igd_thread = Thread.new { discoverIGD }
+            else
+                @igd_thread = nil
+            end
+            return nil
+        end
+
+        # This method will search for other routers in the network and
+        # will wait the specified number of milliseconds that can be
+        # ovveridden by the parameter.  It has currently (ruby 1.9) a
+        # limitation. As long as thread are cooperative the upnpDiscover
+        # function will block the ruby implementation waiting for the
+        # library.  If this will not be solved with ruby 2.0 the
+        # interface upnp_wrap.c needs to be hacked.  You can avoid to
+        # call this function if autodiscover is true.  If no router or
+        # no UPnP devices are found an UPnPException is thrown.
+        def discoverIGD(max_wait_time=@max_wait_time)
+            joinThread()
+            if max_wait_time <= 0 then
+                raise ArgumentError, "Max wait time must be >= 1"
+            end
+            @list = MiniUPnP.upnpDiscover(max_wait_time,nil,nil)
+            if @list == nil then
+                raise UPnPException.new,"No UPNP Device Found"
+            end
+            define_finalizer(@list,proc {|o| MiniUPnP.freeUPNPDevlist(o)})
+            
+            @urls = MiniUPnP::UPNPUrls.new
+            define_finalizer(@urls,proc {|o| MiniUPnP.FreeUPNPUrls(o)})
+            @data = MiniUPnP::IGDdatas.new
+            @lan = getCString()
+
+            r = MiniUPnP.UPNP_GetValidIGD(@list,@urls,@data,@lan,64);
+            if r == 0 || r == 3 then
+                raise UPnPException.new, "No IGD Found"
+            end
+            @lan = @lan.rstrip()
+            return nil
+        end
+
+        # Returns the ip of this client
+        def lanIP()
+            joinThread()
+            return @lan
+        end
+
+        # Returns the external network ip
+        def externalIP()
+            joinThread()
+            external_ip = getCString()
+            r = MiniUPnP.UPNP_GetExternalIPAddress(@urls.controlURL,
+                                @data.servicetype,external_ip)
+            if r != 0 then
+                raise UPnPException.new, "Error while retriving the external ip address. #{code2error(r)}."
+            end
+            return external_ip.rstrip()
+        end
+
+        # Returns the ip of the router
+        def routerIP()
+            joinThread()
+            @data.urlbase.sub(/^.*\//,"").sub(/\:.*/,"")
+        end
+
+        # Returns the status of the router which is an array of 3 elements.
+        # Connection status, Last error, Uptime.
+        def status()
+            joinThread()
+            lastconnerror = getCString()
+            status = getCString()
+            uptime = 0
+            begin
+                uptime_uint = MiniUPnP.new_uintp()
+                r = MiniUPnP.UPNP_GetStatusInfo(@urls.controlURL,
+                           @data.servicetype, status, uptime_uint,
+                           lastconnerror) != 0
+                if r != 0 then
+                    raise UPnPException.new, "Error while retriving status info. #{code2error(r)}."
+                end
+                uptime = MiniUPnP.uintp_value(uptime_uint)
+            rescue
+                raise
+            ensure
+                MiniUPnP.delete_uintp(uptime_uint)
+            end
+            return status.rstrip,lastconnerror.rstrip,uptime
+        end
+
+        # Router connection information
+        def connectionType()
+            joinThread()
+            type = getCString()
+            if MiniUPnP.UPNP_GetConnectionTypeInfo(@urls.controlURL,
+                       @data.servicetype,type) != 0 then
+                raise UPnPException.new, "Error while retriving connection info."
+            end
+            type.rstrip
+        end
+
+        # Total bytes sent from the router to external network
+        def totalBytesSent()
+            joinThread()
+            v = MiniUPnP.UPNP_GetTotalBytesSent(@urls.controlURL_CIF,
+                        @data.servicetype_CIF)
+            if v < 0 then
+                raise UPnPException.new, "Error while retriving total bytes sent."
+            end
+            return v
+        end
+
+        # Total bytes received from the external network.
+        def totalBytesReceived()
+            joinThread()
+            v = MiniUPnP.UPNP_GetTotalBytesReceived(@urls.controlURL_CIF,
+                        @data.servicetype_CIF)
+            if v < 0 then
+                raise UPnPException.new, "Error while retriving total bytes received."
+            end
+            return v
+        end
+        
+        # Total packets sent from the router to the external network.
+        def totalPacketsSent()
+            joinThread()
+            v = MiniUPnP.UPNP_GetTotalPacketsSent(@urls.controlURL_CIF,
+                        @data.servicetype_CIF);
+            if v < 0 then
+                raise UPnPException.new, "Error while retriving total packets sent."
+            end
+            return v
+        end
+        
+        # Total packets received from the router from the external network.
+        def totalPacketsReceived()
+            joinThread()
+            v = MiniUPnP.UPNP_GetTotalBytesSent(@urls.controlURL_CIF,
+                        @data.servicetype_CIF)
+            if v < 0 then
+                raise UPnPException.new, "Error while retriving total packets received."
+            end
+            return v
+        end
+
+        # Returns the maximum bitrates detected from the router (may be an
+        # ADSL router) The result is in bytes/s.
+        def maxLinkBitrates()
+            joinThread()
+            up, down = 0, 0
+            begin
+                up_p = MiniUPnP.new_uintp()
+                down_p = MiniUPnP.new_uintp()
+                if MiniUPnP.UPNP_GetLinkLayerMaxBitRates(@urls.controlURL_CIF,
+                                                         @data.servicetype_CIF,
+                                                         down_p,up_p) != 0 then
+                    raise UPnPException.new, "Error while retriving maximum link bitrates."
+                end
+                up = MiniUPnP.uintp_value(up_p)
+                down = MiniUPnP.uintp_value(down_p)
+            rescue
+                raise
+            ensure
+                MiniUPnP.delete_uintp(up_p)
+                MiniUPnP.delete_uintp(down_p)
+            end
+            return down,up
+        end
+
+        # An array of mappings registered on the router
+        def portMappings() 
+            joinThread()
+            i, r = 0, 0
+            mappings = Array.new
+            while r == 0 
+                rhost = getCString()
+                enabled = getCString()
+                duration = getCString()
+                description = getCString()
+                nport = getCString()
+                lport = getCString()
+                duration = getCString()
+                client = getCString()
+                protocol = getCString()
+
+                r = MiniUPnP.UPNP_GetGenericPortMappingEntry(@urls.controlURL,
+                                  @data.servicetype,i.to_s,nport,client,lport,
+                                  protocol,description,enabled,rhost,duration)
+                if r != 0 then
+                    break;
+                end
+                i = i+1
+                mappings << PortMapping.new(client.rstrip,lport.rstrip.to_i,
+                                  nport.rstrip.to_i,protocol.rstrip,
+                                  description.rstrip,enabled.rstrip,
+                                  rhost.rstrip,duration.rstrip)
+            end 
+            return  mappings
+        end
+
+        # Get the mapping registered for a specific port and protocol
+        def portMapping(nport,proto)
+            checkProto(proto)
+            checkPort(nport)
+            if nport.to_i == 0 then
+                raise ArgumentError, "Port must be an int value and greater then 0."
+            end
+            joinThread()
+            client = getCString()
+            lport = getCString()
+            if MiniUPnP.UPNP_GetSpecificPortMappingEntry(@urls.controlURL,
+                                     @data.servicetype, nport.to_s,proto,
+                                     client,lport) != 0 then
+                raise UPnPException.new, "Error while retriving the port mapping."
+            end
+            return client.rstrip, lport.rstrip.to_i
+        end
+
+        # Add a port mapping on the router.  Parametes are: network
+        # port, local port, description, protocol, ip address to
+        # register (or do not specify it to register for yours).
+        # Protocol must be Protocol::TCP or Protocol::UDP
+        def addPortMapping(nport,lport,proto,desc,client=nil)
+            checkProto(proto)
+            checkPort(nport)
+            checkPort(lport)
+            joinThread()
+            client ||= @lan if client == nil 
+            r = MiniUPnP.UPNP_AddPortMapping(@urls.controlURL,@data.servicetype,
+                                nport.to_s,lport.to_s,client,desc,proto)
+            if r != 0 then
+                raise UPnPException.new , "Failed add mapping: #{code2error(r)}."
+            end
+        end
+
+        # Delete the port mapping for specified network port and protocol
+        def deletePortMapping(nport,proto)
+            checkProto(proto)
+            checkPort(nport)
+            joinThread()
+            r = MiniUPnP.UPNP_DeletePortMapping(@urls.controlURL,@data.servicetype,
+                                               nport.to_s,proto)
+            if r != 0 then
+                raise UPnPException.new , "Failed delete mapping: #{code2error(r)}."
+            end
+        end
+
+        private
+
+        # Generates an empty string to use with the library
+        def getCString(len=128)
+            "\0"*len
+        end
+
+        # Method to wait until the scan is complete
+        def joinThread()
+            if @igd_thread != nil && Thread.current != @igd_thread then
+                @igd_thread.join()
+            end
+        end
+           
+        # Check that the protocol is a correct value
+        def checkProto(proto)
+            if proto != Protocol::UDP && proto != Protocol::TCP then
+                raise ArgumentError, "Unknown protocol #{proto}, only Protocol::TCP and Protocol::UDP are valid."
+            end
+        end
+
+        def checkPort(port)
+            iport = port.to_i
+            if port.to_i != port || iport < 1 || iport > 65535  then
+                raise ArgumentError, "Port must be an integer beetween 1 and 65535."
+            end
+        end
+
+        def code2error(code)
+             case code
+             when 402
+                 "402 Invalid Args"
+             when 501
+                 "501 Action Failed"
+             when 713
+                 "713 SpecifiedArrayIndexInvalid - The specified array index is out of bounds"
+             when 714
+                 "714 NoSuchEntryInArray - The specified value does not exist in the array"
+             when 715
+                 "715 WildCardNotPermittedInSrcIP - The source IP address cannot be wild-carded"
+             when 716
+                 "716 WildCardNotPermittedInExtPort - The external port cannot be wild-carded"
+             when 718
+                 "718 ConflictInMappingEntry - The port mapping entry specified conflicts with a mapping assigned previously to another client"
+             when 724 
+                 "724 SamePortValuesRequired - Internal and External port values must be the same"
+             when 725 
+                 "725 OnlyPermanentLeasesSupported - The NAT implementation only supports permanent lease times on port mappings"
+             when 726 
+                 "726 RemoteHostOnlySupportsWildcard - RemoteHost must be a wildcard and cannot be a specific IP address or DNS name"
+             when 727 
+                 "727 ExternalPortOnlySupportsWildcard - ExternalPort must be a wildcard and cannot be a specific port value"
+             else
+                 "Unknown Error - #{code2error(r)}"
+             end
+        end
+    
+    end
+end
+