git.meshlink.io Git - catta/blob - avahi-sharp/Utility.cs

   1 /***
   2   This file is part of avahi.
   3
   4   avahi is free software; you can redistribute it and/or modify it
   5   under the terms of the GNU Lesser General Public License as
   6   published by the Free Software Foundation; either version 2.1 of the
   7   License, or (at your option) any later version.
   8
   9   avahi is distributed in the hope that it will be useful, but WITHOUT
  10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  12   Public License for more details.
  13
  14   You should have received a copy of the GNU Lesser General Public
  15   License along with avahi; if not, write to the Free Software
  16   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  17   USA.
  18 ***/
  19
  20 using System;
  21 using System.Net;
  22 using System.Text;
  23 using System.Runtime.InteropServices;
  24 using Mono.Unix;
  25 using Mono.Unix.Native;
  26
  27 using Stdlib = Mono.Unix.Native.Stdlib;
  28
  29 namespace Avahi
  30 {
  31     internal class Utility
  32     {
  33         [DllImport ("libc")]
  34         private static extern int strlen (IntPtr ptr);
  35
  36         [DllImport ("avahi-common")]
  37         private static extern IntPtr avahi_address_snprint (IntPtr buf, int size, IntPtr address);
  38
  39         [DllImport ("avahi-common")]
  40         private static extern IntPtr avahi_address_parse (IntPtr str, Protocol proto, IntPtr ret);
  41
  42         public static string PtrToString (IntPtr ptr)
  43         {
  44             if (ptr == IntPtr.Zero)
  45                 return null;
  46
  47             int len = strlen (ptr);
  48             byte[] bytes = new byte[len];
  49             Marshal.Copy (ptr, bytes, 0, len);
  50             return Encoding.UTF8.GetString (bytes);
  51         }
  52
  53         public static string PtrToStringFree (IntPtr ptr)
  54         {
  55             if (ptr == IntPtr.Zero)
  56                 return null;
  57
  58             string ret = PtrToString (ptr);
  59             Free (ptr);
  60             return ret;
  61         }
  62
  63         public static byte[] StringToBytes (string str)
  64         {
  65             if (str == null)
  66                 return null;
  67
  68             return Encoding.UTF8.GetBytes (str + "\0"); // lame.
  69         }
  70
  71         private static IntPtr StringToPtr (string str)
  72         {
  73             if (str == null)
  74                 return IntPtr.Zero;
  75
  76             byte[] bytes = Utility.StringToBytes (str);
  77             IntPtr buf = Stdlib.malloc ((uint) bytes.Length + 1);
  78             Marshal.Copy (bytes, 0, buf, bytes.Length);
  79             Marshal.WriteByte (buf, bytes.Length, 0);
  80             return buf;
  81         }
  82
  83         public static void Free (IntPtr ptr)
  84         {
  85             Stdlib.free (ptr);
  86         }
  87
  88         public static IntPtr AddressToPtr (IPAddress address)
  89         {
  90             IntPtr straddr = Utility.StringToPtr (address.ToString ());
  91             IntPtr addrPtr = Stdlib.malloc (32);
  92             avahi_address_parse (straddr, Protocol.Unspecified, addrPtr);
  93             Utility.Free (straddr);
  94
  95             return addrPtr;
  96         }
  97
  98         public static IPAddress PtrToAddress (IntPtr ptr)
  99         {
 100             IPAddress address = null;
 101
 102             if (ptr != IntPtr.Zero) {
 103                 IntPtr buf = Stdlib.malloc (256);
 104                 IntPtr addrPtr = avahi_address_snprint (buf, 256, ptr);
 105                 address = IPAddress.Parse (Utility.PtrToString (addrPtr));
 106                 Utility.Free (addrPtr);
 107             }
 108
 109             return address;
 110         }
 111     }
 112 }