-/* $Id$ */
-
/***
This file is part of avahi.
using System.Threading;
using System.Collections;
using System.Runtime.InteropServices;
+using Mono.Unix;
+using Mono.Unix.Native;
+
+using Stdlib = Mono.Unix.Native.Stdlib;
namespace Avahi
{
internal enum ResolverEvent {
Found,
- Timeout
+ Failure
}
-
+
internal enum BrowserEvent {
Added,
- Removed
+ Removed,
+ CacheExhausted,
+ AllForNow,
+ Failure
}
internal delegate int PollCallback (IntPtr ufds, uint nfds, int timeout);
internal delegate void ClientCallback (IntPtr client, ClientState state, IntPtr userData);
- public delegate void ClientStateHandler (object o, ClientState state);
+ public delegate void ClientStateHandler (object o, ClientStateArgs state);
+
+ public class ClientStateArgs : EventArgs
+ {
+ private ClientState state;
+ private ErrorCode error;
+
+ public ClientState State
+ {
+ get { return state; }
+ }
+
+ public ErrorCode Error
+ {
+ get { return error; }
+ }
+
+ public ClientStateArgs (ClientState state, ErrorCode error)
+ {
+ this.state = state;
+ this.error = error;
+ }
+ }
public enum Protocol {
Unspecified = -1,
IPv4 = 0,
IPv6 = 1
}
-
- public enum ClientState {
+
+ internal enum ServerState {
Invalid,
Registering,
Running,
- Collision,
- Disconnected = 100
+ Collision
+ }
+
+ public enum ClientState {
+ Registering = ServerState.Registering,
+ Running = ServerState.Running,
+ Collision = ServerState.Collision,
+ Failure = 100,
+ Connecting = 101
}
[Flags]
None = 0,
UseWideArea = 1,
UseMulticast = 2,
- NoTxt = 4,
+ NoTxt = 4,
NoAddress = 8
}
None = 0,
Cached = 1,
WideArea = 2,
- Multicast = 4
+ Multicast = 4,
+ Local = 8,
+ OurOwn = 16,
}
-
+
+ [Flags]
+ public enum ClientFlags {
+ None = 0,
+ IgnoreUserConfig = 1,
+ NoFail = 2
+ }
+
public class Client : IDisposable
{
private IntPtr handle;
private Thread thread;
[DllImport ("avahi-client")]
- private static extern IntPtr avahi_client_new (IntPtr poll, ClientCallback handler,
+ private static extern IntPtr avahi_client_new (IntPtr poll, ClientFlags flags, ClientCallback handler,
IntPtr userData, out int error);
[DllImport ("avahi-client")]
[DllImport ("avahi-client")]
private static extern int avahi_client_errno (IntPtr handle);
-
+
[DllImport ("avahi-common")]
private static extern IntPtr avahi_simple_poll_new ();
private static extern void avahi_simple_poll_free (IntPtr spoll);
[DllImport ("avahi-common")]
- private static extern int avahi_simple_poll_iterate (IntPtr spoll, int timeout);
+ private static extern int avahi_simple_poll_loop (IntPtr spoll);
[DllImport ("avahi-common")]
private static extern void avahi_simple_poll_set_func (IntPtr spoll, PollCallback cb);
[DllImport ("avahi-client")]
private static extern uint avahi_client_get_local_service_cookie (IntPtr client);
- [DllImport ("avahi-client")]
- private static extern int avahi_client_is_service_local (IntPtr client, int iface, Protocol proto,
- IntPtr name, IntPtr type, IntPtr domain);
+ [DllImport ("avahi-common")]
+ private static extern int avahi_service_name_join (IntPtr buf, int len, byte[] name, byte[] type,
+ byte[] domain);
+
+ [DllImport ("avahi-common")]
+ private static extern int avahi_service_name_split (byte[] service, IntPtr name, int name_len,
+ IntPtr type, int type_len,
+ IntPtr domain, int domain_len);
[DllImport ("libc")]
{
get { return handle; }
}
-
+
public string Version
{
get {
}
}
- internal int LastError
+ internal ErrorCode LastError
{
get {
lock (this) {
- return avahi_client_errno (handle);
+ return (ErrorCode) avahi_client_errno (handle);
}
}
}
- public Client ()
+ public Client (ClientFlags flags)
{
spoll = avahi_simple_poll_new ();
cb = OnClientCallback;
int error;
- handle = avahi_client_new (poll, cb, IntPtr.Zero, out error);
+ handle = avahi_client_new (poll, flags, cb, IntPtr.Zero, out error);
if (error != 0)
throw new ClientException (error);
thread.Start ();
}
+ public Client () : this (ClientFlags.None) {
+ }
+
~Client ()
{
Dispose ();
public void Dispose ()
{
- lock (this) {
- if (handle != IntPtr.Zero) {
- thread.Abort ();
-
+ if (handle != IntPtr.Zero) {
+ lock (this) {
avahi_client_free (handle);
+ handle = IntPtr.Zero;
+
avahi_simple_poll_quit (spoll);
+ Monitor.Wait (this);
+
avahi_simple_poll_free (spoll);
- handle = IntPtr.Zero;
}
}
}
- public bool IsServiceLocal (ServiceInfo service)
+ public static string JoinServiceName (string name, string type, string domain)
{
- return IsServiceLocal (service.NetworkInterface, service.Protocol, service.Name,
- service.ServiceType, service.Domain);
+ int len = 4 * (name.Length + type.Length + domain.Length) + 4;
+ IntPtr buf = Stdlib.malloc ((ulong) len);
+
+ int ret = avahi_service_name_join (buf, len,
+ Utility.StringToBytes (name),
+ Utility.StringToBytes (type),
+ Utility.StringToBytes (domain));
+
+ if (ret < 0) {
+ Utility.Free (buf);
+ return null; // FIXME, should throw exception
+ }
+
+ string service = Utility.PtrToString (buf);
+ Utility.Free (buf);
+
+ return service;
}
- public bool IsServiceLocal (int iface, Protocol proto, string name, string type, string domain)
+ public static void SplitServiceName (string service, out string name, out string type, out string domain)
{
- IntPtr namePtr = Utility.StringToPtr (name);
- IntPtr typePtr = Utility.StringToPtr (type);
- IntPtr domainPtr = Utility.StringToPtr (domain);
-
- int result = avahi_client_is_service_local (handle, iface, proto, namePtr, typePtr, domainPtr);
+ int len = 1024;
+
+ IntPtr namePtr = Stdlib.malloc ((ulong) len);
+ IntPtr typePtr = Stdlib.malloc ((ulong) len);
+ IntPtr domainPtr = Stdlib.malloc ((ulong) len);
+
+ int ret = avahi_service_name_split (Utility.StringToBytes (service), namePtr, len, typePtr, len,
+ domainPtr, len);
+
+ if (ret < 0) {
+ Utility.Free (namePtr);
+ Utility.Free (typePtr);
+ Utility.Free (domainPtr);
+
+ name = null;
+ type = null;
+ domain = null;
+ return;
+ }
+
+ name = Utility.PtrToString (namePtr);
+ type = Utility.PtrToString (typePtr);
+ domain = Utility.PtrToString (domainPtr);
Utility.Free (namePtr);
Utility.Free (typePtr);
Utility.Free (domainPtr);
-
- return result == 1;
}
- internal void CheckError ()
+ internal void ThrowError ()
{
- int error = LastError;
+ ErrorCode error = LastError;
- if (error != 0)
+ if (error != ErrorCode.Ok)
throw new ClientException (error);
}
-
+
private void OnClientCallback (IntPtr client, ClientState state, IntPtr userData)
{
if (StateChanged != null)
- StateChanged (this, state);
+ StateChanged (this, new ClientStateArgs (state, LastError));
}
private int OnPollCallback (IntPtr ufds, uint nfds, int timeout) {
private void PollLoop () {
try {
lock (this) {
- while (true) {
- if (avahi_simple_poll_iterate (spoll, -1) != 0)
- break;
- }
+ avahi_simple_poll_loop (spoll);
+ Monitor.Pulse (this);
}
- } catch (ThreadAbortException e) {
} catch (Exception e) {
Console.Error.WriteLine ("Error in avahi-sharp event loop: " + e);
}
projects / catta / blobdiff